model card: single-pass build, retract double-quant caveat

README.md

@@ -108,32 +108,42 @@ offloaded to CPU after encoding — it runs once per prompt, not once per sampli
 
 ## How `pruned_nvfp4` was built
 
-The obvious tool does **not** work. The StarNodes model converter passes non-floating-point
-tensors through untouched:
+**Single pass from `pruned_bf16`.** Comfy-Org's `minimax_h3_{ref2va,fl2va}_pruned_bf16`
+(40.2 GB) is full-precision weights with AdaLN already refactored into the timestep table, so
+the 200 attn/mlp layers are quantized once, straight from bf16:
 
 ```python
-if not tensor.dtype.is_floating_point:
-    return tensor          # already-int8 weights are copied verbatim
+nq, nparams = ckt.TensorCoreNVFP4Layout.quantize(w.contiguous())      # bf16 -> NVFP4
+tensors = ckt.TensorCoreNVFP4Layout.state_dict_tensors(nq, nparams)
 ```
 
-so running it on an int8 checkpoint silently produces a byte-identical file. A real
-dequantize -> requantize is required. `comfy-kitchen` exposes both halves:
+The layer set is `blocks.<N>.{attn.qkv_proj, attn.out_proj, mlp.fc1, mlp.fc2}.weight` — 50
+blocks x 4 = 200, verified set-identical to the layers Comfy-Org quantize in their
+`pruned_int8_convrot` release. Everything else (AdaLN, norms, embedders, token_refiner, all
+biases) is copied verbatim at source precision: 332 tensors, 1132 in the output.
+
+Per-layer config lives in a `comfy_quant` uint8 tensor holding JSON, written as
+`{"format": "nvfp4"}`; there is no file-level `__metadata__`.
+
+Full script: `bf16_to_nvfp4.py` in this repo. 200 layers in ~5 seconds on one GPU.
+
+<details>
+<summary>Earlier builds requantized from int8 (superseded)</summary>
+
+Before Comfy-Org published a pruned bf16 checkpoint, the only pruned source was
+`pruned_int8_convrot`, so these files were built bf16 -> int8_convrot (Comfy-Org) -> NVFP4 —
+two lossy passes whose error compounds. That path needed a real dequantize -> requantize,
+because the StarNodes model converter passes non-floating-point tensors through untouched:
 
 ```python
-params = ckt.TensorWiseINT8Layout.Params(
-    scale=weight_scale, orig_dtype=torch.bfloat16, orig_shape=qdata.shape,
-    is_weight=True, convrot=True, convrot_groupsize=256)
-deq = ckt.TensorWiseINT8Layout.dequantize(qdata, params)              # -> bf16
-nq, nparams = ckt.TensorCoreNVFP4Layout.quantize(deq.contiguous())    # -> NVFP4
-tensors = ckt.TensorCoreNVFP4Layout.state_dict_tensors(nq, nparams)
+if not tensor.dtype.is_floating_point:
+    return tensor          # already-int8 weights are copied verbatim
 ```
 
-Per-layer config lives in a `comfy_quant` uint8 tensor holding JSON, e.g.
-`{"format": "int8_tensorwise", "convrot": true, "convrot_groupsize": 256}`, rewritten to
-`{"format": "nvfp4"}` on output. Note `quantize()` requires bf16/fp16 — float32 raises
-`Unsupported dtype code`.
-
-Full script: `pruned_to_nvfp4.py` in this repo. 200 layers, ~6 seconds on one GPU.
+so running it on an int8 checkpoint silently produced a byte-identical file. The old script
+(`pruned_to_nvfp4.py`) is kept for reference. Both files were rebuilt single-pass on
+2026-08-05; the output key set and dtype census are unchanged, only the error path is.
+</details>
 
 ## Prompting: H3 wants a structured IR, not prose
 
@@ -217,6 +227,10 @@ frame `length` must satisfy 17n+5.
   VRAM (~20 GB vs ~12 GB) and can spend ~14% more time per step, Comfy-Org's
   `pruned_int8_convrot` may be the better choice. This repo's value is smallest-footprint
   and fastest, not highest-fidelity.
+- **That observation predates the single-pass rebuild and has not been repeated since.** It
+  was made against the doubly-quantized files, so some of the smearing may have been
+  compounding error rather than 4-bit weights. Treat the int8-is-better lead as untested
+  against the current files.
 - That comparison is **not controlled**: the two runs also differed in text encoder
   (nvfp4_awq vs int8_convrot), it was n=1, and matched seeds do not produce matched
   trajectories across different quantization. Treat it as a lead, not a result.
@@ -226,9 +240,9 @@ frame `length` must satisfy 17n+5.
 - 15s (362 frames) generates fine; see the VRAM note below.
 - The **`fl2va` file is unbenchmarked** — it was produced by the same script over the same
   layer set as `ref2va`, but has not been run end-to-end.
-- `pruned_nvfp4` is **doubly quantized** (bf16 -> int8_convrot by Comfy-Org -> NVFP4 here).
-  Error from both passes compounds. It held up in testing, but that is a real caveat.
-- Benchmarks are single-GPU, one card, one resolution.
+- Benchmarks are single-GPU, one card, one resolution, and were measured on the older
+  doubly-quantized files. Size and layout are unchanged by the rebuild, so s/it and VRAM
+  should carry over, but they have not been re-measured.
 
 Failure cases are welcome in the discussions tab — concrete artifacts beat aggregate scores.