Add native ComfyUI conversion, provenance, and validation

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json text
+*.md text
+*.py text

MANIFEST.json

@@ -0,0 +1,76 @@
+{
+  "schema": "omniref-comfy-repo-manifest-v1",
+  "private": true,
+  "files": [
+    {
+      "path": ".gitattributes",
+      "bytes": 82,
+      "sha256": "398727837d241c660c7a0d82ba2edaa348150d4d8daac4953b1d62d671442ad4"
+    },
+    {
+      "path": "README.md",
+      "bytes": 5382,
+      "sha256": "5d5e9f390476538a9eb24c2a681166f3b7261ce7d304bf311d1574ee59f1fc46"
+    },
+    {
+      "path": "conversion/convert_omniref_comfy.py",
+      "bytes": 19113,
+      "sha256": "96b745f3fae81450eac777d60c7f3452d24d61384f18877fe4f1fc4e930320a3"
+    },
+    {
+      "path": "conversion/quantize_native_comfy.py",
+      "bytes": 10914,
+      "sha256": "5ff65395a51d78b43684e751682f71115ad0575b4ae1f796611f2e02a228ef0f"
+    },
+    {
+      "path": "conversion/validate_native_comfy.py",
+      "bytes": 8989,
+      "sha256": "a4015fe9e5c219e587f52069701326ce92202dce035fb6b94023c0c135104ca3"
+    },
+    {
+      "path": "fasth3_omniref_qad_nvfp4_comfy.safetensors",
+      "bytes": 13773998700,
+      "sha256": "bf25ee58df65b4dfee349d612f7ac62a2fea0dddd1e68eb37e75c8ce8b166f5a"
+    },
+    {
+      "path": "provenance/CONVERSION.md",
+      "bytes": 2688,
+      "sha256": "ff9c3d8df3a49d502b053fff05702e7a5496e989f04ef3e315964aa9bea1d202"
+    },
+    {
+      "path": "provenance/QAD_CONVERSION_RECEIPT.json",
+      "bytes": 12927,
+      "sha256": "a59d13efea88afeab363ff954b23963759af1239a052a697bf7414588791f44b"
+    },
+    {
+      "path": "provenance/QAD_SOURCE_VERIFICATION.json",
+      "bytes": 3931,
+      "sha256": "9538f791f2a29c8a8e098918148b1c98b8a8c7714c1c8f3ae4d1ae8cd5d9d4b0"
+    },
+    {
+      "path": "provenance/QUANTIZATION.json",
+      "bytes": 160301,
+      "sha256": "0d633848795b464af4e891cad076ad18b2ebb514ffbaabd792354692c0edc397"
+    },
+    {
+      "path": "provenance/SCHEMA_VALIDATION.json",
+      "bytes": 1511,
+      "sha256": "2f9b391292363ebf2ce8d8e7a5b27783f99db8e9d8538433557902fef3a95dfa"
+    },
+    {
+      "path": "provenance/SOURCE_HASH_VERIFICATION.json",
+      "bytes": 914,
+      "sha256": "e4558cbaa2e23231af9acd04985ff51121477663aaa9705a0edc7e64e72fad5e"
+    },
+    {
+      "path": "provenance/VALIDATION.json",
+      "bytes": 5961,
+      "sha256": "a49f64853cffb402bfe9890fa1ffb77f3b37e6b35e57606f70834e1340daf27e"
+    },
+    {
+      "path": "provenance/VALIDATION.md",
+      "bytes": 1797,
+      "sha256": "3f9dd6713cc0ef01491f5baf22b3066d90d3fa8beb257abbac8ff0c9e9a7c798"
+    }
+  ]
+}

README.md

