th#1803: the consumer half of the layout gate — a decoder that DECLARES hf.fp8-blockwise@1

[PaulFidika]

tensorhub 226070fd (th#1803, PR #1046) made the tensor-layout contract enforceable at rebind — a binding whose artifact bytes no decoder in the target image declares is refused with a typed 422, no pod bought. It refused the H3 fp8 conditioner rebind correctly: nothing in any image declared hf.fp8-blockwise@1, the contract tensorhub transcribed from that artifact's own 165,264 header bytes.

This is the consumer half: the declaration, and the loader that makes it true.

What lands

• models/hf_fp8_blockwise.py — transformers' FineGrainedFP8 / DeepSeek-style layout: fp8 e4m3 [out,in] weights, a weight_scale_inv F32 grid at one scale per 128×128 block, applied as a multiplier (verified against transformers==5.13.1's own _dequantize_one, not inferred from the _inv suffix). resident=True keeps fp8 and runs the blockwise GEMM (fp8-w8a8-dynamic); resident=False upcasts ahead at load (fp8-w8a16, the portable/CPU arm).
• @implements_contract(contract="hf.fp8-blockwise@1", …) on the loader, so the image's build-time derivation carries it into release_execution_lanes and the hub's Satisfies comparison can succeed for the first time.
• inspect_hf_fp8_blockwise — verification from safetensors HEADERS ALONE, before any weight byte is read.
• dequantize_block_scaled — the registry's declared hf.fp8_blockwise.dequant@1 reference dequant. §1.33 makes this the function a lossless conversion must prove bit-exactness against, so it exists once.

Why the refusals matter more than the load

cozy.fp8-rowwise@1 is also "fp8 e4m3 with dynamic activations" — same element type, same activation scheme, one English name. Its scale leaf is weight_scale, rank 1, per ROW. A decoder that reads a 128×128 reciprocal grid as a per-row multiplier broadcasts one scale across the wrong span: no exception, plausible numbers, wrong. So a rowwise tree is refused by name, and so are a transposed/mis-blocked grid, an fp8 weight with no scale, a rank-1 scale, and a config that disagrees with the bytes.

The pair is PRODUCIBLE, not CONVERTIBLE (DESIGN-RULINGS §1.33): re-blocking rowwise scales is a re-quantization with new numerics, so the remedy named in the refusal is a conversion-endpoint artifact, never a load-time repack.

No quantization happens in this path (Paul, 2026-08-11, th#1803 follow-up 2): quantization is ahead-of-time via conversion endpoints, never at cold boot. There is deliberately no quantize-if-missing fallback.

Proof (no mocks, CPU, ~9s)

tests/test_hf_fp8_blockwise_th1803.py builds a real tiny Llama, quantizes it to the layout, writes real safetensors + the same quantization_config shape the published conditioner carries, and loads it back through the declaring loader:

1. the tree verifies from headers, with the block grid derived per unit (down_proj [128,256] → scale [1,2]);
2. loaded weights are bit-identical to the reference dequant, and within fp8 error of the pre-quantization weights — which is what separates the multiply convention from its reciprocal (a divide is ~1e5 out, not 4%);
3. a real forward produces finite logits;
4. rowwise / transposed-grid / dense trees are each refused, by name;
5. derive_execution_lanes() carries hf.fp8-blockwise@1 with this decoder.

Files: one new module, one new test, one line-group in tensor_layout_contract.py's handle list. No sibling lane touches these paths.

Follow-up in this lane: the decode proof on the real 27.6 GB artifact on a pod, recorded on th#1803.