Add native Ref2VA PDD bake WITH HEADS; label previous bake WITHOUT HEADS

Publish the 32-head video/audio bank in the ComfyUI #17157 checkpoint format. Preserve all 1031 trunk tensors and rename the existing trunk-only bake without changing its bytes. Include native usage instructions, converter and numerical validation.

README.md

@@ -1,107 +1,141 @@
 ---
-license: apache-2.0
+license: other
+license_name: minimax-h3-community-license-agreement
+license_link: https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/LICENSE
 base_model:
 - alibaba-pai/MiniMax-H3-Acc-LoRAs
 - MiniMaxAI/MiniMax-H3
 pipeline_tag: text-to-video
 tags:
 - comfyui
-- lora
 - minimax-h3
 - video
 - audio
 - distillation
+- pdd
 ---
 
-# MiniMax-H3 Acc LoRAs — ComfyUI conversion
+# MiniMax H3 PDD — ComfyUI LoRAs and baked Ref2VA checkpoints
 
-ComfyUI-key repackaging of the **official
-[alibaba-pai/MiniMax-H3-Acc-LoRAs](https://huggingface.co/alibaba-pai/MiniMax-H3-Acc-LoRAs)**
-8-step PDD acceleration LoRAs for [MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) —
-full audio+video generation in **8 (or 4) sampler steps, CFG-free**.
+ComfyUI conversions of the official
+[Alibaba PAI MiniMax-H3 PDD acceleration weights](https://huggingface.co/alibaba-pai/MiniMax-H3-Acc-LoRAs).
+The Ref2VA checkpoints generate video and audio from reference conditioning.
 
-**These are not plain LoRAs.** Each file carries a rank-64 trunk LoRA **plus** a Parallel
-Decoding Distillation head bank (32 per-interval final-layer projections per modality,
-[PDD — arXiv:2607.26004](https://arxiv.org/abs/2607.26004)). Loading them requires the
-companion custom node pack:
-
-➡️ **[Jalen-Brunson/ComfyUI-MiniMax-H3-PDD-Acc](https://github.com/Jalen-Brunson/ComfyUI-MiniMax-H3-PDD-Acc)**
-(also loads the original alibaba-pai files directly — this repo just saves you the in-memory
-conversion and gives you inspectable standard LoRA keys).
+**There are now two baked Ref2VA checkpoints: WITH HEADS and WITHOUT HEADS.**
+The new **with-heads** file contains the merged trunk and both PDD output-head banks.
+It loads through native ComfyUI after
+[PR #17157](https://github.com/Comfy-Org/ComfyUI/pull/17157), merged October 18, 2026,
+without a separate PDD acceleration LoRA or PDD Apply node.
 
 ## Files
 
-| File | What it is | sha256 |
+| File | Contents | Runtime |
 |---|---|---|
-| `minimax_h3_fl2va_pdd_acc_8step_comfyui.safetensors` | LoRA + head bank for **FL2VA** trunk | `1dce71b9…5cda0ea` |
-| `minimax_h3_ref2va_pdd_acc_8step_comfyui.safetensors` | LoRA + head bank for **Ref2VA** trunk | `5531fa0d…bdc78a1` |
-| `minimax_h3_ref2va_pdd_acc_8step_baked_int8_convrot.safetensors` | full **Ref2VA** int8-convrot checkpoint, trunk LoRA **pre-merged** — for cards that can't fully load the model ([see below](#baked-ref2va-trunk-for-cards-that-cant-fully-load-the-model)) | `fe8e58d8…cd1e111e` |
-
-Put the LoRA files in `ComfyUI/models/pdd_acc/`. Pair FL2VA with an fl2va UNET, Ref2VA with
-ref2va (bf16 or int8-convrot builds both work). The baked checkpoint goes in
-`ComfyUI/models/diffusion_models/` instead.
-
-## Usage (recipe is mandatory)
-
-`UNETLoader → MiniMaxH3SigmaShift (12/3) → MiniMax H3 PDD Acc LoRA (Apply) → BasicGuider (CFG 1.0)`,
-sampler **euler**, sigmas = **the Apply node's sigmas output** (the trained PDD block
-boundaries) into `SamplerCustomAdvanced`. Strengths 1.0, `nfe` 8 (4 is also official). Remove
-other distill LoRAs (turbo); don't stack step-caching nodes. A ready-to-run workflow ships in
-the node pack's `example_workflows/`.
-
-## Baked Ref2VA trunk (for cards that can't fully load the model)
-
-`minimax_h3_ref2va_pdd_acc_8step_baked_int8_convrot.safetensors` (34 GB) is
-[Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3)'s
-`minimax_h3_ref2va_int8_convrot` checkpoint with this repo's Ref2VA trunk LoRA
-**pre-merged at strength 1.0** (dequantize → add → requantize with the same `comfy-kitchen`
-int8-convrot kernels ComfyUI itself uses; every tensor keeps its exact dtype, shape and byte
-length). The PDD head bank is **not** in this file — it stays runtime, so you still need the
-node pack and one of the LoRA files above.
-
-**Why it exists:** ComfyUI merges LoRA patches into weights only for modules that fit in
-VRAM; offloaded modules get a per-forward `lowvram patch` — the LoRA (plus a dequantize) is
-re-applied on **every step**. On cards at the VRAM edge that fixed cost is large: ~2× s/it
-at 864×480 on a 32 GB RTX 5090
-([node pack issue #4](https://github.com/Jalen-Brunson/ComfyUI-MiniMax-H3-PDD-Acc/issues/4)).
-Baking removes the patch term entirely — measured on a fully-offloaded H200: 2.44 → 2.06 s/it
-(`lowvram patches: 258 → 0`); the win grows as the card gets smaller. **If your card fully
-loads the trunk, this file buys you nothing** — use a LoRA file above on a stock trunk.
-
-**Usage:** put it in `ComfyUI/models/diffusion_models/`, load it with a plain **UNETLoader**,
-and run the exact recipe above with the Apply node's **`lora_strength` set to `0.0`**
-(baked-trunk mode: trunk patching skipped; head bank / sigmas / guards unchanged — the node's
-`info` output confirms it). Point the Apply node at the **Ref2VA** LoRA file above (it still
-supplies the head bank and the trained sigmas). Everything else is identical: SigmaShift
-12/3, the Apply node's sigmas → euler, CFG 1.0, `nfe` 8 (4 also official).
-
-**Caveats:** the merge strength is frozen into the file — for another strength, the FL2VA
-trunk, or a bf16/pruned base, `bake_pdd_trunk.py` in the node pack bakes any base yourself
-(streaming write, a few GB of RAM). On an **unbaked** trunk, `lora_strength 0.0` silently
-renders the un-distilled model with PDD heads — if unsure, check the file's safetensors
-metadata for `pdd_acc_baked: true` (full bake provenance — source shas, strength, date — is
-embedded there).
-
-## What was converted
-
-Trunk LoRA renamed from diffusers to ComfyUI H3 keys (`diffusion_model.*.lora_A/B.weight`
-+ `.alpha`, 258 modules):
-
-- `to_q/to_k/to_v` → `attn.qkv_proj`: concatenated `lora_A`, **block-diagonal** `lora_B`,
-  alpha ×3 (keeps the per-branch scale exactly 1.0)
-- `ff.net.0.proj` → `mlp.fc1`: SwiGLU `[value;gate]` → `[gate;value]` `lora_B` row half-swap
-- `to_out.0` → `attn.out_proj`, `ff.net.2` → `mlp.fc2`, `adaln_proj.linear` copied 1:1
-  (modulation layouts verified bit-identical between the two implementations)
-- `token_refiner.refiner_blocks.N` → `token_refiner.blocks.N`
-
-The PDD head bank (`proj_out` [32,96,5376], `audio_proj_out` [32,32,5376] + biases) is kept
-byte-for-byte unchanged. Conversion is verified **bit-identical** to what the node pack
-computes in memory from the original files, and the converter CLI + 13-test suite live in the
-GitHub repo. Full provenance (source file sha256, transform description) is embedded in each
-file's safetensors metadata.
-
-## Credits
-
-All training credit to [alibaba-pai](https://huggingface.co/alibaba-pai) (Apache-2.0 release)
-and the PDD authors (Shaul et al.); base model by
-[MiniMaxAI](https://huggingface.co/MiniMaxAI). This repo is a format conversion only.
+| [`minimax_h3_ref2va_pdd_acc_8step_baked_with_heads_int8_convrot.safetensors`](minimax_h3_ref2va_pdd_acc_8step_baked_with_heads_int8_convrot.safetensors) | **WITH HEADS:** Ref2VA INT8 ConvRot trunk with PDD merged at strength 1.0, plus 32 video and 32 audio heads | Native ComfyUI with PR #17157 |
+| [`minimax_h3_ref2va_pdd_acc_8step_baked_without_heads_int8_convrot.safetensors`](minimax_h3_ref2va_pdd_acc_8step_baked_without_heads_int8_convrot.safetensors) | **WITHOUT HEADS:** PDD trunk merged at strength 1.0; original single output heads | External Ref2VA PDD head bank and Apply node still required |
+| `minimax_h3_fl2va_pdd_acc_8step_comfyui.safetensors` | FL2VA trunk LoRA and external head bank | Companion PDD custom nodes |
+| `minimax_h3_ref2va_pdd_acc_8step_comfyui.safetensors` | Ref2VA trunk LoRA and external head bank | Companion PDD custom nodes |
+
+Put either full checkpoint in `ComfyUI/models/diffusion_models/`.
+Put the two custom-node LoRA files in `ComfyUI/models/pdd_acc/`.
+
+The **without-heads** checkpoint is the former `minimax_h3_ref2va_pdd_acc_8step_baked_int8_convrot.safetensors`.
+It was renamed for clarity; its bytes and SHA256 are unchanged. Existing download links
+using the old filename need to be updated.
+
+## WITH HEADS — native ComfyUI
+
+1. Update ComfyUI to a revision containing PR #17157.
+2. Load `minimax_h3_ref2va_pdd_acc_8step_baked_with_heads_int8_convrot.safetensors` with **Load Diffusion Model / UNETLoader**.
+3. Use the usual MiniMax H3 Ref2VA conditioning, text encoder, video VAE and audio VAE.
+4. Use **Euler**, the **simple** scheduler, **8 steps**, **CFG 1.0**, and **denoise 1.0**.
+   The video/audio sigma shifts are **12.0 / 3.0**, the native model defaults.
+5. Do not apply the PDD acceleration LoRA or PDD Apply node again: its trunk and heads
+   are already included. Keep other acceleration LoRAs disabled for this recipe.
+
+Four steps are also supported by the original PDD release; start with eight.
+The native simple scheduler at four and eight steps was checked against the PDD block
+boundaries. The checkpoint stores **32 fine-interval heads per stream**:
+`config.transformer.pdd_steps = 32` is the bank size, not the requested sampler-step count.
+
+This is a diffusion-model checkpoint. The text encoder and VAEs remain separate.
+The existing INT8 ConvRot trunk is preserved byte-for-byte; only the four output-head tensors
+and checkpoint metadata change. The head tensors are stored in float32:
+
+| Tensor | Shape |
+|---|---|
+| `final_layer.video_out.weight` | `[3072, 5376]` |
+| `final_layer.video_out.bias` | `[3072]` |
+| `final_layer.audio_out.weight` | `[1024, 5376]` |
+| `final_layer.audio_out.bias` | `[1024]` |
+
+Each bank stores head 0 as a full head and subsequent entries as offsets from head 0.
+Native ComfyUI combines the appropriate heads for each sampling interval.
+
+## WITHOUT HEADS — companion PDD nodes
+
+Load `minimax_h3_ref2va_pdd_acc_8step_baked_without_heads_int8_convrot.safetensors` with UNETLoader and use
+[ComfyUI-MiniMax-H3-PDD-Acc](https://github.com/Jalen-Brunson/ComfyUI-MiniMax-H3-PDD-Acc)
+with the Ref2VA PDD file:
+
+- `lora_strength = 0.0` — the trunk is already baked.
+- `head_strength = 1.0`, `nfe = 8` (four also supported).
+- Euler, CFG 1.0, video/audio sigma shifts 12/3.
+- Connect the Apply node's sigma output to `SamplerCustomAdvanced`.
+
+**Without heads** means without the *PDD bank*: this file still has the normal single
+video and audio output heads. It is not a standalone PDD checkpoint.
+
+## Standalone LoRA conversions
+
+The two `..._comfyui.safetensors` LoRA files retain their original custom-node format.
+They contain a rank-64 trunk LoRA plus the unmodified original PDD head bank.
+Use the companion node pack with the matching stock FL2VA or Ref2VA checkpoint,
+trunk/head strengths 1.0, Euler, CFG 1.0 and the Apply node's sigma schedule.
+
+Trunk conversion maps Diffusers Q/K/V projections to ComfyUI's fused QKV layout,
+swaps the SwiGLU projection halves, renames attention/MLP/refiner keys and preserves
+LoRA scaling with explicit alpha tensors. The original standalone head bank remains
+in its absolute-head format for the companion node pack.
+
+## Conversion validation
+
+The with-heads checkpoint was derived from the existing verified trunk bake and the
+same official `MiniMax-H3-Ref2VA-Acc-8Step.safetensors` source.
+
+- All **1031 trunk tensors** are byte-identical to the without-heads checkpoint.
+- Every output tensor was hashed and verified after writing.
+- Native ComfyUI detects 24 video latent channels, 32 audio latent channels and 32 PDD heads.
+- The native model constructor accepts the new head shapes.
+- The complete checkpoint loads through native `comfy.sd.load_diffusion_model` on CPU.
+- Native head evaluation was compared to the original bank averaged independently in float64,
+  across all 32 individual intervals, eight-step and four-step partitions, and additional spans.
+  Maximum relative L2 error across video/audio checks: **3.565e-07**.
+- The float32 head conversion introduces only rounding error; the INT8 trunk is not re-quantized.
+
+These checks validate checkpoint structure and head math. They are not a full rendered-video
+quality benchmark. See [the validation report](with-heads-validation.json) and
+[the conversion script](bake_pdd_with_heads.py).
+
+## SHA256
+
+| File | SHA256 |
+|---|---|
+| WITH HEADS | `d1f555a323a71a3ef33221527c240c9d63534f6fa5ff507b042a48f0423b8484` |
+| WITHOUT HEADS | `fe8e58d8028e74607dfb41aa6a9ce92f5e0f989fff3e1eba6041caedcd1e111e` |
+| FL2VA custom-node LoRA | `1dce71b90e5d993d3309474d47e414766e65dbd760f18978c399c82db5cda0ea` |
+| Ref2VA custom-node LoRA | `5531fa0da887c24ec0083b0050ea9e4ff03c479cfbe21ef586d1c5c79bdc78a1` |
+
+WITH HEADS size: **34,124,239,286 bytes**.
+
+## Credits and license
+
+Base model: [MiniMaxAI/MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3).
+PDD training: [Alibaba PAI](https://huggingface.co/alibaba-pai/MiniMax-H3-Acc-LoRAs)
+and the [PDD authors](https://arxiv.org/abs/2607.26004).
+Native baked-head support: [ComfyUI PR #17157 by kijai](https://github.com/Comfy-Org/ComfyUI/pull/17157).
+This repository provides format conversions, not newly trained weights.
+
+The model card now reflects the upstream MiniMax H3 community license;
+see the [base-model license](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/LICENSE)
+and [PDD source repository](https://huggingface.co/alibaba-pai/MiniMax-H3-Acc-LoRAs).

bake_pdd_with_heads.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""Add the official PDD head banks to an already baked MiniMax H3 trunk."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import struct
+import sys
+
+import torch
+from safetensors import safe_open
+
+
+CHUNK = 16 * 1024 * 1024
+HEADS = {
+    "final_layer.video_out.weight": "proj_out.weight",
+    "final_layer.video_out.bias": "proj_out.bias",
+    "final_layer.audio_out.weight": "audio_proj_out.weight",
+    "final_layer.audio_out.bias": "audio_proj_out.bias",
+}
+
+
+def header(path):
+    with open(path, "rb") as f:
+        prefix = f.read(8)
+        data = f.read(struct.unpack("<Q", prefix)[0])
+    return json.loads(data), prefix + data
+
+
+def sha256(path):
+    digest = hashlib.sha256()
+    with open(path, "rb") as f:
+        while chunk := f.read(CHUNK):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def validate_native(path, source, comfy):
+    sys.path.insert(0, str(comfy))
+    from comfy.cli_args import args as comfy_args
+    comfy_args.cpu = True
+    import comfy.model_detection
+    import comfy.ops
+    from comfy.ldm.minimax.model import MiniMaxH3Model, FinalLayer, _pdd_head
+    from comfy.model_sampling import ModelSamplingAV
+    from comfy.samplers import simple_scheduler
+
+    h, _ = header(path)
+    # Detection only consumes shapes; no second full model allocation is needed.
+    shapes = {k: torch.empty(v["shape"], device="meta")
+              for k, v in h.items() if k != "__metadata__"}
+    config = comfy.model_detection.detect_unet_config(shapes, "", h["__metadata__"])
+    assert config["pdd_steps"] == 32
+    assert config["latents_dim"] == 24 and config["audio_latents_dim"] == 32
+    model = MiniMaxH3Model(**config, device="meta", dtype=torch.bfloat16,
+                         operations=comfy.ops.disable_weight_init)
+    for key in HEADS:
+        assert list(model.state_dict()[key].shape) == h[key]["shape"], key
+    del model, shapes
+
+    # Compare real native head evaluation with the original absolute head bank,
+    # independently averaged in float64 for every fine interval and 8/4 steps.
+    hidden = torch.randn(5, 5376, generator=torch.Generator().manual_seed(17157))
+    cases = [(i, i + 1) for i in range(32)]
+    cases += [(i, i + size) for size in (4, 8) for i in range(0, 32, size)]
+    cases += [(3, 11), (7, 32)]
+    results = []
+    with safe_open(str(path), framework="pt") as baked, safe_open(str(source), framework="pt") as original:
+        final = FinalLayer(5376, 1, 96, 32, 1e-5, pdd_steps=32,
+                           operations=comfy.ops.disable_weight_init)
+        for stream, prefix, shift in (("video", "proj_out", 12.0),
+                                      ("audio", "audio_proj_out", 3.0)):
+            head = getattr(final, stream + "_out")
+            head.weight = torch.nn.Parameter(baked.get_tensor(f"final_layer.{stream}_out.weight"))
+            head.bias = torch.nn.Parameter(baked.get_tensor(f"final_layer.{stream}_out.bias"))
+            w = original.get_tensor(prefix + ".weight").double()
+            b = original.get_tensor(prefix + ".bias").double()
+            grid = torch.linspace(1, 0, 33, dtype=torch.float64)
+            sigmas = shift * grid / (1 + (shift - 1) * grid)
+            delta = sigmas[:-1] - sigmas[1:]
+            max_rel, max_abs = 0.0, 0.0
+            for start, stop in cases:
+                weights = delta[start:stop] / delta[start:stop].sum()
+                reference_w = (weights[:, None, None] * w[start:stop]).sum(0)
+                reference_b = (weights[:, None] * b[start:stop]).sum(0)
+                expected = torch.nn.functional.linear(hidden.double(), reference_w, reference_b)
+                actual = _pdd_head(head, hidden, 32, start, stop, shift)
+                error = actual.double() - expected
+                rel = float(error.norm() / expected.norm())
+                max_rel = max(max_rel, rel)
+                max_abs = max(max_abs, float(error.abs().max()))
+                assert rel < 2e-6, (stream, start, stop, rel)
+            results.append({"stream": stream, "cases": len(cases),
+                            "max_relative_l2_error": max_rel, "max_absolute_error": max_abs})
+
+    sampling = ModelSamplingAV()
+    sampling.set_parameters(shift=12.0, audio_shift=3.0)
+    schedules = {}
+    for steps in (8, 4):
+        actual = simple_scheduler(sampling, steps)
+        grid = torch.linspace(1, 0, steps + 1)
+        expected = 12 * grid / (1 + 11 * grid)
+        torch.testing.assert_close(actual, expected, atol=2e-7, rtol=2e-7)
+        schedules[str(steps)] = actual.tolist()
+    return {"native_detection": {"pdd_steps": 32, "latents_dim": 24, "audio_latents_dim": 32},
+            "native_model_head_shapes": "passed", "native_head_parity": results,
+            "simple_scheduler_matches_pdd_boundaries": schedules}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base", type=Path, required=True)
+    parser.add_argument("--pdd", type=Path, required=True)
+    parser.add_argument("--out", type=Path, required=True)
+    parser.add_argument("--comfy", type=Path, required=True)
+    parser.add_argument("--report", type=Path, required=True)
+    parser.add_argument("--expected-base-sha256", required=True)
+    args = parser.parse_args()
+    torch.set_num_threads(4)
+    if args.out.exists() or args.out.with_suffix(".partial").exists():
+        raise FileExistsError("Output or partial output already exists; inspect before retrying")
+    h, old_prefix = header(args.base)
+    metadata = dict(h.pop("__metadata__"))
+    assert metadata["pdd_acc_baked"] == "true"
+    assert float(metadata["pdd_acc_bake_strength"]) == 1.0
+    source_hash = sha256(args.pdd)
+    assert source_hash == metadata["pdd_acc_bake_source_sha256"], "PDD source differs from trunk bake"
+    replacement = {}
+    reconstruction_errors = {}
+    with safe_open(str(args.pdd), framework="pt") as source:
+        assert source.metadata()["pdd_num_steps"] == "32"
+        for target, key in HEADS.items():
+            absolute = source.get_tensor(key).float()
+            assert list(absolute.shape[1:]) == h[target]["shape"]
+            bank = absolute.clone()
+            bank[1:] -= absolute[0]
+            flat = bank.flatten(0, 1).contiguous()
+            # The first bank entry is a complete head; later entries are offsets.
+            reconstructed = bank.clone()
+            reconstructed[1:] += bank[0]
+            torch.testing.assert_close(reconstructed, absolute, rtol=1e-6, atol=1e-8)
+            reconstruction_errors[target] = float((reconstructed - absolute).abs().max())
+            replacement[target] = flat
+    config = json.loads(metadata["config"])
+    config["transformer"]["pdd_steps"] = 32
+    metadata["config"] = json.dumps(config)
+    metadata.update({
+        "pdd_acc_heads_baked": "true",
+        "pdd_acc_head_layout": "head0_absolute_then_offsets_from_head0",
+        "pdd_acc_head_count": "32",
+        "pdd_acc_heads_source_sha256": source_hash,
+        "pdd_acc_trunk_baked_sha256": args.expected_base_sha256,
+        "pdd_acc_heads_bake_date": "2026-10-20",
+        "pdd_acc_bake_note": (
+            "Trunk and video/audio PDD heads baked at strength 1.0. "
+            "Native ComfyUI PR #17157 format; no PDD Apply node or acceleration LoRA required. "
+            "Euler/simple, 8 or 4 steps, CFG 1, video/audio shifts 12/3. "
+            "All trunk tensor bytes preserved from the without-heads bake."
+        ),
+    })
+    ordered = sorted(h, key=lambda k: h[k]["data_offsets"][0])
+    new_header = {"__metadata__": metadata}
+    offset = 0
+    for key in ordered:
+        entry = dict(h[key])
+        if key in replacement:
+            entry["shape"] = list(replacement[key].shape)
+            entry["dtype"] = "F32"
+            length = replacement[key].numel() * 4
+        else:
+            length = entry["data_offsets"][1] - entry["data_offsets"][0]
+        entry["data_offsets"] = [offset, offset + length]
+        new_header[key] = entry
+        offset += length
+    encoded = json.dumps(new_header, separators=(",", ":")).encode()
+    encoded += b" " * (-len(encoded) % 8)
+    prefix = struct.pack("<Q", len(encoded)) + encoded
+    partial = args.out.with_suffix(".partial")
+    base_digest = hashlib.sha256(old_prefix)
+    expected_tensors = {}
+    print("Writing checkpoint; source heads validated and repacked in float32", flush=True)
+    with args.base.open("rb") as src, partial.open("xb") as dst:
+        dst.write(prefix)
+        src.seek(len(old_prefix))
+        for key in ordered:
+            start, stop = h[key]["data_offsets"]
+            assert src.tell() == len(old_prefix) + start
+            remaining = stop - start
+            tensor_hash = hashlib.sha256()
+            while remaining:
+                chunk = src.read(min(CHUNK, remaining))
+                if not chunk:
+                    raise EOFError(key)
+                base_digest.update(chunk)
+                remaining -= len(chunk)
+                if key not in replacement:
+                    dst.write(chunk)
+                    tensor_hash.update(chunk)
+            if key in replacement:
+                data = replacement[key].numpy().tobytes()
+                dst.write(data)
+                tensor_hash.update(data)
+            expected_tensors[key] = tensor_hash.hexdigest()
+        assert src.read(1) == b"", "Unexpected trailing bytes"
+        dst.flush()
+        os.fsync(dst.fileno())
+    assert base_digest.hexdigest() == args.expected_base_sha256, "Source trunk hash mismatch"
+    print("Verifying every written tensor and the complete checkpoint hash", flush=True)
+    output_digest = hashlib.sha256()
+    with partial.open("rb") as f:
+        actual_prefix = f.read(len(prefix))
+        assert actual_prefix == prefix
+        output_digest.update(actual_prefix)
+        for key in ordered:
+            start, stop = new_header[key]["data_offsets"]
+            remaining = stop - start
+            tensor_hash = hashlib.sha256()
+            while remaining:
+                chunk = f.read(min(CHUNK, remaining))
+                if not chunk:
+                    raise EOFError(key)
+                remaining -= len(chunk)
+                output_digest.update(chunk)
+                tensor_hash.update(chunk)
+            assert tensor_hash.hexdigest() == expected_tensors[key], key
+        assert not f.read(1)
+    validation = validate_native(partial, args.pdd, args.comfy)
+    report = {
+        "output": str(args.out), "size": partial.stat().st_size,
+        "sha256": output_digest.hexdigest(),
+        "base_sha256": base_digest.hexdigest(), "pdd_source_sha256": source_hash,
+        "unchanged_trunk_tensors": len(h) - len(HEADS),
+        "replaced_head_tensors": {k: new_header[k]["shape"] for k in HEADS},
+        "head_reconstruction_max_absolute_errors": reconstruction_errors,
+        "every_tensor_verified_after_write": True, **validation,
+    }
+    partial.rename(args.out)
+    args.report.write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

minimax_h3_ref2va_pdd_acc_8step_baked_with_heads_int8_convrot.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1f555a323a71a3ef33221527c240c9d63534f6fa5ff507b042a48f0423b8484
+size 34124239286

with-heads-validation.json

@@ -0,0 +1,87 @@
+{
+  "output": "minimax_h3_ref2va_pdd_acc_8step_baked_with_heads_int8_convrot.safetensors",
+  "size": 34124239286,
+  "sha256": "d1f555a323a71a3ef33221527c240c9d63534f6fa5ff507b042a48f0423b8484",
+  "base_sha256": "fe8e58d8028e74607dfb41aa6a9ce92f5e0f989fff3e1eba6041caedcd1e111e",
+  "pdd_source_sha256": "111c82e669f6e20e628228172edf39395f1a9fc3ad049793895e542c0f55b18c",
+  "unchanged_trunk_tensors": 1031,
+  "replaced_head_tensors": {
+    "final_layer.video_out.weight": [
+      3072,
+      5376
+    ],
+    "final_layer.video_out.bias": [
+      3072
+    ],
+    "final_layer.audio_out.weight": [
+      1024,
+      5376
+    ],
+    "final_layer.audio_out.bias": [
+      1024
+    ]
+  },
+  "head_reconstruction_max_absolute_errors": {
+    "final_layer.video_out.weight": 2.3283064365386963e-10,
+    "final_layer.video_out.bias": 0.0,
+    "final_layer.audio_out.weight": 1.1641532182693481e-10,
+    "final_layer.audio_out.bias": 0.0
+  },
+  "every_tensor_verified_after_write": true,
+  "native_detection": {
+    "pdd_steps": 32,
+    "latents_dim": 24,
+    "audio_latents_dim": 32
+  },
+  "native_model_head_shapes": "passed",
+  "native_head_parity": [
+    {
+      "stream": "video",
+      "cases": 46,
+      "max_relative_l2_error": 3.3237846140005016e-07,
+      "max_absolute_error": 9.193037961097161e-06
+    },
+    {
+      "stream": "audio",
+      "cases": 46,
+      "max_relative_l2_error": 3.565437028806307e-07,
+      "max_absolute_error": 7.117412184953764e-06
+    }
+  ],
+  "simple_scheduler_matches_pdd_boundaries": {
+    "8": [
+      1.0,
+      0.9882352948188782,
+      0.9729729890823364,
+      0.9523809552192688,
+      0.9230769276618958,
+      0.8780487775802612,
+      0.800000011920929,
+      0.6315789222717285,
+      0.0
+    ],
+    "4": [
+      1.0,
+      0.9729729890823364,
+      0.9230769276618958,
+      0.800000011920929,
+      0.0
+    ]
+  },
+  "complete_checkpoint_native_load": {
+    "checkpoint_sha256": "d1f555a323a71a3ef33221527c240c9d63534f6fa5ff507b042a48f0423b8484",
+    "native_load_diffusion_model": "passed",
+    "missing_or_unexpected_weights": 0,
+    "load_device": "cpu",
+    "pdd_steps": 32,
+    "video_head_shape": [
+      3072,
+      5376
+    ],
+    "audio_head_shape": [
+      1024,
+      5376
+    ],
+    "head_dtype": "torch.float32"
+  }
+}