@@ -0,0 +1,124 @@
+---
+license: other
+license_name: minimax-h3-community-license-agreement
+license_link: https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/LICENSE
+library_name: diffusion-single-file
+base_model:
+- FastVideo/FastVideo-FastH3-Omni-8-Step-V1
+tags:
+- comfyui
+- diffusion-single-file
+- minimax-h3
+- omniref
+- reference-to-video
+- nvfp4
+- qad
+---
+
+# FastH3 OmniRef NVFP4 QAD for ComfyUI
+
+Native ComfyUI NVFP4 diffusion model for FastH3 OmniRef, a reference-conditioned
+video-and-audio generator. The model produces a video with synchronized 32 kHz stereo
+audio from a prompt and ordered image, video, and audio references.
+
+This checkpoint is an **NVFP4 export of the QAD student of the BF16 OmniRef model**
+[`FastVideo/FastVideo-FastH3-Omni-8-Step-V1`](https://huggingface.co/FastVideo/FastVideo-FastH3-Omni-8-Step-V1).
+The QAD student was trained against the BF16 OmniRef teacher for NVFP4 execution; its
+dense BF16 master was then converted to the native ComfyUI layout and quantized to
+NVFP4 for this Comfy-native checkpoint.
+
+## Quantization
+
+- All 50 transformer blocks store `qkv_proj`, `out_proj`, `to_gate_compress`,
+  `mlp.fc1`, and `mlp.fc2` as NVFP4 E2M1 with FP8 block scales (group size 16).
+- Q/K/V are fused by the native Comfy conversion before quantization. The fused
+  `qkv_proj` uses **one per-tensor global scale** plus its block scales, matching
+  ComfyUI's `TensorCoreNVFP4Layout`. This is the compatible treatment for Comfy's
+  single fused QKV module.
+- Activations use ComfyUI's native **dynamic per-tensor** NVFP4 quantization at runtime.
+- The token refiner, AdaLN curves and projections, norms, embeddings, patch and
+  condition projections, and the FP32 PDD output heads stay dense.
+- This is a new PTQ export of the QAD-trained BF16 master. It is **not** a
+  byte-preserving repack of the FastVideo packed NVFP4 checkpoint: that file stores
+  separate Q/K/V matrices and independent per-projection global scales, which cannot
+  be concatenated unchanged into Comfy's fused QKV module.
+
+## Files
+
+| File | Contents |
+|---|---|
+| `fasth3_omniref_qad_nvfp4_comfy.safetensors` | Native ComfyUI NVFP4 diffusion model (~12 GB) |
+| `provenance/` | Source verification, conversion/quantization receipts, schema validation |
+| `conversion/` | Converter and quantizer scripts, pinned-runtime provenance |
+
+Place the diffusion model in:
+
+```text
+ComfyUI/models/diffusion_models/fasth3_omniref_qad_nvfp4_comfy.safetensors
+```
+
+Use the matching text encoder and VAEs from
+[`FastVideo/FastH3-OmniRef-Comfy`](https://huggingface.co/FastVideo/FastH3-OmniRef-Comfy):
+
+```text
+ComfyUI/models/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors
+ComfyUI/models/vae/minimax_h3_video_vae_int8_convrot.safetensors
+ComfyUI/models/vae/minimax_h3_audio_vae_fp32.safetensors
+```
+
+The text encoder includes the vision tower used for reference conditioning. The video
+VAE includes the reference encoder and decoder. The audio VAE is required.
+
+## Usage
+
+Use the **MiniMax H3 Reference to Video** node with an image, video, or audio reference.
+Reference the inputs with `<Picture 1>`, `<Video 1>`, and `<Audio 1>` tags in the prompt.
+
+Recommended OmniRef settings:
+
+- 8 sampling steps, guidance 1.0
+- Video shift 12.0, audio shift 3.0
+- 480p or 768p output; 124 frames is about 5 seconds at 24 fps
+- Euler sampler with a simple schedule for the 8-forward PDD student
+
+Example 480p5 prompt:
+
+```text
+A dynamic tracking shot of <Picture 1>: a cyclist riding along a city street at golden
+hour. The camera moves alongside at riding speed, storefronts and trees passing behind.
+Wind, bicycle chain, and distant traffic sounds. No text, no watermark.
+```
+
+## Validation
+
+- Passes CPU format/schema checks against the pinned ComfyUI MiniMax-H3 detector and
+  quantized-module loader.
+- The QAD BF16 master was checked against the original OmniRef transformer: all tensors
+  outside the QAD-trained projections are byte-identical, and the trained projections
+  differ as expected.
+- Every dense tensor in the NVFP4 file is byte-identical to the QAD BF16 Comfy
+  conversion.
+- Validated with native ComfyUI at 832x480, 124 frames, 8 steps against the
+  corresponding QAD BF16 Comfy export using PSNR/SSIM, signal statistics, and audio
+  metrics (duration, RMS, activity, correlation, and spectral centroid). See
+  `provenance/VALIDATION.md`.
+- The clips contain no NaNs, dropped audio, or silent tracks in validation.
+
+## Limitations
+
+- NVFP4 changes the numerical output relative to the BF16 QAD master, as expected for
+  W4A4 execution.
+- Comfy's fused QKV module takes one global weight scale. Quantizing the fused tensor
+  is a compatible PTQ treatment, but it is not numerically identical to the FastVideo
+  packed QAD representation with separate Q/K/V scales.
+- Native ComfyUI's PDD sampler grid and sparse-attention path differ from the FastVideo
+  runtime. The original inference contract is recorded in the safetensors metadata.
+- Accelerated NVFP4 kernels require Blackwell (SM 10.0 or newer), a ComfyUI build with
+  CUDA 13, and `comfy-kitchen` 0.2.39 or newer. Older CUDA or pre-Blackwell devices
+  load the checkpoint through the dequantization fallback.
+- Reference-driven output is sensitive to prompt wording and reference framing.
+
+## License
+
+MiniMax-H3 and this derivative are governed by the MiniMax-H3 Community License
+Agreement. See the linked license for terms.

conversion/convert_omniref_comfy.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+"""Bounded-memory FastVideo H3 OmniRef -> native ComfyUI single-file export.
+
+Dense BF16/F16/F32 source only. All source tensors are accounted for. QKV fusion
+and SwiGLU reordering copy bytes. PDD full heads become FP32 baseline+offset
+heads because that is the native ComfyUI consumer's representation. Optional
+rank-reduced AdaLN curves are an explicitly reported numerical approximation.
+"""
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+import hashlib
+import json
+import math
+from pathlib import Path
+import re
+import struct
+import sys
+
+COMFY_COMMIT = "b1a247c9cf9dbfda4b2c0a0c1d50950667eeaa0c"
+TOOLS_COMMIT = "d6797787e6bdb1a1fb0094d588a26f8e71a1c757"
+SOURCE_REPO = "FastVideo/FastVideo-FastH3-Omni-8-Step-V1"
+SOURCE_REVISION = "88d512c5e7cc38dda499fbb65688ce58611f9c80"
+DTYPE_BYTES = {"BF16": 2, "F16": 2, "F32": 4}
+CHUNK = 8 * 1024 * 1024
+
+
+@dataclass
+class Tensor:
+    dtype: str
+    shape: list[int]
+    path: Path
+    offset: int
+    size: int
+
+
+@dataclass
+class Output:
+    dtype: str
+    shape: list[int]
+    # File ranges, kept in order; generated tensors are small scratch files.
+    parts: list[tuple[Path, int, int]]
+
+
+def header(path: Path) -> tuple[dict, int]:
+    with path.open("rb") as f:
+        raw = f.read(8)
+        if len(raw) != 8:
+            raise ValueError(f"Truncated safetensors file: {path}")
+        length, = struct.unpack("<Q", raw)
+        if length > 100 * 1024 * 1024:
+            raise ValueError(f"Unreasonable header length: {path}")
+        data = f.read(length)
+    if len(data) != length:
+        raise ValueError(f"Truncated safetensors header: {path}")
+    return json.loads(data), 8 + length
+
+
+def load_source(src: Path) -> tuple[dict, dict[str, Tensor]]:
+    config = json.loads((src / "config.json").read_text())
+    if config.get("quantization_config") or config.get("adaln_rank"):
+        raise ValueError("Only the dense canonical OmniRef source is accepted")
+    index = json.loads((src / "diffusion_pytorch_model.safetensors.index.json").read_text())
+    weight_map = index["weight_map"]
+    tensors: dict[str, Tensor] = {}
+    for filename in sorted(set(weight_map.values())):
+        path = src / filename
+        if Path(filename).name != filename:
+            raise ValueError(f"Unsafe shard name: {filename}")
+        items, start = header(path)
+        for name, item in items.items():
+            if name == "__metadata__":
+                continue
+            if name in tensors or weight_map.get(name) != filename:
+                raise ValueError(f"Duplicate/unindexed tensor: {name}")
+            dtype, shape = item["dtype"], item["shape"]
+            if dtype not in DTYPE_BYTES:
+                raise ValueError(f"Unexpected non-dense dtype {dtype}: {name}")
+            begin, end = item["data_offsets"]
+            size = math.prod(shape) * DTYPE_BYTES[dtype]
+            if begin < 0 or end - begin != size or start + end > path.stat().st_size:
+                raise ValueError(f"Invalid/truncated tensor range: {name}")
+            tensors[name] = Tensor(dtype, shape, path, start + begin, size)
+    if set(tensors) != set(weight_map):
+        raise ValueError("Source tensor keys do not match the frozen index")
+    return config, tensors
+
+
+def expected_shapes(c: dict) -> dict[str, list[int]]:
+    h, q = c["hidden_size"], c["num_attention_heads"] * c["attention_head_dim"]
+    f, t, p = c["ffn_dim"], c["time_embed_dim"], c["pdd_steps"]
+    video = c["in_channels"] * math.prod(c["patch_size"])
+    audio = c["audio_in_channels"]
+    result = {}
+    for name, rows, cols in [("proj_in", h, video), ("audio_proj_in", h, audio),
+                              ("context_embedder", h, c["text_dim"]),
+                              ("proj_out", video * p, h), ("audio_proj_out", audio * p, h),
+                              ("time_embedder.linear_1", c["time_embed_hidden_dim"], c["freq_dim"]),
+                              ("time_embedder.linear_2", t, c["time_embed_hidden_dim"]),
+                              ("norm_out.linear", 2 * h, t)]:
+        result[name + ".weight"] = [rows, cols]
+        result[name + ".bias"] = [rows]
+    result["norm_out.norm.weight"] = [h]
+    result["token_refiner.final_norm.weight"] = [h]
+    for prefix, count in [("transformer_blocks", c["num_layers"]),
+                          ("token_refiner.refiner_blocks", c["num_refiner_layers"])]:
+        for i in range(count):
+            stem = f"{prefix}.{i}."
+            result.update({stem + "norm1.weight": [h], stem + "norm2.weight": [h],
+                           stem + "attn.norm_q.weight": [c["attention_head_dim"]],
+                           stem + "attn.norm_k.weight": [c["attention_head_dim"]],
+                           stem + "attn.to_q.weight": [q, h], stem + "attn.to_k.weight": [q, h],
+                           stem + "attn.to_v.weight": [q, h], stem + "attn.to_out.0.weight": [h, q],
+                           stem + "ff.net.0.proj.weight": [2 * f, h], stem + "ff.net.2.weight": [h, f]})
+            if prefix == "transformer_blocks":
+                result[stem + "adaln_proj.linear.weight"] = [18 * h, t]
+                result[stem + "adaln_proj.linear.bias"] = [18 * h]
+                result[stem + "attn.to_gate_compress.weight"] = [q, h]
+    return result
+
+
+def renamed(name: str) -> str:
+    roots = {"proj_in": "video_patch_proj", "audio_proj_in": "audio_patch_proj",
+             "context_embedder": "condition_proj", "proj_out": "final_layer.video_out",
+             "audio_proj_out": "final_layer.audio_out", "norm_out.linear": "final_layer.adaln_proj.linear",
+             "norm_out.norm": "final_layer.norm", "time_embedder.linear_1": "time_embedder.proj_in",
+             "time_embedder.linear_2": "time_embedder.proj_out"}
+    for before in sorted(roots, key=len, reverse=True):
+        if name.startswith(before + "."):
+            return roots[before] + name[len(before):]
+    name = name.replace("token_refiner.refiner_blocks.", "token_refiner.blocks.")
+    name = re.sub(r"^transformer_blocks\.", "blocks.", name)
+    return (name.replace(".attn.norm_q.", ".attn.q_norm.").replace(".attn.norm_k.", ".attn.k_norm.")
+            .replace(".attn.to_out.0.", ".attn.out_proj.").replace(".ff.net.2.", ".mlp.fc2.")
+            .replace(".ff.net.0.proj.", ".mlp.fc1."))
+
+
+def torch_tensor(t: Tensor, first: int = 0, rows: int | None = None):
+    import torch
+    stride = math.prod(t.shape[1:]) * DTYPE_BYTES[t.dtype]
+    count = (t.shape[0] - first) if rows is None else rows
+    with t.path.open("rb") as f:
+        f.seek(t.offset + first * stride)
+        raw = bytearray(f.read(count * stride))
+    if len(raw) != count * stride:
+        raise ValueError(f"Source truncated while reading {t.path}")
+    dtype = {"BF16": torch.bfloat16, "F16": torch.float16, "F32": torch.float32}[t.dtype]
+    return torch.frombuffer(raw, dtype=dtype).reshape(count, *t.shape[1:])
+
+
+def raw_tensor(tensor) -> bytes:
+    import torch
+    return tensor.detach().cpu().contiguous().reshape(-1).view(torch.uint8).numpy().tobytes()
+
+
+def generated(path: Path, tensor) -> Output:
+    import torch
+    dtype = {torch.float32: "F32", torch.float16: "F16", torch.bfloat16: "BF16"}[tensor.dtype]
+    path.write_bytes(raw_tensor(tensor))
+    return Output(dtype, list(tensor.shape), [(path, 0, path.stat().st_size)])
+
+
+def convert_heads(t: Tensor, n: int, scratch: Path, name: str) -> Output:
+    """Native Comfy stores head0 and (headj-head0). Differences stay FP32."""
+    per_head = t.shape[0] // n
+    output = scratch / (name.replace(".", "_") + ".bin")
+    with output.open("wb") as f:
+        for j in range(n):
+            for row in range(0, per_head, 256):
+                count = min(256, per_head - row)
+                x = torch_tensor(t, j * per_head + row, count).float()
+                if j:
+                    x -= torch_tensor(t, row, count).float()
+                f.write(raw_tensor(x))
+    return Output("F32", t.shape, [(output, 0, output.stat().st_size)])
+
+
+def time_curve(t, c: dict, tensors: dict[str, Tensor]):
+    import torch
+    half = c["freq_dim"] // 2
+    freq = torch.exp(-math.log(10000.0) * torch.arange(half, dtype=torch.float64) / half)
+    embed = torch.cat(((t[:, None] * freq).cos(), (t[:, None] * freq).sin()), dim=1)
+    w1, b1, w2, b2 = [torch_tensor(tensors[k]).double() for k in
+                      ["time_embedder.linear_1.weight", "time_embedder.linear_1.bias",
+                       "time_embedder.linear_2.weight", "time_embedder.linear_2.bias"]]
+    return torch.nn.functional.silu(torch.nn.functional.linear(
+        torch.nn.functional.silu(torch.nn.functional.linear(embed, w1, b1)), w2, b2))
+
+
+def prune_curves(c, tensors, output, rank, grid, scratch):
+    import torch
+    if rank < 1 or rank > min(c["time_embed_dim"], grid):
+        raise ValueError("Invalid AdaLN curve rank")
+    train_t = torch.linspace(0, 1, grid, dtype=torch.float64)
+    curve = time_curve(train_t, c, tensors)
+    _, singular, vh = torch.linalg.svd(curve, full_matrices=False)
+    basis = vh[:rank].T.contiguous()
+    coordinates = (curve @ basis).float()
+    # Independent offset grid exercises table interpolation, including near endpoints.
+    hold_t = (torch.arange(129, dtype=torch.float64) + 0.37) / 129
+    hold = time_curve(hold_t, c, tensors)
+    pos = hold_t * (grid - 1)
+    i0 = pos.floor().long().clamp(max=grid - 2)
+    interpolated = torch.lerp(coordinates[i0], coordinates[i0 + 1], (pos - i0).float()[:, None]).double()
+    errors = []
+    for source_name, tensor in tensors.items():
+        if source_name != "norm_out.linear.weight" and not source_name.endswith(".adaln_proj.linear.weight"):
+            continue
+        path = scratch / (renamed(source_name).replace(".", "_") + ".curve.bin")
+        with path.open("wb") as f:
+            for row in range(0, tensor.shape[0], 2048):
+                dense = torch_tensor(tensor, row, min(2048, tensor.shape[0] - row)).double()
+                f.write(raw_tensor((dense @ basis).float()))
+        output[renamed(source_name)] = Output("F32", [tensor.shape[0], rank], [(path, 0, path.stat().st_size)])
+        sample_rows = torch.linspace(0, tensor.shape[0] - 1, min(64, tensor.shape[0])).long().tolist()
+        sample = torch.cat([torch_tensor(tensor, row, 1) for row in sample_rows]).double()
+        reference = hold @ sample.T
+        approximate = interpolated @ (sample @ basis).float().double().T
+        errors.append({"tensor": source_name, "sampled_rows": len(sample_rows),
+                       "relative_l2": float((approximate - reference).norm() / reference.norm().clamp(min=1e-30)),
+                       "max_abs": float((approximate - reference).abs().max())})
+    for key in list(output):
+        if key.startswith("time_embedder."):
+            del output[key]
+    output["adaln_t_table"] = generated(scratch / "adaln_t_table.bin", coordinates)
+    return {"kind": "time-embedding-curve-svd-and-linear-interpolation", "rank": rank, "grid": grid,
+            "table_dtype": "F32", "projected_weight_dtype": "F32", "fit_domain": [0.0, 1.0],
+            "fit_relative_residual": float(singular[rank:].norm() / singular.norm()),
+            "holdout_timesteps": len(hold_t), "holdout_modulation_samples": errors,
+            "approximation": True, "end_to_end_quality_validated": False}
+
+
+def make_plan(c: dict, tensors: dict[str, Tensor], scratch: Path, rank: int = 0, grid: int = 1025):
+    import torch
+    expected = expected_shapes(c)
+    if set(tensors) != set(expected):
+        raise ValueError(f"Unexpected source keys: missing={sorted(set(expected)-set(tensors))}; "
+                         f"extra={sorted(set(tensors)-set(expected))}")
+    for name, shape in expected.items():
+        if tensors[name].shape != shape:
+            raise ValueError(f"{name}: expected {shape}, got {tensors[name].shape}")
+    output = {}
+    for name, t in sorted(tensors.items()):
+        if ".attn.to_k." in name or ".attn.to_v." in name:
+            continue
+        if ".attn.to_q." in name:
+            group = [tensors[name.replace(".attn.to_q.", f".attn.to_{p}.")] for p in ("q", "k", "v")]
+            if len({g.dtype for g in group}) != 1:
+                raise ValueError(f"QKV dtype mismatch: {name}")
+            out_name = renamed(name).replace(".attn.to_q.", ".attn.qkv_proj.")
+            output[out_name] = Output(t.dtype, [3 * t.shape[0], *t.shape[1:]],
+                                      [(g.path, g.offset, g.size) for g in group])
+        elif ".ff.net.0.proj." in name:
+            half = t.size // 2
+            output[renamed(name)] = Output(t.dtype, t.shape,
+                                           [(t.path, t.offset + half, half), (t.path, t.offset, half)])
+        elif name.startswith(("proj_out.", "audio_proj_out.")):
+            output[renamed(name)] = convert_heads(t, c["pdd_steps"], scratch, name)
+        else:
+            output[renamed(name)] = Output(t.dtype, t.shape, [(t.path, t.offset, t.size)])
+    inv = 1.0 / (c["rope_theta"] ** (torch.arange(0, 2 * c["rope_freq_dim"], 2, dtype=torch.float32)
+                                    / (2 * c["rope_freq_dim"])))
+    output["rope.inv_freq"] = generated(scratch / "rope.bin", inv)
+    curve = prune_curves(c, tensors, output, rank, grid, scratch) if rank else None
+    return output, curve
+
+
+def write_file(path: Path, output: dict[str, Output], metadata: dict) -> dict:
+    if path.exists():
+        raise FileExistsError(f"Refusing to overwrite {path}")
+    table = {"__metadata__": metadata}
+    offset = 0
+    for name, item in sorted(output.items()):
+        size = sum(part[2] for part in item.parts)
+        if size != math.prod(item.shape) * DTYPE_BYTES[item.dtype]:
+            raise ValueError(f"Output byte count mismatch: {name}")
+        table[name] = {"dtype": item.dtype, "shape": item.shape, "data_offsets": [offset, offset + size]}
+        offset += size
+    raw = json.dumps(table, separators=(",", ":"), ensure_ascii=False).encode()
+    raw += b" " * (-len(raw) % 8)
+    digest = hashlib.sha256()
+    tmp = path.with_name(path.name + ".partial")
+    if tmp.exists():
+        raise FileExistsError(f"Scratch output already exists: {tmp}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tmp.open("xb") as f:
+        def emit(data):
+            f.write(data)
+            digest.update(data)
+        emit(struct.pack("<Q", len(raw)))
+        emit(raw)
+        for name, item in sorted(output.items()):
+            for src, begin, count in item.parts:
+                with src.open("rb") as source:
+                    source.seek(begin)
+                    while count:
+                        block = source.read(min(count, CHUNK))
+                        if not block:
+                            raise ValueError(f"Truncated source during output: {name}")
+                        emit(block)
+                        count -= len(block)
+    tmp.rename(path)
+    return {"file": path.name, "bytes": path.stat().st_size, "sha256": digest.hexdigest(),
+            "tensors": len(output), "tensor_data_bytes": offset}
+
+
+def metadata_for(c, contract, rank):
+    transformer = {"pdd_steps": c["pdd_steps"], "sigma_shift_video": contract["video_scheduler_shift"],
+                   "sigma_shift_audio": contract["audio_scheduler_shift"],
+                   "norm_eps": c["norm_eps"], "qk_norm_eps": c["qk_norm_eps"],
+                   "final_norm_eps": c["final_norm_eps"]}
+    if rank:
+        transformer["time_embed_dim"] = rank
+    return {"format": "pt", "config": json.dumps({"transformer": transformer}, separators=(",", ":")),
+            "source_repo": SOURCE_REPO, "source_revision": SOURCE_REVISION,
+            "comfyui_commit": COMFY_COMMIT, "comfy_model_tools_commit": TOOLS_COMMIT,
+            "source_inference_contract": json.dumps(contract, separators=(",", ":")),
+            "pdd_head_storage": "head0-full;heads1-31-offset-from-head0;fp32",
+            "adaln_curve_approximation": str(bool(rank)).lower(),
+            "inference_parity": "not-validated;native-Comfy-PDD-uses-unit-grid-source-uses-0.999"}
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--src", type=Path, required=True, help="Canonical transformer_ref component directory")
+    p.add_argument("--output", type=Path, required=True)
+    p.add_argument("--contract", type=Path, help="Defaults to SRC/../fastvideo_inference.json")
+    p.add_argument("--scratch", type=Path, required=True)
+    p.add_argument("--adaln-curve-rank", type=int, default=0, help="0 retains full dense AdaLN;8 mirrors V2 technique")
+    p.add_argument("--curve-grid", type=int, default=1025)
+    p.add_argument("--threads", type=int, default=4)
+    p.add_argument("--inspect-only", action="store_true", help="Validate headers and print plan without conversion")
+    args = p.parse_args()
+    c, tensors = load_source(args.src)
+    expected = expected_shapes(c)
+    if set(expected) != set(tensors) or any(tensors[k].shape != v for k, v in expected.items()):
+        raise ValueError("Source geometry does not match the canonical native H3 mapping")
+    if args.inspect_only:
+        print(json.dumps({"source_tensors": len(tensors), "source_tensor_bytes": sum(t.size for t in tensors.values()),
+                          "pdd_steps": c["pdd_steps"], "curve_rank": args.adaln_curve_rank,
+                          "output_tensors": len(tensors) - 2 * (c["num_layers"] + c["num_refiner_layers"]) + 1
+                          - (3 if args.adaln_curve_rank else 0)}, indent=2))
+        return
+    import torch
+    torch.set_num_threads(args.threads)
+    args.scratch.mkdir(parents=True, exist_ok=False)
+    contract_path = args.contract or args.src.parent / "fastvideo_inference.json"
+    contract = json.loads(contract_path.read_text())
+    if contract.get("pdd_steps") != c["pdd_steps"] or contract.get("grid_max_t") != 0.999:
+        raise ValueError("Unexpected source inference contract")
+    output, curve = make_plan(c, tensors, args.scratch, args.adaln_curve_rank, args.curve_grid)
+    receipt = write_file(args.output, output, metadata_for(c, contract, args.adaln_curve_rank))
+    receipt.update({"source_repo": SOURCE_REPO, "source_revision": SOURCE_REVISION,
+                    "source_index_sha256": hashlib.sha256((args.src / "diffusion_pytorch_model.safetensors.index.json").read_bytes()).hexdigest(),
+                    "source_config": c, "source_contract": contract, "source_tensors": len(tensors),
+                    "source_tensor_bytes": sum(t.size for t in tensors.values()), "skipped_source_tensors": [],
+                    "conversion": ["concatenateQKV", "swapSwiGLUhalves", "PDDfullheadsToFP32offsetheads", "deriveRoPE"],
+                    "curve": curve, "comfyui_commit": COMFY_COMMIT, "comfy_model_tools_commit": TOOLS_COMMIT,
+                    "gpu_inference_validated": False})
+    receipt_path = args.output.with_suffix(args.output.suffix + ".receipt.json")
+    receipt_path.write_text(json.dumps(receipt, indent=2) + "\n")
+    print(json.dumps(receipt, indent=2))
+
+
+if __name__ == "__main__":
+    main()

conversion/quantize_native_comfy.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Quantize a native ComfyUI single-file OmniRef checkpoint to native FP8 or NVFP4.
+
+The input is the native ComfyUI layout produced by ``convert_omniref_comfy.py``:
+Q/K/V are already fused into ``attn.qkv_proj`` and the PDD output heads use the
+native first-head-plus-offset representation. The quantizer therefore sees one
+fused QKV tensor and applies one Comfy weight scale to it, exactly as the
+pinned ComfyUI runtime expects.
+
+Only the per-block attention/MLP projections are quantized. The token refiner,
+AdaLN curves and projections, patch/condition/output projections, norms, RoPE,
+and FP32 PDD heads stay dense. This matches the native ComfyUI MiniMax-H3
+quantized-layer policy used by the released V2/Trim Comfy checkpoints.
+
+Writes a JSON receipt with source/output hashes, the exact format markers,
+per-linear reconstruction metrics, and runtime versions.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import importlib.metadata
+import json
+from pathlib import Path
+import re
+import sys
+import time
+
+import torch
+
+# Native Comfy MiniMax-H3 block linears. qkv_proj is the fused Q/K/V module.
+QUANT_LINEAR = re.compile(
+    r"^blocks\.\d+\.(?:attn\.(?:qkv_proj|out_proj|to_gate_compress)|mlp\.(?:fc1|fc2))\.weight$"
+)
+
+FORMATS = {
+    "fp8": {
+        "layout": "TensorCoreFP8Layout",
+        "tag": {"format": "float8_e4m3fn"},
+        "documented_name": "FP8 E4M3, per-tensor weight scale, dynamic per-tensor activation scale",
+        "activation": "dynamic-per-tensor",
+    },
+    "nvfp4": {
+        "layout": "TensorCoreNVFP4Layout",
+        "tag": {"format": "nvfp4"},
+        "documented_name": "NVFP4 E2M1, per-tensor global scale plus FP8 block scales (group 16), dynamic per-tensor activation scale",
+        "activation": "dynamic-per-tensor",
+    },
+}
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while True:
+            block = handle.read(64 * 1024 * 1024)
+            if not block:
+                break
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def tensor_digest(tensor: torch.Tensor) -> str:
+    return hashlib.sha256(tensor.detach().cpu().contiguous().view(torch.uint8).numpy().tobytes()).hexdigest()
+
+
+def safetensors_header(path: Path) -> dict:
+    from safetensors import safe_open
+
+    with safe_open(str(path), framework="pt", device="cpu") as handle:
+        keys = list(handle.keys())
+        metadata = handle.metadata() or {}
+    return {"tensor_count": len(keys), "metadata": metadata, "keys": keys}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--src", required=True, type=Path, help="Native ComfyUI BF16 single-file checkpoint")
+    parser.add_argument("--dst", required=True, type=Path, help="Output quantized single-file checkpoint")
+    parser.add_argument("--format", required=True, choices=sorted(FORMATS))
+    parser.add_argument("--receipt", required=True, type=Path)
+    parser.add_argument("--comfyui-commit", default="b1a247c9cf9dbfda4b2c0a0c1d50950667eeaa0c")
+    parser.add_argument("--expect-tensors", type=int, default=None)
+    args = parser.parse_args()
+
+    if args.src == args.dst:
+        raise SystemExit("source and destination must differ")
+    if args.dst.exists():
+        raise SystemExit(f"refusing to overwrite existing output: {args.dst}")
+    if not torch.cuda.is_available():
+        raise SystemExit("CUDA is required for comfy-kitchen quantization")
+
+    import comfy_kitchen
+    import comfy_kitchen.tensor as ckt
+    from safetensors import safe_open
+    from safetensors.torch import load_file, save_file
+
+    started = time.time()
+    spec = FORMATS[args.format]
+    layout_cls = getattr(ckt, spec["layout"])
+    tag_bytes = json.dumps(spec["tag"], separators=(",", ":")).encode()
+
+    print(f"[quantize] format={args.format} src={args.src} dst={args.dst}", flush=True)
+    src_header = safetensors_header(args.src)
+    if args.expect_tensors is not None and src_header["tensor_count"] != args.expect_tensors:
+        raise SystemExit(f"expected {args.expect_tensors} tensors, found {src_header['tensor_count']}")
+    print(f"[quantize] source tensors={src_header['tensor_count']} hashing source", flush=True)
+    src_sha256 = sha256_file(args.src)
+
+    # The native Comfy BF16 export is ~44 GB. Keeping the pass-through tensors
+    # plus the quantized output in CPU RAM stays well under a GB200 node's RAM.
+    source = load_file(str(args.src), device="cpu")
+    metadata = dict(src_header["metadata"])
+    metadata["quantization"] = json.dumps(
+        {
+            "format": spec["tag"]["format"],
+            "layout": spec["layout"],
+            "weights": "per-tensor global scale" if args.format == "fp8" else "per-tensor global scale plus FP8 block scales, group 16",
+            "activations": spec["activation"],
+            "quantized_layers": "all 50 DiT blocks: fused qkv_proj, out_proj, to_gate_compress, mlp.fc1, mlp.fc2",
+            "dense_layers": "token_refiner, AdaLN, norms, embeddings, patch/condition projections, FP32 PDD heads",
+            "qkv_treatment": "fused Q/K/V quantized as one tensor under one weight scale",
+            "comfyui_commit": args.comfyui_commit,
+        },
+        separators=(",", ":"),
+    )
+    metadata["quantization_source_sha256"] = src_sha256
+    metadata["quantization_recipe"] = "omniref-comfy-ptq-v1"
+
+    output: dict[str, torch.Tensor] = {}
+    linears = []
+    for index, (name, tensor) in enumerate(source.items(), 1):
+        if not QUANT_LINEAR.match(name):
+            output[name] = tensor
+            continue
+
+        weight = tensor.to(device="cuda", dtype=torch.bfloat16).contiguous()
+        qdata, params = layout_cls.quantize(weight)
+        serialized = layout_cls.state_dict_tensors(qdata, params)
+        for suffix, value in serialized.items():
+            output[name + suffix] = value.detach().cpu().contiguous()
+        output[name[: -len(".weight")] + ".comfy_quant"] = torch.tensor(list(tag_bytes), dtype=torch.uint8)
+
+        dequantized = layout_cls.dequantize(qdata, params).float()
+        reference = weight.float()
+        diff = dequantized - reference
+        rel_l2 = float(diff.norm() / reference.norm().clamp(min=1e-30))
+        cosine = float(torch.nn.functional.cosine_similarity(dequantized.flatten(), reference.flatten(), dim=0))
+        entry = {
+            "name": name,
+            "logical_shape": list(tensor.shape),
+            "weight_storage_shape": list(serialized[""].shape),
+            "weight_storage_dtype": str(serialized[""].dtype).replace("torch.", ""),
+            "reconstruction_relative_l2": rel_l2,
+            "reconstruction_cosine": cosine,
+            "reconstruction_max_abs": float(diff.abs().max()),
+            "source_amax": float(reference.abs().max()),
+        }
+        if args.format == "fp8":
+            entry["weight_scale"] = float(params.scale.reshape(-1)[0])
+        else:
+            entry["weight_scale_2"] = float(params.scale.reshape(-1)[0])
+            entry["weight_scale_shape"] = list(serialized["_scale"].shape)
+            entry["weight_scale_dtype"] = str(serialized["_scale"].dtype).replace("torch.", "")
+            entry["block_scale_min"] = float(serialized["_scale"].to(torch.float32).min())
+            entry["block_scale_max"] = float(serialized["_scale"].to(torch.float32).max())
+        linears.append(entry)
+        print(
+            f"[quantize] {index:4d}/{len(source)} {name} relL2={rel_l2:.6f} cos={cosine:.8f}",
+            flush=True,
+        )
+        del weight, qdata, params, dequantized, reference, diff
+        torch.cuda.empty_cache()
+
+    expected_linears = 50 * 5
+    if len(linears) != expected_linears:
+        raise SystemExit(f"expected {expected_linears} quantized linears, got {len(linears)}")
+
+    print(f"[quantize] writing {len(output)} tensors to {args.dst}", flush=True)
+    args.dst.parent.mkdir(parents=True, exist_ok=True)
+    save_file(output, str(args.dst), metadata=metadata)
+    out_sha256 = sha256_file(args.dst)
+    out_header = safetensors_header(args.dst)
+
+    # Pass-through tensors must survive byte-for-byte. Compare every dense tensor
+    # from the written file against the source file, not against the in-memory copy.
+    pass_through = [name for name in source if not QUANT_LINEAR.match(name)]
+    identical = 0
+    with safe_open(str(args.src), framework="pt", device="cpu") as src_reader, safe_open(
+        str(args.dst), framework="pt", device="cpu"
+    ) as dst_reader:
+        for name in pass_through:
+            left = src_reader.get_tensor(name)
+            right = dst_reader.get_tensor(name)
+            if left.dtype != right.dtype or left.shape != right.shape or not torch.equal(left, right):
+                raise SystemExit(f"pass-through tensor changed: {name}")
+            identical += 1
+
+    receipt = {
+        "schema": "omniref-comfy-quant-receipt-v1",
+        "created_utc": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "format": args.format,
+        "format_description": spec["documented_name"],
+        "source": {
+            "path": str(args.src),
+            "bytes": args.src.stat().st_size,
+            "sha256": src_sha256,
+            "tensor_count": src_header["tensor_count"],
+            "metadata": src_header["metadata"],
+        },
+        "output": {
+            "path": str(args.dst),
+            "bytes": args.dst.stat().st_size,
+            "sha256": out_sha256,
+            "tensor_count": out_header["tensor_count"],
+        },
+        "runtime": {
+            "torch": torch.__version__,
+            "cuda": torch.version.cuda,
+            "gpu": torch.cuda.get_device_name(0),
+            "comfy_kitchen": importlib.metadata.version("comfy-kitchen"),
+            "comfyui_commit": args.comfyui_commit,
+        },
+        "policy": {
+            "quantized_linears": "all 50 DiT blocks: fused qkv_proj, out_proj, to_gate_compress, mlp.fc1, mlp.fc2",
+            "dense_linears": "token refiner, AdaLN, norms, embeddings, patch/condition projections, FP32 PDD heads",
+            "qkv": "fused by the native Comfy conversion, then quantized as one tensor with one weight scale",
+            "activation_quantization": spec["activation"],
+            "native_comfy_layout": spec["layout"],
+        },
+        "quantized_linear_count": len(linears),
+        "quantized_linears": linears,
+        "pass_through_tensor_count": identical,
+        "pass_through_byte_identical": True,
+        "elapsed_seconds": round(time.time() - started, 1),
+    }
+    args.receipt.parent.mkdir(parents=True, exist_ok=True)
+    args.receipt.write_text(json.dumps(receipt, indent=2) + "\n")
+    print(json.dumps({k: receipt[k] for k in ("format", "output", "quantized_linear_count", "elapsed_seconds")}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

conversion/validate_native_comfy.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""CPU format/schema validation for native ComfyUI OmniRef quantized checkpoints.
+
+Checks, without CUDA:
+  * the exact quantized-linear set and native Comfy marker JSON;
+  * storage dtypes/shapes against the pinned ComfyUI layout rules;
+  * every dense tensor is byte-identical to the BF16 source;
+  * the pinned ComfyUI detector recovers the expected architecture;
+  * when possible, a strict native state-dict load on CPU through ``comfy.ops``.
+
+FP8/NVFP4 kernel execution is validated separately on the GPU.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import math
+from pathlib import Path
+import sys
+
+import torch
+from safetensors import safe_open
+
+QUANT_LINEAR = __import__("re").compile(
+    r"^blocks\.\d+\.(?:attn\.(?:qkv_proj|out_proj|to_gate_compress)|mlp\.(?:fc1|fc2))\.weight$"
+)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(64 * 1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def header(path: Path) -> tuple[list[str], dict, dict]:
+    with safe_open(str(path), framework="pt", device="cpu") as handle:
+        keys = list(handle.keys())
+        metadata = handle.metadata() or {}
+        details = {key: (str(handle.get_slice(key).get_dtype()), list(handle.get_slice(key).get_shape())) for key in keys}
+    return keys, metadata, details
+
+
+def is_nvfp4(metadata: dict) -> bool:
+    return json.loads(metadata.get("quantization", "{}")).get("format") == "nvfp4"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--src", required=True, type=Path, help="BF16 native Comfy source")
+    parser.add_argument("--dst", required=True, type=Path, help="Quantized native Comfy file")
+    parser.add_argument("--format", required=True, choices=["fp8", "nvfp4"])
+    parser.add_argument("--receipt", required=True, type=Path)
+    parser.add_argument("--comfy-root", default=None, help="Pinned ComfyUI checkout for native detection/load")
+    args = parser.parse_args()
+
+    errors: list[str] = []
+    src_keys, src_meta, src_details = header(args.src)
+    dst_keys, dst_meta, dst_details = header(args.dst)
+
+    expected_quant = {key for key in src_keys if QUANT_LINEAR.match(key)}
+    expected_markers = {key[: -len(".weight")] + ".comfy_quant" for key in expected_quant}
+    if len(expected_quant) != 250:
+        errors.append(f"expected 250 quantized linears in source, found {len(expected_quant)}")
+
+    actual_base = {key for key in dst_keys if QUANT_LINEAR.match(key)}
+    if actual_base != expected_quant:
+        errors.append("quantized weight set differs from expected block linears")
+
+    for name in expected_quant:
+        marker_key = name[: -len(".weight")] + ".comfy_quant"
+        if marker_key not in dst_details:
+            errors.append(f"missing marker: {marker_key}")
+            continue
+        with safe_open(str(args.dst), framework="pt", device="cpu") as handle:
+            marker = json.loads(handle.get_tensor(marker_key).numpy().tobytes())
+        expected_format = "float8_e4m3fn" if args.format == "fp8" else "nvfp4"
+        if marker.get("format") != expected_format:
+            errors.append(f"bad marker for {name}: {marker}")
+        scale_key = name + "_scale"
+        if scale_key not in dst_details:
+            errors.append(f"missing scale: {scale_key}")
+        if args.format == "nvfp4":
+            if name + "_scale_2" not in dst_details:
+                errors.append(f"missing global scale: {name}_scale_2")
+            logical = src_details[name][1]
+            rows, cols = logical
+            expected_storage = [rows, math.ceil(cols / 16) * 8]  # K/2 with 16x padding
+            storage_shape = dst_details[name][1]
+            if storage_shape != expected_storage:
+                errors.append(f"{name}: NVFP4 storage {storage_shape} != {expected_storage}")
+            scale_shape = dst_details[scale_key][1]
+            expected_scale = [rows, math.ceil(cols / 16)]
+            if scale_shape != expected_scale:
+                errors.append(f"{name}: block scale {scale_shape} != {expected_scale}")
+            if dst_details[name][0] != "U8":
+                errors.append(f"{name}: NVFP4 storage dtype {dst_details[name][0]} != U8")
+        else:
+            if dst_details[name][1] != src_details[name][1]:
+                errors.append(f"{name}: FP8 shape {dst_details[name][1]} != {src_details[name][1]}")
+            if dst_details[name][0] != "F8_E4M3":
+                errors.append(f"{name}: FP8 dtype {dst_details[name][0]} != F8_E4M3")
+            if dst_details[scale_key][1] not in ([], [1]):
+                errors.append(f"{name}: FP8 weight_scale shape {dst_details[scale_key][1]} is not per-tensor")
+
+    # Dense pass-through tensors must be byte-identical.
+    dense = [key for key in src_keys if not QUANT_LINEAR.match(key)]
+    changed = []
+    with safe_open(str(args.src), framework="pt", device="cpu") as src_reader, safe_open(
+        str(args.dst), framework="pt", device="cpu"
+    ) as dst_reader:
+        for name in dense:
+            left = src_reader.get_tensor(name)
+            right = dst_reader.get_tensor(name)
+            if left.dtype != right.dtype or left.shape != right.shape or not torch.equal(left, right):
+                changed.append(name)
+    if changed:
+        errors.append(f"dense tensors changed: {changed[:8]}")
+
+    detected = None
+    native_load = {"status": "not_requested"}
+    if args.comfy_root:
+        sys.path.insert(0, str(Path(args.comfy_root).resolve()))
+        try:
+            import comfy.model_detection
+            import comfy.ops
+            from comfy.ldm.minimax.model import MiniMaxH3Model
+            from safetensors.torch import load_file
+
+            state = load_file(str(args.dst), device="cpu")
+            detected = comfy.model_detection.detect_unet_config(state, "", metadata=dst_meta)
+            expected_arch = {
+                "image_model": "minimax_h3",
+                "num_layers": 50,
+                "token_refiner_num_layers": 2,
+                "hidden_size": 5376,
+                "latents_dim": 24,
+                "audio_latents_dim": 32,
+                "attention_head_dim": 128,
+                "num_attention_heads": 56,
+                "ffn_hidden_size": 14336,
+                "gate_compress": True,
+                "pdd_steps": 32,
+            }
+            for key, value in expected_arch.items():
+                if detected.get(key) != value:
+                    errors.append(f"detected {key}={detected.get(key)!r} != {value!r}")
+            operations = comfy.ops.mixed_precision_ops(
+                {"mixed_ops": True}, compute_dtype=torch.float32, disabled=set()
+            )
+            model = MiniMaxH3Model(**detected, dtype=torch.float32, device="cpu", operations=operations)
+            result = model.load_state_dict(state, strict=True)
+            native_load = {
+                "status": "passed",
+                "missing_keys": list(result.missing_keys),
+                "unexpected_keys": list(result.unexpected_keys),
+            }
+            if result.missing_keys or result.unexpected_keys:
+                errors.append("native strict load reported missing/unexpected keys")
+        except Exception as exc:  # noqa: BLE001 - report exact environment limitation
+            # The format/schema checks above are authoritative on CPU. Some
+            # comfy-kitchen builds cannot construct quantized modules without a
+            # CUDA context; the GPU end-to-end run covers that path.
+            native_load = {"status": "unavailable", "error": f"{type(exc).__name__}: {exc}"}
+
+    receipt = {
+        "schema": "omniref-comfy-schema-validation-v1",
+        "created_utc": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "format": args.format,
+        "source": {"path": str(args.src), "sha256": sha256_file(args.src), "tensor_count": len(src_keys)},
+        "quantized": {"path": str(args.dst), "sha256": sha256_file(args.dst), "tensor_count": len(dst_keys)},
+        "checks": {
+            "quantized_linear_count": len(expected_quant),
+            "markers_present": sorted(expected_markers) == sorted(
+                key for key in dst_keys if key.endswith(".comfy_quant")
+            ),
+            "dense_tensors_checked": len(dense),
+            "dense_tensors_changed": changed,
+            "detected_config": detected,
+            "native_cpu_strict_load": native_load,
+        },
+        "errors": errors,
+        "result": "passed" if not errors else "failed",
+    }
+    args.receipt.parent.mkdir(parents=True, exist_ok=True)
+    args.receipt.write_text(json.dumps(receipt, indent=2) + "\n")
+    print(json.dumps({"result": receipt["result"], "errors": errors, "native": native_load}, indent=2))
+    return 0 if not errors else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

provenance/CONVERSION.md

@@ -0,0 +1,55 @@
+# NVFP4 QAD Comfy conversion and quantization
+
+## Source
+
+- Dense BF16 QAD master: `transformer_bf16` (14 shards), exported from the QAD student
+  of `FastVideo/FastVideo-FastH3-Omni-8-Step-V1`.
+- The master has the canonical OmniRef geometry: 688 tensors, 50 transformer blocks,
+  32 PDD heads, video/audio shifts 12/3, VSA gate compression.
+- All tensors outside the QAD-trained projections are byte-identical to the original
+  OmniRef transformer; the trained attention/MLP projections differ. See
+  `QAD_SOURCE_VERIFICATION.json`.
+- Pinned ComfyUI: `b1a247c9cf9dbfda4b2c0a0c1d50950667eeaa0c`.
+- Pinned comfy-kitchen: `0.2.39`.
+
+## Conversion
+
+The dense BF16 master is converted with the OmniRef native Comfy converter:
+
+- rename every source tensor to the native ComfyUI names;
+- fuse Q/K/V in q, k, v row order, including the token refiner;
+- swap the two SwiGLU input halves;
+- convert the 32 PDD heads to Comfy's FP32 first-head-plus-offset layout;
+- derive the persistent RoPE frequencies;
+- apply the rank-8 AdaLN time-embedding curve on a 1025-point grid, the same
+  compression used by the BF16 OmniRef Comfy export.
+
+## Quantization
+
+This is a new PTQ export of the QAD BF16 master, not a byte-preserving repack of the
+FastVideo packed NVFP4 checkpoint.
+
+- Q/K/V are fused by the native Comfy conversion before quantization. Comfy's fused
+  `qkv_proj` therefore receives **one per-tensor global scale** plus FP8 block scales
+  (group size 16), matching `TensorCoreNVFP4Layout`.
+- The FastVideo packed QAD checkpoint stores separate Q/K/V matrices with independent
+  global scales; concatenating those tensors unchanged would not be valid for Comfy's
+  fused module.
+- `out_proj`, `to_gate_compress`, `mlp.fc1`, and `mlp.fc2` in all 50 blocks are
+  quantized with the same native NVFP4 layout.
+- ComfyUI dynamically quantizes activations per tensor at runtime.
+- Token refiner, AdaLN, norms, embeddings, patch/condition projections, and FP32 PDD
+  output heads stay dense and byte-identical to the QAD BF16 Comfy conversion.
+- Comfy marker: `{"format":"nvfp4"}` on each quantized module.
+
+## Reproduce
+
+```bash
+python convert_omniref_comfy.py   --src transformer_bf16   --contract fastvideo_inference.json   --output fasth3_omniref_qad_bf16_comfy.safetensors   --scratch scratch-qad-curve-r8   --adaln-curve-rank 8 --curve-grid 1025
+
+python quantize_native_comfy.py   --src fasth3_omniref_qad_bf16_comfy.safetensors   --dst fasth3_omniref_qad_nvfp4_comfy.safetensors   --format nvfp4   --receipt nvfp4_quantization.json   --expect-tensors 582
+```
+
+The receipts record source/output SHA256 hashes, runtime versions, every quantized
+linear, and per-linear reconstruction error.
+

provenance/QAD_CONVERSION_RECEIPT.json

@@ -0,0 +1,403 @@
+{
+  "file": "fasth3_omniref_qad_bf16_comfy.safetensors",
+  "bytes": 44240780704,
+  "sha256": "4e244969987e3c6e16bffa449bcf62c1f7c83b5cce15e5806246d3ae8055154f",
+  "tensors": 582,
+  "tensor_data_bytes": 44240717408,
+  "source_repo": "FastVideo/FastVideo-FastH3-Omni-8-Step-V1",
+  "source_revision": "88d512c5e7cc38dda499fbb65688ce58611f9c80",
+  "source_index_sha256": "40979168a4c9f720953f5af95552603a5273f4eee3e58d3615514a6267cc3d46",
+  "source_config": {
+    "_class_name": "MiniMaxH3Transformer3DModel",
+    "_diffusers_version": "0.36.0.dev0",
+    "attention_head_dim": 128,
+    "audio_in_channels": 32,
+    "ffn_dim": 14336,
+    "final_norm_eps": 1e-05,
+    "freq_dim": 256,
+    "hidden_size": 5376,
+    "in_channels": 24,
+    "norm_eps": 1e-05,
+    "num_attention_heads": 56,
+    "num_layers": 50,
+    "num_refiner_layers": 2,
+    "patch_size": [
+      1,
+      2,
+      2
+    ],
+    "pdd_steps": 32,
+    "qk_norm_eps": 1e-05,
+    "rope_freq_dim": 16,
+    "rope_theta": 10000.0,
+    "text_dim": 5120,
+    "time_embed_dim": 2688,
+    "time_embed_hidden_dim": 5376
+  },
+  "source_contract": {
+    "attention_backend": "VIDEO_SPARSE_ATTN_H3",
+    "audio_scheduler_shift": 3.0,
+    "base_model_revision": "hf://MiniMaxAI/MiniMax-H3@9bfb6693f2cf6de171db46d1aa586f67d773a1da",
+    "conditioning": "fixed_ordered_references_target_only_flow",
+    "grid_max_t": 0.999,
+    "guidance_scale": 1.0,
+    "model_type": "ref2va",
+    "num_inference_steps": 8,
+    "pdd_step_indices": [
+      0,
+      4,
+      8,
+      12,
+      16,
+      20,
+      24,
+      28,
+      32
+    ],
+    "pdd_steps": 32,
+    "schema": "fasth3-inference-contract-v1",
+    "schema_version": "fasth3-inference-contract-v1",
+    "transformer_component": "transformer_ref",
+    "transformer_forwards": 8,
+    "video_scheduler_shift": 12.0,
+    "vsa_ref_keep_rate": 0.1,
+    "vsa_ref_policy": "p2_multi_region",
+    "vsa_sparsity": 0.9,
+    "vsa_tile_size": 128
+  },
+  "source_tensors": 688,
+  "source_tensor_bytes": 70142174464,
+  "skipped_source_tensors": [],
+  "conversion": [
+    "concatenateQKV",
+    "swapSwiGLUhalves",
+    "PDDfullheadsToFP32offsetheads",
+    "deriveRoPE"
+  ],
+  "curve": {
+    "kind": "time-embedding-curve-svd-and-linear-interpolation",
+    "rank": 8,
+    "grid": 1025,
+    "table_dtype": "F32",
+    "projected_weight_dtype": "F32",
+    "fit_domain": [
+      0.0,
+      1.0
+    ],
+    "fit_relative_residual": 0.00010133369976635075,
+    "holdout_timesteps": 129,
+    "holdout_modulation_samples": [
+      {
+        "tensor": "norm_out.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002865233464574267,
+        "max_abs": 0.0006642544918661342
+      },
+      {
+        "tensor": "transformer_blocks.0.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00028220971342389804,
+        "max_abs": 0.000655848104541279
+      },
+      {
+        "tensor": "transformer_blocks.1.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002500019094960694,
+        "max_abs": 0.0005601141953750499
+      },
+      {
+        "tensor": "transformer_blocks.10.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002416551213296664,
+        "max_abs": 0.0005127902298566189
+      },
+      {
+        "tensor": "transformer_blocks.11.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00025566255176295583,
+        "max_abs": 0.0006970543184967593
+      },
+      {
+        "tensor": "transformer_blocks.12.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002803780968880836,
+        "max_abs": 0.0005343511257961397
+      },
+      {
+        "tensor": "transformer_blocks.13.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002584695908441387,
+        "max_abs": 0.0004739712926107309
+      },
+      {
+        "tensor": "transformer_blocks.14.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002910532788419137,
+        "max_abs": 0.0006167935081637932
+      },
+      {
+        "tensor": "transformer_blocks.15.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002469427830971245,
+        "max_abs": 0.00035769183356759715
+      },
+      {
+        "tensor": "transformer_blocks.16.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00028391790586773294,
+        "max_abs": 0.00047246609881251844
+      },
+      {
+        "tensor": "transformer_blocks.17.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002869634349253921,
+        "max_abs": 0.0007902806770636595
+      },
+      {
+        "tensor": "transformer_blocks.18.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002485772094970746,
+        "max_abs": 0.0006660115750541928
+      },
+      {
+        "tensor": "transformer_blocks.19.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00022820637810836426,
+        "max_abs": 0.000454958769330438
+      },
+      {
+        "tensor": "transformer_blocks.2.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00027655427074800646,
+        "max_abs": 0.0009016942397257477
+      },
+      {
+        "tensor": "transformer_blocks.20.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00030725577566114673,
+        "max_abs": 0.0008379473900057555
+      },
+      {
+        "tensor": "transformer_blocks.21.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00023061350160196578,
+        "max_abs": 0.0011666881189658085
+      },
+      {
+        "tensor": "transformer_blocks.22.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00023835166467095758,
+        "max_abs": 0.0007218851744519306
+      },
+      {
+        "tensor": "transformer_blocks.23.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002533558506562286,
+        "max_abs": 0.0007599189025755404
+      },
+      {
+        "tensor": "transformer_blocks.24.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00025434361772686556,
+        "max_abs": 0.0006184998097025218
+      },
+      {
+        "tensor": "transformer_blocks.25.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002803287478038723,
+        "max_abs": 0.0008424069119212785
+      },
+      {
+        "tensor": "transformer_blocks.26.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002427097226267563,
+        "max_abs": 0.0005747431665024116
+      },
+      {
+        "tensor": "transformer_blocks.27.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002610874979495917,
+        "max_abs": 0.0011547877335882362
+      },
+      {
+        "tensor": "transformer_blocks.28.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00025688772628382954,
+        "max_abs": 0.0007070723287414538
+      },
+      {
+        "tensor": "transformer_blocks.29.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00026883960881806534,
+        "max_abs": 0.0008599025781315106
+      },
+      {
+        "tensor": "transformer_blocks.3.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002368578247393376,
+        "max_abs": 0.0009200827465114525
+      },
+      {
+        "tensor": "transformer_blocks.30.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00024855077930941723,
+        "max_abs": 0.0013539101566308887
+      },
+      {
+        "tensor": "transformer_blocks.31.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.000248474962059711,
+        "max_abs": 0.0012859274503882467
+      },
+      {
+        "tensor": "transformer_blocks.32.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002428254709366112,
+        "max_abs": 0.0014554129821475748
+      },
+      {
+        "tensor": "transformer_blocks.33.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00023598417936072013,
+        "max_abs": 0.001837545487124892
+      },
+      {
+        "tensor": "transformer_blocks.34.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002501798711765004,
+        "max_abs": 0.002109945793156154
+      },
+      {
+        "tensor": "transformer_blocks.35.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002425583822798537,
+        "max_abs": 0.002020115661256483
+      },
+      {
+        "tensor": "transformer_blocks.36.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00023483459603999013,
+        "max_abs": 0.0017876969071357607
+      },
+      {
+        "tensor": "transformer_blocks.37.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00023134358346439085,
+        "max_abs": 0.0017698832170331968
+      },
+      {
+        "tensor": "transformer_blocks.38.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00022657149892788762,
+        "max_abs": 0.0019057241907223244
+      },
+      {
+        "tensor": "transformer_blocks.39.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00022759120835296538,
+        "max_abs": 0.0022020056775189367
+      },
+      {
+        "tensor": "transformer_blocks.4.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002595302991378682,
+        "max_abs": 0.0008776936584853345
+      },
+      {
+        "tensor": "transformer_blocks.40.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002313392567915914,
+        "max_abs": 0.0023742669073691935
+      },
+      {
+        "tensor": "transformer_blocks.41.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00022581828148539781,
+        "max_abs": 0.002467452761190536
+      },
+      {
+        "tensor": "transformer_blocks.42.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00022962368103619676,
+        "max_abs": 0.002600971318656775
+      },
+      {
+        "tensor": "transformer_blocks.43.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002246428667526305,
+        "max_abs": 0.0023927730378194845
+      },
+      {
+        "tensor": "transformer_blocks.44.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00022718124717151158,
+        "max_abs": 0.002239463950175047
+      },
+      {
+        "tensor": "transformer_blocks.45.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00023251823784486256,
+        "max_abs": 0.002354271058670143
+      },
+      {
+        "tensor": "transformer_blocks.46.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00023286344384665863,
+        "max_abs": 0.003132404161736435
+      },
+      {
+        "tensor": "transformer_blocks.47.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00022930350045823262,
+        "max_abs": 0.0035076916507517097
+      },
+      {
+        "tensor": "transformer_blocks.48.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002468179623068937,
+        "max_abs": 0.0029221208618497307
+      },
+      {
+        "tensor": "transformer_blocks.49.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00028150893929036644,
+        "max_abs": 0.005873630323451895
+      },
+      {
+        "tensor": "transformer_blocks.5.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00024675880824154896,
+        "max_abs": 0.000894859385961233
+      },
+      {
+        "tensor": "transformer_blocks.6.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00029495062340505695,
+        "max_abs": 0.0006582339453927721
+      },
+      {
+        "tensor": "transformer_blocks.7.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.00028241220478707007,
+        "max_abs": 0.0006037143577201087
+      },
+      {
+        "tensor": "transformer_blocks.8.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002680551951240189,
+        "max_abs": 0.0004946770126523781
+      },
+      {
+        "tensor": "transformer_blocks.9.adaln_proj.linear.weight",
+        "sampled_rows": 64,
+        "relative_l2": 0.0002718576327394062,
+        "max_abs": 0.0005833224778661883
+      }
+    ],
+    "approximation": true,
+    "end_to_end_quality_validated": false
+  },
+  "comfyui_commit": "b1a247c9cf9dbfda4b2c0a0c1d50950667eeaa0c",
+  "comfy_model_tools_commit": "d6797787e6bdb1a1fb0094d588a26f8e71a1c757",
+  "gpu_inference_validated": false
+}

provenance/QAD_SOURCE_VERIFICATION.json

@@ -0,0 +1,98 @@
+{
+  "schema": "omniref-qadv2-source-verification-v1",
+  "created_utc": "2026-10-20T16:32:41.097733+00:00",
+  "qad_master": {
+    "path": "/mnt/nfs/vlm-aryan/v2-qad/export/omniref-v2-work/transformer_bf16",
+    "config_sha256": "658c1f6278262db3072d9a6f4832c7c49280f91c94a8455414525cd6648de677",
+    "index_sha256": "40979168a4c9f720953f5af95552603a5273f4eee3e58d3615514a6267cc3d46",
+    "tensor_count": 688,
+    "shards": [
+      {
+        "name": "diffusion_pytorch_model-00001-of-00014.safetensors",
+        "bytes": 5296610024,
+        "sha256": "c4e6ee7a05a2030ae144bb1705c1cdd6045573623a1c3ab1be494b60c6690476"
+      },
+      {
+        "name": "diffusion_pytorch_model-00002-of-00014.safetensors",
+        "bytes": 5318721280,
+        "sha256": "51b025ef7cf4f91b8bb26225f6f35161edb3c96e311d344ad963e7bbb7607e14"
+      },
+      {
+        "name": "diffusion_pytorch_model-00003-of-00014.safetensors",
+        "bytes": 5318721272,
+        "sha256": "3781d4bf62e9a06bb420b4516ffbdbc36f460d3a130893f6b8bd8eba8ce3d59a"
+      },
+      {
+        "name": "diffusion_pytorch_model-00004-of-00014.safetensors",
+        "bytes": 4952636536,
+        "sha256": "811754513bff92a57b63bbe8ad5fe89830372a9f25b50e3016b421c14cdf08e8"
+      },
+      {
+        "name": "diffusion_pytorch_model-00005-of-00014.safetensors",
+        "bytes": 5318506024,
+        "sha256": "a7112bbb54de4b6ed9f6e6a05ee3e139a3e4796cb6fb9911d716c1a6791ffcaa"
+      },
+      {
+        "name": "diffusion_pytorch_model-00006-of-00014.safetensors",
+        "bytes": 5164580720,
+        "sha256": "197c47754ac26930f5e074ffb25044c0cfa482821e9a05d809f0d5e0194336b5"
+      },
+      {
+        "name": "diffusion_pytorch_model-00007-of-00014.safetensors",
+        "bytes": 5318721272,
+        "sha256": "790c78c978138cd551e8ee6fba8a9e24c9814d333d026ee8033792737f1ae975"
+      },
+      {
+        "name": "diffusion_pytorch_model-00008-of-00014.safetensors",
+        "bytes": 5318721280,
+        "sha256": "16ae3aab7b106065c66df86a8cf5b514fe80884f0c9a3f9a25304cae1f72f828"
+      },
+      {
+        "name": "diffusion_pytorch_model-00009-of-00014.safetensors",
+        "bytes": 4875566088,
+        "sha256": "c3c8b1dd4d4779ff46750680e347768d712d8478d217a297dc420729e2b41521"
+      },
+      {
+        "name": "diffusion_pytorch_model-00010-of-00014.safetensors",
+        "bytes": 5318506016,
+        "sha256": "a20c102b9751092d2c1433ccc30915c6edbf336aee4942aaa2fda1b20f6614c4"
+      },
+      {
+        "name": "diffusion_pytorch_model-00011-of-00014.safetensors",
+        "bytes": 5164580720,
+        "sha256": "2a8671bed7eb63674216e62072d9b0e02952180f534932a3ff287d6d9dabe7aa"
+      },
+      {
+        "name": "diffusion_pytorch_model-00012-of-00014.safetensors",
+        "bytes": 5318721288,
+        "sha256": "17c5a514c579a0d50b78fa8570fd6686f15209d138acf3bbdfcf0b8f6f212edd"
+      },
+      {
+        "name": "diffusion_pytorch_model-00013-of-00014.safetensors",
+        "bytes": 5318721240,
+        "sha256": "836c79d282a1a08343f72f80144b4cadae6e16eef0236f3e2a171acc460aa820"
+      },
+      {
+        "name": "diffusion_pytorch_model-00014-of-00014.safetensors",
+        "bytes": 2138941328,
+        "sha256": "f1448e520232cb61df53beb2521b105d5b4e54226d0c9508ac5d9d1eff8575c8"
+      }
+    ]
+  },
+  "base_reference": {
+    "path": "/mnt/nfs/vlm-aryan/h3-omniref-qad/model/transformer_ref",
+    "index_sha256": "40979168a4c9f720953f5af95552603a5273f4eee3e58d3615514a6267cc3d46",
+    "tensor_count": 688
+  },
+  "checks": {
+    "key_sets_equal": true,
+    "shape_or_dtype_mismatches": [],
+    "frozen_tensors_byte_identical": 388,
+    "trained_tensors_byte_identical": 0,
+    "trained_tensors_changed": 300,
+    "trained_pattern": "^transformer_blocks\\.\\d+\\.(?:attn\\.(?:to_q|to_k|to_v|to_out(?:\\.0)?)|ff\\.(?:net\\.0\\.proj|net\\.2))\\.(?:weight|bias)$",
+    "all_frozen_tensors_match_base": true,
+    "qad_training_visible_in_trained_tensors": true
+  },
+  "result": "passed"
+}

provenance/SCHEMA_VALIDATION.json

@@ -0,0 +1,50 @@
+{
+  "schema": "omniref-comfy-schema-validation-v1",
+  "created_utc": "2026-10-20T16:51:58.256998+00:00",
+  "format": "nvfp4",
+  "source": {
+    "path": "/mnt/nfs/vlm-aryan/omniref-comfy-quant/out/fasth3_omniref_qad_bf16_comfy.safetensors",
+    "sha256": "4e244969987e3c6e16bffa449bcf62c1f7c83b5cce15e5806246d3ae8055154f",
+    "tensor_count": 582
+  },
+  "quantized": {
+    "path": "/mnt/nfs/vlm-aryan/omniref-comfy-quant/out/fasth3_omniref_qad_nvfp4_comfy.safetensors",
+    "sha256": "bf25ee58df65b4dfee349d612f7ac62a2fea0dddd1e68eb37e75c8ce8b166f5a",
+    "tensor_count": 1332
+  },
+  "checks": {
+    "quantized_linear_count": 250,
+    "markers_present": true,
+    "dense_tensors_checked": 332,
+    "dense_tensors_changed": [],
+    "detected_config": {
+      "image_model": "minimax_h3",
+      "num_layers": 50,
+      "token_refiner_num_layers": 2,
+      "hidden_size": 5376,
+      "latents_dim": 24,
+      "audio_latents_dim": 32,
+      "attention_head_dim": 128,
+      "num_attention_heads": 56,
+      "ffn_hidden_size": 14336,
+      "text_dim": 5120,
+      "adaln_curve_grid": 1025,
+      "time_embed_dim": 8,
+      "rope_inv_freq_len": 16,
+      "gate_compress": true,
+      "pdd_steps": 32,
+      "sigma_shift_video": 12.0,
+      "sigma_shift_audio": 3.0,
+      "norm_eps": 1e-05,
+      "qk_norm_eps": 1e-05,
+      "final_norm_eps": 1e-05
+    },
+    "native_cpu_strict_load": {
+      "status": "passed",
+      "missing_keys": [],
+      "unexpected_keys": []
+    }
+  },
+  "errors": [],
+  "result": "passed"
+}

provenance/SOURCE_HASH_VERIFICATION.json

@@ -0,0 +1,28 @@
+{
+  "files": [
+    {
+      "path": "diffusion_models/fasth3_omniref_8step_pruned_bf16.safetensors",
+      "bytes": 44240780704,
+      "sha256": "c0fac98c0317eb85215bd186b250be9b113675baab1323add40f26262f552ed9",
+      "manifest_match": true
+    },
+    {
+      "path": "text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+      "bytes": 15687142551,
+      "sha256": "35a88d51044231fe332301d7a62aa81e3f2cba62febeb446e2c1e3e0ef76f2c6",
+      "manifest_match": true
+    },
+    {
+      "path": "vae/minimax_h3_video_vae_int8_convrot.safetensors",
+      "bytes": 2811065184,
+      "sha256": "52a2c8c73583c86e4f41cdcce3a6ad0ea562987bc0bf3d60a0cef5f5c8e60c0e",
+      "manifest_match": true
+    },
+    {
+      "path": "vae/minimax_h3_audio_vae_fp32.safetensors",
+      "bytes": 605254808,
+      "sha256": "8e505d95dd1561d47abd43d4238fd40d9bb1ae9e147ed0a4cba778d76ae4db48",
+      "manifest_match": true
+    }
+  ]
+}

provenance/VALIDATION.json

@@ -0,0 +1,202 @@
+{
+  "schema": "omniref-comfy-validation-v1",
+  "all_passed": true,
+  "pairs": [
+    {
+      "reference": "/mnt/nfs/vlm-aryan/omniref-comfy-quant/results/qad_couple_bf16_00001_.mp4",
+      "variant": "/mnt/nfs/vlm-aryan/omniref-comfy-quant/results/qad_couple_nvfp4_00001_.mp4",
+      "reference_streams": {
+        "video": {
+          "codec_name": "h264",
+          "width": 832,
+          "height": 480,
+          "nb_frames": "124",
+          "duration": "5.166667",
+          "avg_frame_rate": "24/1"
+        },
+        "audio": {
+          "codec_name": "aac",
+          "sample_rate": "32000",
+          "channels": 2,
+          "duration": "5.166688"
+        }
+      },
+      "variant_streams": {
+        "video": {
+          "codec_name": "h264",
+          "width": 832,
+          "height": 480,
+          "nb_frames": "124",
+          "duration": "5.166667",
+          "avg_frame_rate": "24/1"
+        },
+        "audio": {
+          "codec_name": "aac",
+          "sample_rate": "32000",
+          "channels": 2,
+          "duration": "5.166688"
+        }
+      },
+      "video": {
+        "psnr_db": {
+          "average": 18.055532,
+          "min": 17.019769,
+          "max": 18.784264
+        },
+        "ssim": {
+          "all": 0.645996
+        }
+      },
+      "reference_signalstats": {
+        "frames": 124,
+        "yavg_mean": 66.52045887096773,
+        "yavg_min": 64.1544,
+        "yavg_max": 69.0764,
+        "yavg_std": 1.4365474254217374,
+        "ylow_min": 23.0,
+        "yhigh_max": 141.0,
+        "range": 4.922000000000011
+      },
+      "variant_signalstats": {
+        "frames": 124,
+        "yavg_mean": 64.7651870967742,
+        "yavg_min": 63.5108,
+        "yavg_max": 65.5562,
+        "yavg_std": 0.5085328947027883,
+        "ylow_min": 18.0,
+        "yhigh_max": 127.0,
+        "range": 2.0454000000000008
+      },
+      "variant_freeze": {
+        "freeze_starts": [],
+        "freeze_count": 0
+      },
+      "audio": {
+        "samples": 165888,
+        "duration_s": 5.184,
+        "reference_rms": 0.12436776958520834,
+        "variant_rms": 0.10050172034476386,
+        "reference_peak": 0.8157475888729095,
+        "variant_peak": 0.795351654291153,
+        "variant_active_fraction": 0.9188126929012346,
+        "variant_zero_crossing_rate": 0.086655373838818,
+        "psnr_db": -0.4829138836156005,
+        "correlation": 0.3312793710414481,
+        "reference_spectral_centroid_hz": 1732.758424304872,
+        "variant_spectral_centroid_hz": 1869.7456943786385
+      },
+      "checks": {
+        "variant_has_video": true,
+        "variant_has_audio": true,
+        "variant_audio_not_silent": true,
+        "variant_audio_active": true,
+        "variant_audio_duration_matches_video": true,
+        "variant_video_has_frames": true,
+        "variant_video_has_contrast": true,
+        "variant_video_not_black": true,
+        "variant_signalstats_finite": true,
+        "variant_no_long_freeze": true
+      },
+      "passed": true,
+      "label": "qad_couple"
+    },
+    {
+      "reference": "/mnt/nfs/vlm-aryan/omniref-comfy-quant/results/qad_cyclist_bf16_00001_.mp4",
+      "variant": "/mnt/nfs/vlm-aryan/omniref-comfy-quant/results/qad_cyclist_nvfp4_00001_.mp4",
+      "reference_streams": {
+        "video": {
+          "codec_name": "h264",
+          "width": 832,
+          "height": 480,
+          "nb_frames": "124",
+          "duration": "5.166667",
+          "avg_frame_rate": "24/1"
+        },
+        "audio": {
+          "codec_name": "aac",
+          "sample_rate": "32000",
+          "channels": 2,
+          "duration": "5.166688"
+        }
+      },
+      "variant_streams": {
+        "video": {
+          "codec_name": "h264",
+          "width": 832,
+          "height": 480,
+          "nb_frames": "124",
+          "duration": "5.166667",
+          "avg_frame_rate": "24/1"
+        },
+        "audio": {
+          "codec_name": "aac",
+          "sample_rate": "32000",
+          "channels": 2,
+          "duration": "5.166688"
+        }
+      },
+      "video": {
+        "psnr_db": {
+          "average": 17.065885,
+          "min": 15.103695,
+          "max": 19.025832
+        },
+        "ssim": {
+          "all": 0.620487
+        }
+      },
+      "reference_signalstats": {
+        "frames": 124,
+        "yavg_mean": 88.1789677419355,
+        "yavg_min": 57.7666,
+        "yavg_max": 107.079,
+        "yavg_std": 16.303842333631884,
+        "ylow_min": 23.0,
+        "yhigh_max": 219.0,
+        "range": 49.3124
+      },
+      "variant_signalstats": {
+        "frames": 124,
+        "yavg_mean": 86.48673467741936,
+        "yavg_min": 65.4808,
+        "yavg_max": 113.183,
+        "yavg_std": 12.674295997449915,
+        "ylow_min": 25.0,
+        "yhigh_max": 222.0,
+        "range": 47.702200000000005
+      },
+      "variant_freeze": {
+        "freeze_starts": [],
+        "freeze_count": 0
+      },
+      "audio": {
+        "samples": 165888,
+        "duration_s": 5.184,
+        "reference_rms": 0.014723019933069991,
+        "variant_rms": 0.010349389418981452,
+        "reference_peak": 0.08551505208015442,
+        "variant_peak": 0.09483717381954193,
+        "variant_active_fraction": 0.9135561342592593,
+        "variant_zero_crossing_rate": 0.4987792895163575,
+        "psnr_db": 0.6167579897670976,
+        "correlation": 0.4456390174380726,
+        "reference_spectral_centroid_hz": 9519.315481379153,
+        "variant_spectral_centroid_hz": 7645.46219766074
+      },
+      "checks": {
+        "variant_has_video": true,
+        "variant_has_audio": true,
+        "variant_audio_not_silent": true,
+        "variant_audio_active": true,
+        "variant_audio_duration_matches_video": true,
+        "variant_video_has_frames": true,
+        "variant_video_has_contrast": true,
+        "variant_video_not_black": true,
+        "variant_signalstats_finite": true,
+        "variant_no_long_freeze": true
+      },
+      "passed": true,
+      "label": "qad_cyclist"
+    }
+  ]
+}

provenance/VALIDATION.md

@@ -0,0 +1,29 @@
+# FastH3 OmniRef NVFP4 QAD for ComfyUI validation
+
+Native ComfyUI end-to-end validation at 832x480, 124 frames (~5.2 s at 24 fps),
+8 sampling steps, Euler sampler, simple schedule, guidance 1.0, video/audio shifts 12/3.
+
+Video comparison uses ffmpeg PSNR/SSIM and signal statistics; audio comparison decodes
+to raw float samples and reports numeric duration, RMS, activity, correlation, PSNR, and
+spectral-centroid metrics. No video frame is read as an image.
+
+| Pair | PSNR avg (dB) | PSNR min (dB) | SSIM | Audio PSNR (dB) | Audio corr | Variant RMS | Active frac | Frozen spans | Result |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---|
+| qad_couple | 18.06 | 17.02 | 0.6460 | -0.48 | 0.33128 | 0.10050 | 0.9188 | 0 | pass |
+| qad_cyclist | 17.07 | 15.10 | 0.6205 | 0.62 | 0.44564 | 0.01035 | 0.9136 | 0 | pass |
+
+Per-pair checks:
+
+- `qad_couple`: variant_has_video=True, variant_has_audio=True, variant_audio_not_silent=True, variant_audio_active=True, variant_audio_duration_matches_video=True, variant_video_has_frames=True, variant_video_has_contrast=True, variant_video_not_black=True, variant_signalstats_finite=True, variant_no_long_freeze=True
+- `qad_cyclist`: variant_has_video=True, variant_has_audio=True, variant_audio_not_silent=True, variant_audio_active=True, variant_audio_duration_matches_video=True, variant_video_has_frames=True, variant_video_has_contrast=True, variant_video_not_black=True, variant_signalstats_finite=True, variant_no_long_freeze=True
+
+Environment:
+
+- ComfyUI: b1a247c9cf9dbfda4b2c0a0c1d50950667eeaa0c
+- comfy-kitchen: 0.2.39
+- PyTorch: 2.9.0a0+50eac811a6.nv25.09
+- CUDA: 13.0
+- GPU: NVIDIA GB200
+
+The comparison reference is the BF16 Comfy conversion of the same QAD master, so the metrics isolate the NVFP4 export rather than the QAD training change.
+