diff --git a/.agents/model-matrix.md b/.agents/model-matrix.md
index 010564d82..6cb4093ae 100644
--- a/.agents/model-matrix.md
+++ b/.agents/model-matrix.md
@@ -19,8 +19,10 @@ a practical unit that one agent can spike without silently dropping aliases.
 ## Architecture-support checklist
 
 At-a-glance view of which architectures we have actually engaged, and how far.
-**326 architecture rows are inventoried at the pin, plus 1 beyond-pin row
-(`KimiK3ForConditionalGeneration`, released after the pin) = 327 total**; 43 are
+**326 architecture rows are inventoried at the pin, plus 2 beyond-pin rows
+(`KimiK3ForConditionalGeneration`, released after the pin, and `MiniMaxH3DiTModel`,
+which is a DIFFUSION architecture living in the separate `vllm-omni` repository)
+= 328 total**; 44 are
 past `INVENTORIED` (engaged), the remaining 284 are known-but-not-started long tail. Every mark
 below is grounded in the row's lifecycle `State` cell plus its ledger evidence,
 and this section is CI-enforced against those rows by
@@ -43,15 +45,15 @@ Rollup by lifecycle state (must equal the detailed per-state row counts):
 |---|---|
 | ACTIVE | 24 |
 | GATING | 1 |
-| PARTIAL | 3 |
+| PARTIAL | 4 |
 | READY | 0 |
 | SPIKE | 7 |
 | BLOCKED | 5 |
 | INVENTORIED | 284 |
 | DONE | 3 |
-| **Total** | **327** |
+| **Total** | **328** |
 
-Engaged architectures (the 43 non-`INVENTORIED` rows):
+Engaged architectures (the 44 non-`INVENTORIED` rows):
 
 | Support | Architecture | Family / example | Status | Row |
 |---|---|---|---|---|
@@ -79,6 +81,7 @@ Engaged architectures (the 43 non-`INVENTORIED` rows):
 | ✅ | `Glm4MoeLiteForCausalLM` | GLM-4.7-Flash (31.2B MLA + GLM MoE) | SACRED gate 8/8 vs vLLM 0.25.0 (STRICT token-exact 1/8 + near-tie-band 7/8, 69/128 tokens strictly exact, max teacher-forced gap 0.0 nats, 0 forward-divergent; vLLM K=5 self-deterministic → STRICT bar); FIRST e2e coverage of the q_lora query branch AND the noaux_tc sigmoid router (closes the MLA campaign's two gaps, C2); speed pending | `MODEL-TEXT-glm4-moe-lite-glm4-moe-lite-for-causal-lm` |
 | 📋 | `KimiLinearForCausalLM` | Kimi-Linear | MLA half unlocked by the shared MLA campaign; the full model is not gated, row stays `SPIKE` | `MODEL-TEXT-kimi-linear-kimi-linear-for-causal-lm` |
 | 📋 | `KimiK3ForConditionalGeneration` | Kimi K3 (2.8T MoE + MoonViT-V2, DERIVE-AND-SHIP) | **W2/W5 CPU scaffolding landed** (registry stub + nested text/vision/quant config descent + text-backbone structural name-map + REFUSE-by-name forward + MXFP4-refuse loader; clean CPU build, scaffold gate 6/6). text backbone IS `KimiLinearForCausalLM` (KDA+MLA+MoE hybrid, HEAVY reuse); **does NOT fit GB10 (~1.56 TB MXFP4, ~12×)** and NOT in the pinned oracle ⇒ no on-box golden — DERIVED, proxy-gated on Kimi-Linear-48B; forward + MXFP4 + KDA delta + MoonViT-V2 not implemented (NOT-YET-BUILDABLE) | `MODEL-MM-kimi-k3-kimi-k3-for-conditional-generation` |
+| 🚧 | `MiniMaxH3DiTModel` | MiniMax-H3 (33.1B omni-modal video+audio DiT, DERIVE-AND-SHIP) | **W1/W2 landed**: packed layout (fl2va + ref2va, fp64 position grid BIT-EXACT), latent packing, euler-ancestral eta0 scheduler, and the full DiT forward all parity-gated against the UPSTREAM vLLM-Omni modules executed at reduced dimensions (**max abs diff 1.6e-7**, 10/10 cases / 2539 assertions). NOT autoregressive (no KV cache, no sampler, no logits) and **e2e HW-BLOCKED** (~354 GB checkpoint, ~133 GB/rank on 4x B300 vs 119 GiB unified); bf16 production stream + request planning + the ComfyUI-GGUF arm also landed (535 REAL tensors resolve onto our contract, geometry from shapes alone). **HW verdict CORRECTED: quantized arms FIT (~41 GB in 119 GiB)**, so e2e + speed are reachable; encoder/VAEs/audio VAE DONE (4.2e-9 vs the checkpoint's remote code); NVFP4 layout GATED as identical to ours (speed path is loader wiring); BOTH VAE DECODERS done (audio 4.2e-9, video ViT3D 8.9e-8); video tiling + 3D-CNN encoder (conditioning only) pending; encoder TEXT tower done (1.2e-7); **serving `/v1/videos` DONE and the DEVICE-RESIDENT forward (W2b, f32) LANDED + GPU-VERIFIED on Thor sm_110 at video 1.49e-7 / audio 8.94e-8**; bf16 stream + fusion folds + the FP4 path (needs sm_121a) + a real-checkpoint run pending. **2026-08-05: the AUDIO-VAE ENCODER is ported** (DAC analysis stack + `pre_block` AttnProjection + `mean_proj`, gated stage by stage vs the checkpoint's own remote code at 2.98e-8 / 1.64e-7 / 1.86e-8) with its own checkpoint loader gated on the real 1087-tensor manifest — so **ref2va AUDIO and VIDEO+AUDIO references are now WIRED** (audio rows move by 0.51 / 0.71; a different waveform still moves them by 7.1e-4). Both VAEs are now complete in both directions | `MODEL-DIFFUSION-minimax-h3-mini-max-h3-dit` |
 | ✅ | `LagunaForCausalLM` | Poolside Laguna-S-2.1 (118B/8B MoE) | **NVFP4 W4A4 ARM RAN on GB10 (N4, 2026-08-01, `CLAIM-LAGUNA-NVFP4-N4`): the additive safetensors NVFP4 arm (N1a/N1b/N2/N3 — `Nvfp4Weight` expert fields + `LoadLagunaForCausalLMWeights` + `LqGemmNvfp4Fp4` per-expert TRUE-W4A4 + `LagunaFfnBlock` `fp4` branch + `laguna_gen` dir-autodetect; CPU-gated `test_laguna_nvfp4_loader` 3/3·61, GGUF path byte-identical) generates COHERENTLY on the real 67 GiB `poolside/Laguna-S-2.1-NVFP4`. vs the vLLM MARLIN golden (vLLM's exact prompt ids injected): FIRST 2 TOKENS MATCH exactly, then near-tie divergence (our TRUE-W4A4 fp4-activations vs the MARLIN golden's W4A16 bf16-activations — different precision, EXPECTED; shares golden vocab). SPEED (N5, trace-driven, 2026-08-01): 0.16 → ~4.5 tok/s (~28× THIS SESSION), now ~4× from vLLM 18.8. **Lever #2** (nsys found the bf16 tower running host `MatmulNK` on the CUDA queue): route it to the GPU (`LqGemm` bf16 → `CastBf16` + `MatmulBT`, weight stays bf16) → 6.34 → 0.39 s/tok (16×). **Lever #1** (nsys found the emulation expert GEMM at 92%, GPU 87% busy): the engine's native sm120a fp4 tensor-core MMA (`MatmulNvfp4Fp4Native`) reads the SAME linear scales — it was gated OFF behind `VT_NVFP4_FP4_NATIVE`; default it ON in the driver → 0.39 → ~0.20-0.24 s/tok (~2×). Both coherent + near-tie (byte-identical ids to emulation; first token matches golden). Two GB10 memory fixes landed to run (shard-release + context-before-load). OPEN #234 (remaining ~4×): grouped W4A4 MoE (top_k×3 launches → 3), `ResidentNvfp4`, decode CUDA-graph + on-GPU sampling (the host-orchestration tail). Spec `.agents/specs/laguna-nvfp4-arm-2026-07-31.md` §N4/§N5. The GGUF-Q4_K track (below) is the separate keep-quant vehicle.** Prior **FASTER DECODE (W9, 2026-07-31, `CLAIM-LAGUNA-W9-GROUPED`): the 30 un-grouped per-expert keep-quant GEMV launches/step (top_k × {gate,up,down} `LqGemmRowSlice`) fold onto the SHARED `vt::MatmulBTQuantGrouped` op — per token, Pk experts' gate/up/down each collapse to ONE grouped launch over the already-stacked `[E*N,H]` tower (no loader change). Same-binary A/B on real UD-Q4_K_XL (GB10, `--gpu`, drop_caches cold, 24 tok): grouped (`VT_LAGUNA_GROUPED_MOE=1`, default) == per-expert (`=0`) BYTE-IDENTICAL (md5 `754728c6`, both == W6 golden) + decode 0.18 → 0.13 s/tok (1.38×). Routes through the shared vt op (fold policy). Cumulative with W8: decode 0.66 → 0.13 s/tok (5.1×; 1.5 → 7.7 tok/s; 18× → 3.6× vs llama.cpp 27.8). Next lever: device-resident decode (#1). See spec §W9.** Prior **FASTER DECODE (W8, 2026-07-31, `CLAIM-LAGUNA-W8-EMBED`): `LagunaEmbed` no longer converts the whole 1.23 GB embed table to f32 every token (it gathered T rows out of the whole [Vsz,H] table via `ReadF32` — ~311M host element-converts/token, the DOMINANT decode cost the W7 profile under-filed as "#5"); now gathers only the T needed rows directly (BIT-IDENTICAL — same per-element conversion, same rows). GATED on the real 3-shard UD-Q4_K_XL GGUF (GB10, `--gpu`, W6 cached, drop_caches cold, 24 tok): TOKEN-IDENTICAL to the W5/W6 golden (`22345 83 350 785 …`, coherent " Paris.") + decode 0.66 → 0.17 s/tok = 3.9× (1.5 → 5.9 tok/s; 18× → 4.7× vs llama.cpp 27.8). See `.agents/specs/laguna-s21-w7-speed-2026-07-31.md` §W8. Next: grouped-expert GEMM (=A3) then device-resident decode.** Prior **DECODE-SPEED ATTRIBUTED (W7 profile-only, 2026-07-31, `CLAIM-LAGUNA-W7-SPEED`): `nsys` of the W6 decode (real UD-Q4_K_XL GGUF, GB10) attributes the 0.66 s/tok (~1.5 tok/s vs llama.cpp 27.8 on identical bytes, ~15-18x) to HOST-ORCHESTRATION, not kernel compute — GPU active only 32.7% of the step, 67.3% host/idle; 22,115 `cudaStreamSynchronize` (~2,764/step, zero GPU overlap) from the ~1,795 per-GEMM `DrainQueue` in `LagunaForwardGgufCached` + scalar host glue; 39.4% of GPU time is `QuantizeQ8K` activation-quant (per-GEMM), weight GEMVs un-grouped at ~22% of the 240 GB/s peak (llama.cpp ~76%); no H2D/D2H (unified memory). Ranked levers (all in-tree from ds4): device-resident decode 1.5->~5-7 tok/s, grouped-expert GEMM (`MatmulBTQuantGrouped`) +1.5-2x + dedupes the activation-quant, decode CUDA-graph, tuned MMVQ; + free host cleanups (`LagunaEmbed` copies the whole 1.23 GB embed table/token, per-token RoPE-cache rebuild). Honest reachable ~13-20 tok/s, 27.8 a stretch. NO code changed. See `.agents/specs/laguna-s21-w7-speed-2026-07-31.md`. Prior RUNNABLE + FAST DECODE (W6, 2026-07-31): a per-layer K/V cache + single-token incremental decode replaces W5's O(n²) STATELESS recompute — TOKEN-IDENTICAL (byte-equal ids, md5 `754728c6…` match, == the W5 golden) and 5.05× faster per token: decode 3.33 → 0.66 s/tok on the real UD-Q4_K_XL GGUF (GB10, `--gpu`, keep-quant), same " Paris.…" text. `LagunaKvCache` (mirrors `DeepseekV4KvCache`, MLA-latent → GQA multi-head K/V; caches post-QK-RMSNorm/post-RoPE K + raw V at f32 — bit-exact since RoPE/QK-norm are position-only and attention is causal), MIXED attention per-layer: 12 GLOBAL layers grow unbounded + 36 SLIDING-WINDOW-512 layers EVICT rows beyond the 512 window (gemma2/3 `is_sliding`); `LagunaForwardGgufCached` + shared `LagunaAttention`/`LagunaFfnBlock` helpers used by BOTH forwards (identical float ops; recompute ids unchanged after refactor), `examples/laguna_gen --stateless` A/B flag. No cache bug (bit-exact first run). Next speed = grouped-expert GEMM + device-resident decode (both in-tree from ds4). See `.agents/specs/laguna-s21-w6-2026-07-31.md`. Prior RUNNABLE (W5, 2026-07-31): our engine greedy-generates COHERENT text on the REAL 3-shard UD-Q4_K_XL GGUF (GB10 keep-quant) — "The capital of France is" → " Paris. …", first token "Paris." matches the llama.cpp-Poolside reference. Multi-shard GGUF reader + keep-quant tower (`LoadLagunaFromGgufShards`) + `LagunaForwardGguf` (ds4 keep-quant Gemm/GemmRowSlice) + `examples/laguna_gen`; load 20.6s, peak 71 GiB, 3.27 s/tok stateless recompute (speed=W6).** Prior W3: **W3 REAL forward + 3 new ops landed** (`laguna_ops.cpp`: per-head softplus attn out-gate + ungrouped sigmoid-noaux router + dual per-layer RoPE cos/sin builders; `LagunaModel::Forward` now a REAL runnable host-reference composition — variable-Q-head GQA + dual RoPE + sliding-window mask + softplus gate + dense L0 / ungrouped-MoE L1..47 + untied lm_head — replacing the W1/W2 `VT_CHECK(false)` stub; CPU `-Werror` full-library build clean; `test_laguna_scaffold` **8/8·166** incl. softplus math, router selection+tie-break RED-first, dual-RoPE cos/sin bit-match, variable-Q-head shapes, forward composition on synthetic weights; `test_model_registry` 24/24). W1 oracle DECISION: vLLM native `laguna.py` in pin ⇒ config constructs; dual-oracle = vLLM-NVFP4/-FP8 (fits GB10, BF16 235 GiB does NOT) + llama.cpp-Q4_K token-exact. DEFERRED to W4 (needs 73 GB checkpoint): GGUF keep-quant tower materialization + device/paged production forward + strict dual-oracle greedy gate. ~85-90% reuse (ds4-MoE + gemma-sliding + olmo3-dual-rope + landed Q4_K keep-quant); NEW = the 3 landed host ops + name-map + variable-Q-head device runner. **W4 (2026-07-31, `CLAIM-LAGUNA-W4`, in progress):** the UD-Q4_K_XL GGUF (73.4 GiB, 3 shards) FETCHED to dgx + its metadata/tensor-map READ AUTHORITATIVELY (814 tensors, arch `laguna`, `expert_gating_func=2` sigmoid, `leading_dense_block_count=1`, `expert_weights_scale=2.5`). Three CPU-verified FIDELITY corrections the W1-W3 scaffold got wrong, each grounded in the real GGUF + llama.cpp: (1) **per-head QK-RMSNorm** (`attn_q_norm`/`attn_k_norm` F32[128]) added to params+forward — the scope MISSED it (surfaces only in the tensor map); (2) **dual-RoPE mscale** now uses llama.cpp's `yarn_attn_factor·(1+0.1·ln(factor))` off the GGUF-authoritative `factor=32`/`yarn_attn_factor=1.0` (256K-ctx build, NOT HF's factor-128/1.4852 1M-ctx scalar) — resolves the numerics-delicate residual; (3) **separate** `ffn_gate_exps`/`ffn_up_exps` (Q4_K) + `ffn_down_exps` (Q5_K) + Q8_0 shared/attn (the scaffold assumed merged gate_up). GGUF keep-quant tower materialization (`Mw`/`Sew` mirror of ds4) + keep-quant `ForwardGguf` (vt::MatmulBT/GemmRowSlice) + the real-model greedy run vs the llama.cpp-laguna same-quant oracle remain the W5 close (73 GB single-GB10, host-orchestrated) | `MODEL-TEXT-laguna-laguna-for-causal-lm` |
 | 🚫 | `DeepseekV3ForCausalLM` / `DeepseekV32ForCausalLM` | DeepSeek-V3 / V3.2 | HW-blocked (671B, ~642 GiB fp8 vs 119 GiB unified memory); V3.2 additionally DEP-blocked (DSA indexer) | `MODEL-TEXT-deepseek-v2-deepseek-v3-for-causal-lm` |
 | 🚫 | `GlmMoeDsaForCausalLM` | GLM-5 (DSA) | HW-blocked (1404 GiB bf16) and DEP-blocked (GLM-5.x is DeepSeek-V3.2 verbatim) | `MODEL-TEXT-deepseek-v2-glm-moe-dsa-for-causal-lm` |
@@ -403,6 +406,7 @@ Transformers compatibility is capability-driven and excluded from finite counts.
 | `MODEL-MM-kimi-k25-kimi-k25-for-conditional-generation` | `KimiK25ForConditionalGeneration` | `registry.py:448`; `vllm/model_executor/models/kimi_k25.py::KimiK25ForConditionalGeneration` | conditional generation / video+image | MM processor; encoder/merge; vision encoder; video path | ☐ required | `INVENTORIED` | none | unassigned |
 | `MODEL-MM-kimi-audio-kimi-audio-for-conditional-generation` | `MoonshotKimiaForCausalLM` | `registry.py:449`; `vllm/model_executor/models/kimi_audio.py::KimiAudioForConditionalGeneration` | conditional generation / audio+image | MM processor; encoder/merge; audio/ASR frontend; vision encoder | ☐ required | `INVENTORIED` | none | unassigned |
 | `MODEL-MM-kimi-k3-kimi-k3-for-conditional-generation` | `KimiK3ForConditionalGeneration` | **BEYOND-PIN — NOT in `555967922`** (K3 released 2026-07-27, after the pin); closest registered = its literal text backbone `KimiLinearForCausalLM` (`registry.py:140`; `vllm/model_executor/models/kimi_linear.py`) + the K2.5 vision wrapper `kimi_k25.py:290` / tower `kimi_k25_vit.py` | conditional generation / image (text-first) | model loader/forward; FusedMoE/grouped GEMM; GDN/linear-attention state (KDA); MLA/latent KV; MXFP4 compressed-tensors quant; MM processor + MoonViT-V2 encoder/merge | [kimi-k3 spike](specs/kimi-k3.md) | `SPIKE` | **W0 SCOPE (2026-07-28, `CLAIM-KIMI-K3-SCOPE`, DERIVE-AND-SHIP, records-only).** From the HF `config.json` (fetch-derived): `architectures:["KimiK3ForConditionalGeneration"]`, `text_config.architectures:["KimiLinearForCausalLM"]` — the text backbone IS the pinned Kimi-Linear hybrid, MASSIVELY scaled: **H=7168, L=93 (69 KDA + 24 MLA full-attn), 896 experts / top-16 / 2 shared, `moe_intermediate_size=3072`**; MLA geometry `kv_lora=512`/`q_lora=1536`/`qk_nope=128`/`qk_rope=64` (= our landed DeepSeek-V3 dims); KDA `head_dim=128`/`num_heads=96`/`short_conv=4`/`gate_lower_bound=-5.0`; quant **`mxfp4-pack-quantized` (compressed-tensors, group 32, e8m0) + MXFP8 acts (QAT)**; vision **MoonViT-V2** (~401M, patch 14, 27L). **HEAVY REUSE** — GDN (KDA's parent, `cuda_gdn.cu`/`gdn_attn.cpp`), DeepSeek MLA (`deepseek_v2.cpp`/`mla_attention.*`, exact geometry), DeepSeek-style MoE (`qwen3_moe.cpp`/`cuda_moe.cu`, scale to 896), and the Qwen3.6-35B GDN-hybrid-MoE model skeleton (`qwen3_5_moe.cpp`) are the structural twins; Kimi-K2 tokenizer/tool parser (`parser/kimi_k2.cpp`) reused. **NET-NEW:** the KDA kernel delta (per-channel `[H,D]` low-rank decay `f_a_proj`/`f_b_proj` + sigmoid-gated output norm + 3 q/k/v convs — already scoped on the Kimi-Linear row), **MXFP4** (we have NVFP4 group-16, not MXFP4 group-32/e8m0), **AttnRes** (report-only, UNCONFIRMED — not in config.json nor pinned `kimi_linear.py`), and the **MoonViT-V2 tower**. **HW-fit: DOES NOT FIT GB10** — 2.8T MXFP4 ≈ **1.56 TB ≈ ~12× over the 119 GiB pool**; no small K3 exists. **DERIVE-AND-SHIP** (no on-box golden, like the beyond-vLLM CUDA bricks): (a) REAL proxy gate of KDA+MLA+MoE on the FITTING `Kimi-Linear-48B-A3B` (~89–91 GiB) vs the pinned oracle, (b) build-verify + structural review for the K3 scale-up. The pinned oracle has NO `kimi_k3` ⇒ even HW-rich users need a pin advance to oracle-gate K3 itself. CORRECTS the 2026-07-25 sweep note ("loads as `DeepseekV3ForCausalLM`" — true for K2, NOT K3). W-plan W1-W8 in the spec. **W2/W5 CPU SCAFFOLDING LANDED (2026-07-28, `CLAIM-KIMI-K3-W2-W5`, DERIVED+BUILD-VERIFIED, NOT pushed):** additive registry TU registers `KimiK3ForConditionalGeneration` (info: text-gen + `is_hybrid` + `has_inner_state` + `supports_multimodal`); config-descent `ParseKimiK3Params` reads the nested `text_config` (KimiLinear KDA+MLA+MoE scalars — note upstream key `num_experts_per_token`), `vision_config` (MoonViT-V2 PARTIAL), `quantization_config` (MXFP4 detect) grounded in `configs/kimi_linear.py:11-148`; pure `EnumerateKimiK3TextBackboneTensors` is the 93-layer KDA/MLA + 896-expert MoE structural name-map grounded 1:1 in `kimi_linear.py:104-378,460-554` + `kimi_gdn_linear_attn.py:102-226` (per-layer KDA vs MLA-with-qLoRA vs MoE-vs-dense branching); forward REFUSE-by-name (`VT_CHECK(false)`, mirrors `deepseek_v4.cpp`); loader REFUSES MXFP4 (a real K3 checkpoint's dtype) deferring to the shared DeepSeek-V4 MXFP4 row. **NOT-YET-BUILDABLE (correctly deferred):** MXFP4 materialization (→ `CLAIM-DEEPSEEK-V4-*` / quantization-matrix MXFP4), the KDA kernel delta (→ Kimi-Linear row `MODEL-TEXT-kimi-linear-*`), MoonViT-V2 vision (W7), K3 multimodal-wrapper weight prefix (post-pin). Code: `src/vllm/model_executor/models/kimi_k3{,_registry,_weights}.cpp` + `include/vllm/model_executor/models/kimi_k3.h`. Test: `tests/vllm/models/test_kimi_k3_scaffold.cpp` (6/6, 63 assertions — registry-resolve + config-descent + split logic + enumeration + reject + MXFP4-refuse). Clean CPU build (`-DVLLM_CPP_CUDA=OFF`). Row stays `SPIKE` (no on-box e2e; forward not implemented) | `CLAIM-KIMI-K3-SCOPE`, `CLAIM-KIMI-K3-W2-W5` |
+| `MODEL-DIFFUSION-minimax-h3-mini-max-h3-dit` | `MiniMaxH3DiTModel` | **BEYOND-PIN AND OUT-OF-REPO** — not in `555967922` (H3 released after the pin) and not in the vLLM repository at all: it lives in `vllm-project/vllm-omni`, `vllm_omni/diffusion/models/minimax_h3/` (`minimax_h3_transformer.py`, `packed_sequence.py`, `packed_tokens.py`, `scheduling_minimax_h3_euler_ancestral.py`, `denoise_loop.py`, `vae.py`, `encoder.py`, `pipeline_minimax_h3.py`) | diffusion generation / video + audio (text/image/video/audio in) | flow-matching denoise loop; packed varlen NON-CAUSAL attention; AdaLN modulation; 3D MM-RoPE; video VAE + audio VAE (checkpoint REMOTE CODE); Qwen3-VL-derived encoder; MP4 muxing; Ulysses sequence parallelism | [minimax-h3 spike](specs/minimax-h3.md) | `PARTIAL` | **W0-W2 LANDED (2026-08-03, `CLAIM-MINIMAX-H3-W0-W2`, DERIVE-AND-SHIP).** H3 is NOT an autoregressive LLM: it is a CFG-distilled joint video+audio DIFFUSION transformer (50 blocks, H=5376, 56 MHA heads x 128, SwiGLU 14336, AdaLN 6x3xH, 3D RoPE rotating 96 of 128 dims, video row width 96, audio latent 32) forwarded ONCE PER STEP of a 50-step flow-matching loop — no KV cache, no sampler, no logits, so the SACRED token-exact methodology does not apply. **HW VERDICT: e2e is IMPOSSIBLE on this project's hardware** — ~354 GB checkpoint (DiT 66.3 GB + Qwen3-VL-derived encoder 51.5 GB + video VAE ~10 GB + audio VAE ~0.6 GB), upstream validates on **4x NVIDIA B300 at ~133 GB peak per rank**, vs ONE GB10 with 119 GiB UNIFIED memory; CPU offload does not help because the pool IS host RAM. **WHAT IS GATED (and it is exact):** upstream's modules are pure Python, so they are executed at REDUCED DIMENSIONS on CPU as the oracle (`scripts/gen-minimax-h3-goldens.py` imports them by file path and freezes their outputs; both sides rebuild weights/inputs from an identical FNV-1a + splitmix64 stream, so no weight byte is checked in). Results: fl2va + ref2va packed layouts EXACT including the **fp64 position grid BIT-EXACT** (it feeds RoPE — the port reproduces numpy's `linspace(endpoint=False)` evaluation order and upstream's deliberately-split pairwise vs sequential span summations, `packed_sequence.py:101-113`); patchify/unpatchify/audio pack EXACT + round-trip; scheduler EXACT; **full DiT forward max abs diff 1.6e-7 (video) / 1.5e-7 (audio)** — f32 round-off. **REUSE:** the packed varlen non-causal attention routes through the SHARED `vt::DFlashBlockAttention(causal=false)` (its per-document bidirectional contract IS upstream's varlen FA call) and every projection through `vt::MatmulBT` — NO new kernel was added. **NOT-YET-BUILT (honest):** device-resident/bf16 forward + fusion folds (W2b), H3-Encoder on our existing Qwen3-VL tower (W3), the two VAEs — which are **checkpoint REMOTE CODE** under `trust_remote_code` and must be reimplemented in C++, not adapted (W4/W5) — pipeline/tasks (W6), `/v1/videos` + MP4 muxing, which needs a NEW dependency decision (W7), and USP multi-GPU (W8). No speed number is claimed; upstream reports the DiT at 88% of request latency. Code: [minimax_h3.h](../include/vllm/model_executor/models/minimax_h3.h#L1-L333), [minimax_h3.cpp](../src/vllm/model_executor/models/minimax_h3.cpp#L410-L640) (`MiniMaxH3DitForward`), [minimax_h3_packing.cpp](../src/vllm/model_executor/models/minimax_h3_packing.cpp#L259-L400) (`BuildMiniMaxH3PackedSequence`). Test: [test_minimax_h3.cpp](../tests/vllm/models/test_minimax_h3.cpp#L376-L470) (DiT forward parity; 10/10 cases / 2539 assertions, clean CPU build) + generator [gen-minimax-h3-goldens.py](../scripts/gen-minimax-h3-goldens.py#L1-L60); [ledger](parity-ledger.md#L889). **W6A+W9 LANDED (2026-08-03, `CLAIM-MINIMAX-H3-W6A-W9`) + HW VERDICT CORRECTED.** (a) the **bf16 PRODUCTION dtype policy** now runs (upstream's cast points with the fp32 islands preserved; gated vs a bf16 upstream golden at max abs diff 2.4e-3); (b) **request planning** — 17n+5 frame snapping, video/audio latent shapes, the rectified-flow time-shift sigma schedule, canvas resolution and t2va/fl2va/ref2va dispatch — ported and EXACT vs `time_request.py` + `pipeline_minimax_h3.py:121-122,207-222,374-434`; (c) the **ComfyUI-GGUF arm**: the name map is the IDENTITY and every one of the **535 real tensors** of `MiniMax-H3-FL2VA-Q3_K_M.gguf` resolves onto our contract, with the geometry derived from SHAPES ALONE equal to the shipped config (gated on a manifest read from the file's own header by range request — no payload downloaded). Two shape rules recorded: GGUF `ne` is reversed vs torch, and `comfy.gguf.orig_shape.<name>` overrides it where ComfyUI reshaped a tensor for quant-block alignment (the 50 AdaLN projections: logical [96768, 2688], 2688 not a multiple of the 256-element Q3_K block). **★ HARDWARE VERDICT CORRECTED — the earlier 'e2e is IMPOSSIBLE on this hardware' was WRONG** because it reasoned from the bf16 release alone: quantized H3 checkpoints exist and FIT (GGUF DiT Q3_K_M 15.6 GB + Qwen3-VL encoder Q4_K_M 14.6 GB + VAEs ~11 GB ~= **41 GB** in a 119 GiB pool; `lilcheaty/MiniMax-H3-NVFP4` likewise). So e2e AND a speed comparison are REACHABLE; NVFP4 is the likely speed path (sm_121 native FP4 tensor cores + our tuned NVFP4 stack). **W5 LANDED (audio VAE)**: H3's VAEs are checkpoint REMOTE CODE under `trust_remote_code`, so a no-Python engine must REIMPLEMENT them — the DAC-lineage BigVGAN audio decoder (weight-norm materialization (w = g*v divided by the row norm), anti-aliased SnakeBeta with kaiser-sinc up/down resampling, replicate padding, final clamp) is ported and gated against the checkpoint's OWN modules at **max abs diff 4.2e-9**. The VIDEO VAE (`klvae.py` ~48 KB + CNN/ViT + tiling) is the largest remaining brick. **W10 GROUNDED + W4 SCOPED from REAL manifests** (safetensors headers captured by range request, no payload downloaded): the NVFP4 checkpoint's 1051 tensors are textbook compressed-tensors NVFP4 (U8 packed 2-per-byte + E4M3 `weight_scale` at group 16 + F32 scalar `weight_scale_2`; 258 quantized projections; fp32/bf16 islands left unquantized; names identical to our contract) — i.e. EXACTLY the layout our tuned NVFP4 stack already consumes, so W10 is loader wiring, not a new quant scheme. The video VAE's 560 tensors show its ENCODER is the 3D CNN (rank-5 Conv3d) while its DECODER — the half generation needs — is a 36-block TRANSFORMER (to_qkv/to_out, ff.w1/w2, 2 norms + 2 learned residual scales per block, x_embedder/mask_token/register_tokens/proj_out), materially smaller than klvae.py's 48 KB suggested. **W4 BLOCK LANDED**: the video-VAE decoder's repeated `TransformerBlock` is ported and gated at **6.0e-8** against the checkpoint's OWN remote code — RMSNorm + per-head RMS qk-norm (no affine) + full attention + gated-SiLU FF + LEARNED PER-CHANNEL residual scales, and critically the PER-HEAD-INTERLEAVED qkv layout ([head][q,k,v], NOT the DiT's [q_all,k_all,v_all]) that would otherwise produce a plausible-but-wrong image. **W4 DECODER DONE**: the FULL ViT3D video-VAE decoder — pack, x_embedder, register/cls tokens, 3D RoPE (RotaryEmbeddingND, length-normalized ids, angle scale 2pi, tiled freq blocks), the 36-block stack, LayerNorm norm_out, proj_out and unpatchify — is ported and gated at **8.9e-8** against the checkpoint's own `ViT3DDecoder`, at its real hyperparameters (36 layers, 32 heads x 64, rope_theta 100, rope_dim_ratio 0.75). BOTH VAE decoders are now done (audio 4.2e-9). **W3 TEXT TOWER DONE**: the H3-Encoder's truncated Qwen3-VL text tower — gated at **1.2e-7** vs upstream — with all three H3 deltas exercised: layer truncation (min(num_hidden_layers, 50)), the UNNORMALIZED layer-49 output (NO final RMSNorm, unlike stock Qwen3-VL — applying one silently shifts every conditioning vector), and DeepStack visual injection into the first N layers; plus interleaved M-RoPE, fused QKV, per-head q/k RMSNorm, causal GQA and the gated-SiLU MLP. **W6 t2va ASSEMBLED — the WHOLE PATH COMPOSES**: `MiniMaxH3GenerateT2va` wires packed layout -> rectified-flow sigma schedules -> the multi-step denoise loop of DiT forwards -> unpatchify + audio unpack -> per-channel denormalize -> BOTH VAE decoders, producing correctly-shaped, finite frames and a stereo waveform in [-1, 1]; gated by a structural end-to-end test at reduced dimensions with random weights (NOT a quality result). Assembling it also caught a real gap: the audio decode needed the checkpoint's `dec_in_proj` (Conv1d k=1, vae_latent_channels -> num_mels) ahead of BigVGAN. **W9 GGUF ARM DONE**: `LoadMiniMaxH3DitFromGguf` materializes the DiT from a ComfyUI-format GGUF — dequantizing every tensor through the SHARED GGUF dequant entry point (so the Q2_K/Q3_K/Q4_K families the H3 GGUFs use are covered by the same code every other GGUF model uses), recovering the geometry from shapes alone, and binding the forward's views with missing tensors throwing BY NAME rather than reading as zeros; gated by a synthetic-file load-AND-RUN test (a real DiT forward executes off the loaded weights). **W10 LOADER DONE**: `LoadMiniMaxH3DitFromNvfp4` materializes the DiT from an NVFP4 compressed-tensors checkpoint — the U8-packed [out, in/2] weight plus its E4M3 group-16 `weight_scale` and F32 scalar `weight_scale_2` go through the project's EXISTING NVFP4 dequant (no new quant code), sidecars are excluded from the model tensor set, and the logical [out, in] shape is recovered; gated by a synthetic-file load-AND-RUN test. BOTH quantized loaders are now done. **W3 VISION BLOCK DONE** (6.0e-8): the repeated unit of the encoder's Qwen3-VL vision tower, which differs from the text tower in every way that matters numerically — LayerNorm WITH BIAS (not RMSNorm), a [q_all, k_all, v_all] qkv layout (not the video VAE ViT's per-head interleave), fp32 rotary, NON-CAUSAL attention segmented by `cu_seqlens` (the test asserts a perturbation in one packed image leaves the other's outputs BIT-IDENTICAL), and the TANH-approximate GELU. **W3 ENCODER COMPLETE**: the FULL vision tower also lands — Conv3d patch embed (kernel == stride, so a linear over the flattened patch), BILINEAR resampling of the learned position grid into spatial-merge order, the 2D rotary table, per-frame `cu_seqlens`, and both merger flavours (the final merger norms the PRE-shuffle width while the DeepStack mergers norm the POST-shuffle width, and both use exact-erf GELU unlike the block MLP's tanh approximation), gated over a RAGGED two-image batch. Only the MM processor remains on the encoder. **CONDITION-NOISE augmentation DONE** (fl2va/ref2va): the noised-anchor mix plus its ROW ACCOUNTING — each visual condition draws noise of length `target_latent_t + imgvid_cond_num_frames` and slices the PREFIX matching its own latent_t, every condition restarts the SAME seed (so concatenating and drawing once would differ for multi-reference requests), and rows advance by that condition's own patchified count. Gated EXACT with the noise supplied, so the comparison isolates the accounting from torch's RNG. **REFERENCE-VIDEO geometry + FRAME SCHEDULE DONE** (the pure-math half of `reference_video.py`): the canvas pipeline (aspect clamp -> 768 short edge -> max-pixel rescale -> nearest multiple of 32) and the 24-to-2 FPS frame resample with per-temporal-patch block timestamps, both EXACT. NOTE the rest of that module (probe, transcode, frame extraction, audio decode) shells out to ffmpeg and is blocked on the SAME external dependency decision as `/v1/videos` MP4 muxing — one decision unlocks reference-video INPUT decode and generated-video OUTPUT encode together. **VIDEO VAE TILING DONE**: the tile plan (smallest tile count whose MINIMUM overlaps still cover the axis, leftover slack distributed in whole `vae_ratio` units ROUND-ROBIN across the seams) plus the linear seam cross-fade, both EXACT. Shipped config tile 256 / overlap 64 / vae_ratio 16 (= prod(space_down), the 'f16' in f16t4). Getting the slack distribution wrong shifts every tile after the first and surfaces as seam artifacts rather than an error. **PRESENTATION TOKEN TAGS DONE** — the fl2va vision-span override the denoise loop requires callers to have applied: a vision block is `vision_start + pad*count + vision_end` and the WHOLE block, MARKERS INCLUDED, is tagged VIDEO; tagging only the pads would leave two markers as TEXT and shift every AdaLN modulation index after them. Gated EXACT, with the test proving each VIDEO run is a whole vision block. **VAE 3D-CNN ENCODER PRIMITIVES DONE**: causal Conv3d (all temporal padding on the LEFT so a frame never sees the future, `reflect` spatial padding), GroupNorm3D (32 groups, eps 1e-6, statistics spanning TIME as well as space) and ResnetBlock3D, gated EXACT — with CAUSALITY proven directly on the bare convolution (a change to the last frame provably cannot reach earlier frames). **Downsample3D DONE** too: the strided inter-level conv, whose subtlety is the ASYMMETRIC pre-pad — one pixel on the RIGHT of W and the BOTTOM of H before a stride-2 conv with padding (1,0,0); padding symmetrically instead shifts the whole sampling lattice by half a pixel, which is a silent wrong latent rather than an error. Only the EncoderFCN3D level-loop assembly remains on the VAE encoder. **VIDEO VAE COMPLETE — encoder AND decoder**: the whole 3D-CNN encoder level loop (conv_in -> per level [ResnetBlock3D x N then Downsample3D or a 1x1x1 channel match] -> GroupNorm -> SiLU -> conv_out) is gated EXACT. **MM PROCESSOR = REUSE, gated**: H3's `FL2VA/processor` is a stock `Qwen3VLProcessor`, so the multimodal front end is this project's EXISTING Qwen3-VL processor rather than a new port; H3's own config is parsed and driven through it (patch 16 / temporal 2 / merge 2, **0.5 normalization rather than CLIP statistics**, a 32-pixel grid, the 768x1344 default canvas proven an IDENTITY under smart_resize, and VIDEO bounds deliberately looser than the image ones). **With this every PORTABLE piece of the lane is done**; what remains is one dependency decision (ffmpeg media I/O + MP4 muxing) and GPU-blocked work (the device-resident FP4 forward and any speed number). **WAV OUTPUT** added: the decoded stereo waveform serializes to RIFF/WAVE 16-bit PCM, converting the VAE's CHANNEL-MAJOR layout to INTERLEAVED (getting that backwards yields audio that plays but with the channels time-smeared) and clamping rather than wrapping. Deliberately dependency-free, and required under EITHER outcome of the open MP4/muxer decision. **VIDEO OUTPUT PATH DONE**: PPM frame serialization (planar [C,T,H,W] -> row-major interleaved RGB, [-1,1] -> [0,255] clamped) plus the MP4 mux argv (h264/yuv420p + AAC, `-shortest`, `+faststart`). The built argv was RUN through real ffmpeg 6.1.1 and produced a VALID MP4 (ffprobe: h264 yuv420p video + AAC stereo at 32 kHz). The library never spawns a process — `src/vllm/` has no subprocess precedent — so it builds the artifacts and the command while the example/server layer invokes it. **`/v1/videos` API LOGIC DONE**: the request contract (H3 defaults — 50 steps, flow shift 12 video / 3 audio; both the vLLM-Omni `extra_params` nesting and a flat top-level spelling accepted; malformed input rejected with a reason rather than silently defaulted) and the job store (queued -> running -> succeeded/failed, illegal transitions throw, unknown ids reported so the route can 404, status JSON omits fields that do not apply, and concurrent creation is thread-safe). Remaining is mechanical glue: route registration + runner injection, with the ffmpeg call in `examples/` per the ratified boundary. Test: 34/34 + video-api 4/4 (9233 + 63 assertions). OPEN: there is no vllm-omni parity PIN — the upstream-sync protocol covers only the vLLM repo | `CLAIM-MINIMAX-H3-W0-W2`, `CLAIM-MINIMAX-H3-W6A-W9` |
 | `MODEL-MM-moss-transcribe-diarize-moss-transcribe-diarize-for-conditional-generation` | `MossTranscribeDiarizeForConditionalGeneration` (v0.25.0 target-pending) | v0.25.0 target `registry.py:450-453`; `vllm/model_executor/models/moss_transcribe_diarize.py::MossTranscribeDiarizeForConditionalGeneration` @ `702f481` | conditional generation / audio | MM processor; Whisper encoder; VQ adaptor; Qwen3 decoder; speech-to-text/diarization frontend | ☐ required | `INVENTORIED` | none | unassigned |
 | `MODEL-MM-lightonocr-light-on-ocrfor-conditional-generation` | `LightOnOCRForConditionalGeneration` | `registry.py:450-453`; `vllm/model_executor/models/lightonocr.py::LightOnOCRForConditionalGeneration` | conditional generation / image | MM processor; encoder/merge; vision encoder | ☐ required | `INVENTORIED` | none | unassigned |
 | `MODEL-MM-lfm2-vl-lfm2-vlfor-conditional-generation` | `Lfm2VlForConditionalGeneration` | `registry.py:454`; `vllm/model_executor/models/lfm2_vl.py::Lfm2VLForConditionalGeneration` | conditional generation / image | MM processor; encoder/merge; Mamba/SSM state; vision encoder; video path | ☐ required | `INVENTORIED` | none | unassigned |
diff --git a/.agents/parity-ledger.md b/.agents/parity-ledger.md
index 1156d1926..7ce65e9bd 100644
--- a/.agents/parity-ledger.md
+++ b/.agents/parity-ledger.md
@@ -886,3 +886,27 @@ Columns:
 | 2026-07-31 (`SERVE-C-ABI` W0 contract spike; `CLAIM-SERVE-C-ABI-SPIKE`; CPU-only records/docs) | Accepted `.agents/specs/c-api-library.md` for the already-shipped original C packaging layer: complete scope, vLLM semantic chain/deviation, ABI v10/19-symbol baseline, ownership/error/version/dispatch rules, exact code/test anchors, gates, dependencies, risks, and W1-W5 follow-ons. Also fixes the verified stale public `VLLM_ABI_VERSION 9` labels in README/USAGE to the source-of-truth v10 and adds the missing v10 usage-table entry. No production/test/CMake source changed. | Pinned vLLM `555967922` has no C ABI; behavior beneath the adapter remains owned by its vLLM-derived engine rows. The flat ABI is the recorded llama.cpp-style packaging deviation and may translate, never reimplement, policy. | **CPU/records gate only; benchmark NOT APPLICABLE.** Focused C11/C++/dlopen/export gate passed 3/3 after explicitly building `vllm_shared`; five record checkers pass. `check-agent-record` reports the base tree's same six missing closing-commit objects (`444ea9d7`, `7a3f04b2`, `164453a2`), none in this row/diff. Row stays `ANCHOR-BACKFILL` because all-symbol dlsym coverage (chat symbols currently omitted), historical-layout compatibility, allocation-failure no-throw proof, lifetime sanitizer stress, and a standalone real-model C consumer remain W1-W5. |
 | 2026-07-31 (`CLAIM-CPU-GCC12-WERROR-PORTABILITY`; maintenance, rows `QUANT-GGUF-KEEPQ-LOADER` + `KV-OFFLOAD`; lifecycle unchanged) | Removes two GCC 12 production-library `-Werror` blockers without suppressions: the GGUF prefault keeps the same one-byte-per-page volatile XOR but uses simple assignment, and the KV filesystem tier builds the identical `.<pid>.<counter>.tmp` suffix with append operations inside its thread-local initializer. No API, algorithm, default, CUDA, fixture, or golden change. | Behavior remains grounded in the accepted loader and KV-persistence leaf specs: llama.cpp mmap prefault intent and vLLM `tiering/fs/io.py` unique temporary-file publication. This is compiler portability, not a parity-surface change. | RED: GCC 12 failed first at `qwen3_5_gguf_weights.cpp:49` (`-Wvolatile`), then at `fs_io.cpp:66` (`-Wrestrict`). GREEN: production `vllm` and focused test targets build clean; focused CTest 2/2 (`test_gguf_keep_quant`, `test_kv_offload_fs`). Full all-target build is PARTIAL at 42% on unrelated test-only GCC 12 `-Wrestrict` diagnostics in `test_deepseek_v2_paged_engine.cpp` and `test_glm4_moe_lite_paged_engine.cpp`; no full-CTest claim. Benchmark NOT APPLICABLE. |
 | 2026-08-01 (`SERVE-CLI-CHAT` W0 contract spike; `CLAIM-SERVE-CLI-CHAT-SPIKE`; CPU-only records/spec) | Accepts `.agents/specs/cli-chat-complete.md`, corrects the inventory from “no direct commands” to the actual pinned `chat`/`complete` surface, and decomposes a dual-mode port: exact remote OpenAI HTTP/SSE commands plus preservation of the existing in-process invocation as a compatibility alias. No production, test, CMake, model, kernel, fixture, or generated file changes. | Pinned vLLM `5559679229`: command registration `vllm/entrypoints/cli/main.py:17-37,73-98`; model/auth resolution and stream shaping `vllm/entrypoints/cli/openai.py:30-100`; chat `:155-234`; complete `:237-312`. The local compatibility baseline is `examples/cli/main.cpp:1-207`. | CPU record/doc gates only; benchmark `NOT APPLICABLE`, `benchmark_binding=false`. Implementation remains absent and the row moves `INVENTORIED` -> `SPIKE`. W1-W5 name parse, transport, complete, chat, and packaging gates, including fake-server request/SSE transcript parity, Release `-Werror`, ASan+UBSan, and TSan. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W0-W2`; branch `feat/minimax-h3`) | **MiniMax-H3 W0-W2 — the project's FIRST diffusion architecture.** Adds the H3 packed-sequence layout (fl2va + ref2va block families, including the FP64 (t,h,w) position grid), the latent<->token packing, the euler-ancestral eta0 flow-matching scheduler, the 50-block AdaLN DiT forward, and the CFG-distilled denoise-loop driver. The packed varlen NON-CAUSAL attention routes through the SHARED `vt::DFlashBlockAttention(causal=false)` and every projection through `vt::MatmulBT` — NO new kernel. H3 is NOT autoregressive (no KV cache/sampler/logits), so it is deliberately NOT registered in the causal-LM registry and is exempt from the born-on-the-runner seam by construction. | `vllm-project/vllm-omni`, `vllm_omni/diffusion/models/minimax_h3/`: `minimax_h3_transformer.py:47-78,139-168,171-244,272-285,288-317,320-467,470-561,564-623,626-688,691-743,765-1102`, `packed_sequence.py:101-113,116-239,258-277,290-557`, `packed_tokens.py:23-106`, `scheduling_minimax_h3_euler_ancestral.py:49-102`, `denoise_loop.py:22-28,91-239`. **BEYOND-PIN AND OUT-OF-REPO** — H3 is not in the parity pin `555967922` and not in the vLLM repository at all; there is no vllm-omni pin yet (open item). | **CPU-GATED, EXACT.** Upstream's modules are pure Python, so they are EXECUTED at reduced dimensions as the oracle (`scripts/gen-minimax-h3-goldens.py`; both sides rebuild weights/inputs from an identical FNV-1a+splitmix64 stream, so no weight byte is checked in). `test_minimax_h3` **10/10 cases, 2539 assertions**: fl2va + ref2va layouts EXACT with the fp64 position grid **BIT-EXACT**; patchify/unpatchify/audio pack EXACT + round-trip; scheduler EXACT; **DiT forward max abs diff 1.6e-7 (video) / 1.5e-7 (audio)**. **NOT GATED (honest):** anything end-to-end — the checkpoint is ~354 GB and upstream validates on 4x B300 at ~133 GB/rank vs one GB10 at 119 GiB UNIFIED, so e2e video/audio is HARDWARE-BLOCKED and no speed number is claimed. Encoder/VAEs/pipeline/serving and the device-resident forward are W2b-W8. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W6A-W9`; branch `feat/minimax-h3`) | **MiniMax-H3 W6A + W9 + a HARDWARE-VERDICT CORRECTION.** (a) the DiT forward now also runs the **bf16 PRODUCTION dtype policy** (upstream's cast points, fp32 islands preserved); (b) **request planning** ported — 17n+5 frame snapping, video/audio latent shapes, the rectified-flow time-shift sigma schedule, canvas resolution, and t2va/fl2va/ref2va dispatch; (c) the **ComfyUI-GGUF arm** — logical-shape resolution (ne reversal + the `comfy.gguf.orig_shape` reshape rule) and geometry derivation from the tensor manifest alone. | `time_request.py:5-61`, `pipeline_minimax_h3.py:121-122,207-222,374-434`, `minimax_h3_transformer.py:85-101` (the fp32 islands) + the ComfyUI GGUF writer's `comfy.gguf.orig_shape` convention. Checkpoints: `realrebelai/MiniMax-H3_GGUFs`, `lilcheaty/MiniMax-H3-NVFP4`. | **CPU-GATED.** `test_minimax_h3` **13/13 cases, 3907 assertions**: request planning EXACT vs upstream; bf16 stream max abs diff 2.4e-3 (bf16 scale, same cast points, different GEMM accumulation order); **the REAL 535-tensor manifest of `MiniMax-H3-FL2VA-Q3_K_M.gguf` resolves onto our weight contract exactly** (identity name map) and the geometry derived from SHAPES ALONE equals the shipped H3 config. **★ CORRECTS the prior row's hardware verdict:** 'e2e IMPOSSIBLE on this hardware' reasoned from the bf16 release only and was WRONG — the quantized arms fit (~41 GB GGUF working set in a 119 GiB pool), so e2e and a speed comparison are reachable. Still no e2e or speed NUMBER is claimed. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W5`; branch `feat/minimax-h3`) | **MiniMax-H3 audio VAE decoder REIMPLEMENTED (W5).** H3's two VAEs are checkpoint REMOTE CODE (`FL2VA/{audio,video}_vae/*.py`, loaded via `get_class_from_dynamic_module` under `trust_remote_code`); vLLM-Omni only ADAPTS them, so a no-Python engine must reimplement them. This ports the audio side: a DAC-lineage BigVGAN vocoder — weight-norm materialization, ConvTranspose1d upsample stages, AMPBlock1 residual stacks averaged across 3 kernels, anti-aliased SnakeBeta (kaiser-sinc 2x up / 2x down with replicate padding), and the final clamp (H3 sets use_tanh_at_final=false). | The checkpoint's own `dac_bigvgan.py`, `dac_activations.py`, `dac_alias_free_{act,filter,resample}.py`, `dac_audio_vae.py` + `config.yaml`/`metadata.json` (decoder_dim 1024, latent 2048, upsample_rates [5,5,2,2,2,2,2], kernels [9,9,4,4,4,4,4], resblock kernels [3,7,11] dilations [1,3,5], snake_logscale). The remote code is NOT vendored (MiniMax H3 Community License). | **CPU-GATED, effectively exact.** `scripts/gen-minimax-h3-audio-vae-goldens.py` imports the checkpoint's OWN modules and runs them at reduced dimensions as the oracle; weights come from the shared H3Rand stream so no weight byte is checked in. **Waveform max abs diff 4.2e-9**, kaiser-sinc filter 3.0e-8; the golden is deliberately UNSATURATED (a clamped golden would hide errors, asserted in the test). `test_minimax_h3` 14/14 cases / 3983 assertions. NOT gated: the encode side's determinism-context semantics, and the VIDEO VAE (the largest remaining brick). Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W10-SCOPE`; branch `feat/minimax-h3`) | **MiniMax-H3 NVFP4 arm GROUNDED + video VAE SCOPED, both from REAL checkpoint manifests.** Adds `scripts/gen-minimax-h3-safetensors-manifest.py` (a safetensors header is front-loaded and a few tens of KB, so an HTTP range request captures the whole manifest — the same trick the GGUF arm uses) and gates two real checkpoints: `lilcheaty/MiniMax-H3-NVFP4` (1051 tensors) and the video VAE (`FL2VA/video_vae/source/model.safetensors`, 560 tensors). | compressed-tensors NVFP4 (the scheme our `quantization-matrix` NVFP4 rows already implement) and the checkpoint's own video-VAE remote code. | **GATED against the real files, no payload downloaded.** NVFP4: the checkpoint is the textbook compressed-tensors triple — `weight` U8 (FP4 packed 2-per-byte, [21504, 2688] for a [21504, 5376] logical qkv), `weight_scale` F8_E4M3 at **group 16** ([21504, 336]), `weight_scale_2` F32 scalar; 258 quantized projections each carrying all three; the fp32/bf16 ISLANDS (patch projections, time embedder, output heads, norms, rope) left unquantized; and the names are IDENTICAL to our contract. So W10 is loader WIRING onto the existing tuned NVFP4 stack, not a new quant scheme — this is the speed path. Video VAE: ENCODER is the 3D CNN (116 tensors, rank-5 Conv3d) but the DECODER — the half generation needs — is a **36-block TRANSFORMER** (440 tensors: to_qkv/to_out, ff.w1/w2, 2 norms + 2 learned residual scales per block, plus x_embedder/mask_token/register_tokens/norm_out/proj_out), fp32 throughout. That makes W4 materially smaller than `klvae.py`'s 48 KB implied. `test_minimax_h3` 16/16 cases / 5908 assertions. Still NO e2e or speed number. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W4-BLOCK`; branch `feat/minimax-h3`) | **MiniMax-H3 video-VAE decoder TransformerBlock ported (W4, partial).** The repeated unit of the 36-block ViT decoder: RMSNorm -> attention -> LEARNED PER-CHANNEL residual scale, then RMSNorm -> gated-SiLU feed-forward -> per-channel scale; per-head RMS q/k norm with NO affine weight; fp32. | the checkpoint's own `FL2VA/video_vae/base_module.py:200-281` (TransformerBlock, FeedForward) and `attention.py` (Attention.forward). Remote code NOT vendored (MiniMax H3 Community License); the generator stubs the handful of diffusers symbols the bundle imports rather than taking the dependency. | **CPU-GATED, effectively exact: max abs diff 6.0e-8** vs the checkpoint's own module at reduced dimensions. Catches the layout TRAP: this ViT's `to_qkv` is PER-HEAD INTERLEAVED (`view(B,S,-1,3*dim_head)` then chunk => [head][q,k,v]), NOT the [q_all,k_all,v_all] the H3 DiT uses — reading it the DiT way yields a plausible-but-wrong image. `test_minimax_h3` 17/17 / 5911 assertions. NOT gated: the stack surround (x_embedder, mask/register tokens, 3D RoPE, norm_out/proj_out, unpatchify, tiling) and the 3D-CNN encoder. Still NO e2e or speed number. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W4-DECODER`; branch `feat/minimax-h3`) | **MiniMax-H3 video-VAE ViT3D DECODER complete (W4).** Adds the stack surround around the already-gated block: `_pack_tensors_3d`, `x_embedder`, the register-token + ZERO cls-token suffix, 3D RoPE (RotaryEmbeddingND over length-normalized token ids, angle scale 2*pi, per-axis frequency blocks concatenated then TILED twice), the 36-block stack, LayerNorm `norm_out`, `proj_out`, and `_unpack_tensors_3d`. | the checkpoint's own `FL2VA/video_vae/vae_vit.py:216-365` (ViT3DDecoder), `base_module.py:157-196` (RotaryEmbeddingND), `func.py:12-47,82-102` (create_token_ids, apply_rotary_pos_emb), at the REAL hyperparameters from `source/config.json::vit_decoder_kwargs` (36 layers, 32 heads x 64, rms_norm affine, qk rms_norm no affine, gated SiLU, rope_theta 100.0, rope_dim_ratio 0.75). | **CPU-GATED, effectively exact: max abs diff 8.9e-8** for the full decoder (block alone 6.0e-8) vs the checkpoint's own module at reduced dimensions. `test_minimax_h3` 18/18 / 5918 assertions. BOTH VAE DECODERS are now done (audio 4.2e-9). NOT gated: video tiling (`vae_tile_size` 256 / overlap 64) and the 3D-CNN ENCODER, which is only needed for image/video CONDITIONING, not for output frames. Still NO e2e or speed number. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W3-TEXT`; branch `feat/minimax-h3`) | **MiniMax-H3 encoder TEXT tower (W3, partial).** The truncated Qwen3-VL text model that produces the `[seq, 5120]` `prompt_embeds` the DiT consumes: pre-norm decoder layers with fused QKV, per-head q/k RMSNorm, interleaved M-RoPE, causal GQA and a gated-SiLU MLP — plus the three H3-specific deltas. | `vllm_omni/diffusion/models/minimax_h3/encoder.py:1-30` (the delta contract), `:292-330` (interleaved M-RoPE), `:751-800` (MiniMaxH3Qwen3VLTextModel, DeepStack), and the attention/MLP forwards. Imported by file path with a one-symbol `vllm.logger` stub, so the oracle needs neither vllm nor its dependencies. | **CPU-GATED: max abs diff 1.2e-7** on BOTH the plain and DeepStack paths vs upstream at reduced dimensions, with the config deliberately declaring MORE layers than are selected so TRUNCATION is exercised, and an explicit assertion that DeepStack actually changes the result. The load-bearing delta is the **UNNORMALIZED** output: H3 consumes the state straight out of layer 49 with NO final RMSNorm, unlike a stock Qwen3-VL text model — applying one silently shifts every conditioning vector. `test_minimax_h3` 19/19 / 5930 assertions. NOT gated: the encoder's VISION tower (reuse of `qwen3_vl_vision.cpp`) and the MM processor. Still NO e2e or speed number. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W6-T2VA`; branch `feat/minimax-h3`) | **MiniMax-H3 t2va pipeline ASSEMBLED (W6) — the whole path composes.** `MiniMaxH3GenerateT2va` wires the separately-gated stages together: packed layout -> rectified-flow sigma schedules (video/audio shift 12/3) -> the denoise loop of DiT forwards -> unpatchify + audio unpack -> per-channel denormalize -> the video ViT3D decoder and the audio BigVGAN decoder -> frames + stereo waveform. | `pipeline_minimax_h3.py` (diffuse/decode flow, `_initial_noise`), `vae.py:252-270,341-357` (denormalization), `dac_audio_vae.py:218-231` (`dec_in_proj`). | **STRUCTURAL END-TO-END GATE** at reduced dimensions with random weights — explicitly NOT a quality result, but a real exercise of the composed path: frames come out [3, T*pt, H*ps, W*ps], the waveform is stereo at 32 kHz, everything is FINITE and inside [-1, 1], and the denoise loop demonstrably moves the latents. Assembling it CAUGHT A REAL GAP: the audio decode was missing the checkpoint's `dec_in_proj` (Conv1d k=1 from vae_latent_channels to num_mels) ahead of BigVGAN — now applied when the weight is present, with the standalone BigVGAN gate unchanged. `test_minimax_h3` 20/20 / 6370 assertions. NOT gated: fl2va/ref2va conditioning, bit-exact torch-RNG noise seeding (noise is an INPUT by design), and any run on a REAL checkpoint. Still NO speed number. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W9-LOAD`; branch `feat/minimax-h3`) | **MiniMax-H3 GGUF arm COMPLETE (W9).** `LoadMiniMaxH3DitFromGguf` turns a ComfyUI-format GGUF into a runnable DiT: resolve the manifest (identity name map, `ne` reversal, the `comfy.gguf.orig_shape` reshape rule), derive the geometry from SHAPES alone, dequantize every tensor to f32 through the shared `DequantGgufRowToF32`, and bind the forward's non-owning views. | the ComfyUI GGUF writer's layout + this project's existing GGUF reader/dequant stack (so the K-quant families need no new code). | **CPU-GATED by a synthetic-file LOAD-AND-RUN test**: the geometry is recovered exactly from tensor shapes, a loaded weight carries the LOGICAL (torch) shape rather than the reversed `ne`, and a REAL DiT forward executes off the loaded weights producing finite, correctly-sized outputs. Missing tensors throw BY NAME rather than yielding a null view the forward would read as zeros. `test_minimax_h3` 21/21 / 6668 assertions. NOT gated: a load of the ACTUAL 15.6 GB file (needs the download) and NVFP4 loader wiring. Still NO speed number. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W10-LOAD`; branch `feat/minimax-h3`) | **MiniMax-H3 NVFP4 loader (W10, loader half).** `LoadMiniMaxH3DitFromNvfp4` turns an NVFP4 compressed-tensors checkpoint into a runnable DiT: the U8-packed [out, in/2] weight plus its E4M3 group-16 `weight_scale` and F32 scalar `weight_scale_2` are dequantized through the project's EXISTING `DequantNvfp4ToBf16`, the fp32/bf16 islands are read as-is, quant sidecars are excluded from the model tensor set, and the geometry is recovered from the DEQUANTIZED shapes. The view binding is now SHARED with the GGUF arm (`BindMiniMaxH3DitViews`) since both land on the same weight contract. | compressed-tensors NVFP4 (already implemented in this tree for the Laguna arm) + the real `lilcheaty/MiniMax-H3-NVFP4` manifest gated earlier. | **CPU-GATED by a synthetic-file LOAD-AND-RUN test**: a packed [out, in/2] weight comes back as the logical [out, in], `weight_scale`/`weight_scale_2` never appear as model tensors, and a REAL DiT forward executes off the loaded weights with finite outputs. NOTE the refactor that introduced the shared binder initially corrupted six tensor NAME STRINGS (a blind `out.`->`out->` rewrite turned "time_embedder.proj_out.bias" into "...proj_out->bias"); the loader's throw-BY-NAME design caught it immediately instead of silently binding zeros — which is exactly why it is written that way. `test_minimax_h3` 22/22 / 6971 assertions. NOT done: the DEVICE path that keeps FP4 packed and routes projections through the cutlass FP4 GEMM (that is where the speed is), and a run on the real file. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W3-VISION`; branch `feat/minimax-h3`) | **MiniMax-H3 encoder VISION block (W3, second half).** The repeated unit of the H3-Encoder's Qwen3-VL vision tower: LayerNorm -> fused-qkv non-causal attention with fp32 rotary -> proj -> residual; LayerNorm -> tanh-GELU MLP -> residual. | `vllm_omni/diffusion/models/minimax_h3/encoder.py:337-481` (patch embed, rotary, merger, MLP, attention, block). | **CPU-GATED: max abs diff 6.0e-8** vs upstream at reduced dimensions. The block differs from the TEXT tower in four numerically load-bearing ways, all exercised: LayerNorm WITH BIAS rather than RMSNorm; a [q_all, k_all, v_all] qkv layout (NOT the per-head interleave the video-VAE ViT uses — the two ViTs in this model disagree on this); fp32 rotary; and the TANH-approximate GELU rather than exact erf. Attention is segmented by `cu_seqlens`, and the test PROVES the isolation: perturbing a token in the second packed image leaves every output of the first BIT-IDENTICAL, while the second's do change. `test_minimax_h3` 23/23 / 7040 assertions. NOT gated: the vision surround (Conv3d patch embed, learned pos-embed interpolation, the 2D rotary table, patch + DeepStack mergers) and the MM processor. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-W3-TOWER`; branch `feat/minimax-h3`) | **MiniMax-H3 encoder COMPLETE (W3).** The full vision tower: Conv3d patch embed, bilinear interpolation of the learned position grid into spatial-merge order, the 2D rotary table, the block stack over per-frame `cu_seqlens`, the DeepStack mergers and the final patch merger. | `encoder.py:337-600` (patch embed, rotary, mergers, `fast_pos_embed_interpolate`, `rot_pos_emb`, `MiniMaxH3Qwen3VLVisionModel.forward`). | **CPU-GATED: merged output and DeepStack features both within 1e-4** of upstream over a RAGGED two-image batch (different h/w), so the position-embedding interpolation and the per-frame cu_seqlens both had to handle unequal grids. Details that are load-bearing and now pinned: the patch embed's Conv3d has kernel == stride, so it is a linear over the flattened patch; `torch.linspace(0, n-1, 1)` returns the START, not the end; `.int()` TRUNCATES when picking the bilinear corners; and the two merger flavours differ — the final merger norms the PRE-shuffle width while the DeepStack mergers norm the POST-shuffle width, both with exact-erf GELU rather than the block MLP's tanh approximation. `test_minimax_h3` 24/24 / 7050 assertions. REMAINS on the encoder: only the MM processor (image/video preprocessing into patches). Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-COND-NOISE`; branch `feat/minimax-h3`) | **MiniMax-H3 condition-noise augmentation.** fl2va/ref2va pin their keyframe and reference-audio rows to a NOISED anchor: `out = noise_aug*clean + (1-noise_aug)*noise`, over packed condition rows, for both the visual and audio sides. | `condition_noise.py` (whole file). | **CPU-GATED EXACT (<= 1e-6).** The mix is trivial; the gate's value is the ROW ACCOUNTING: each visual condition draws noise of length `target_latent_t + imgvid_cond_num_frames` then slices the PREFIX matching its own latent_t (a shorter condition does NOT get a shorter draw), every condition restarts the SAME seed (concatenating and drawing once would be numerically different for multi-reference requests), and rows advance by that condition's own patchified count. The golden supplies the noise upstream drew, so the comparison isolates the accounting from torch's RNG — which remains a tracked open item, consistent with the t2va pipeline also taking noise as an input. `noise_aug == 1.0` is asserted as the documented identity, and shape/row-count disagreements throw rather than mis-slicing. `test_minimax_h3` 25/25 / 8787 assertions. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-REFVID-MATH`; branch `feat/minimax-h3`) | **MiniMax-H3 reference-video geometry + frame schedule** — the pure-math half of `reference_video.py`: the canvas pipeline (aspect clamp to [1:4, 4:1] -> 768 short edge -> max-pixel rescale -> nearest multiple of 32, Python round-half-to-even) and the frame schedule (24 FPS resampled to the 2 FPS Qwen video rate with duplicate indices dropped, then timestamps averaged per temporal patch with the tail padded by REPEATING the last). | `reference_video.py:24-27, 84-103, 201-260`. | **CPU-GATED EXACT** on canvases and on sampled indices + block timestamps. A self-invented invariant ("the snapped canvas respects the max-pixel budget") FAILED and was CORRECTED rather than the port changed: upstream applies the budget BEFORE snapping to 32 and does not re-check afterwards, so 3840x1080 legitimately yields 1920x544 = 1,044,480 > 1,032,192. The test now asserts the invariant the reference actually holds. **DEPENDENCY BOUNDARY recorded:** the rest of the module (probe, transcode, frame extraction, audio decode) shells out to ffmpeg/soundfile and is blocked on the SAME decision as MP4 muxing — one dependency choice unlocks reference-video INPUT decode and generated-video OUTPUT encode together. `test_minimax_h3` 26/26 / 8908 assertions. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-VAE-TILING`; branch `feat/minimax-h3`) | **MiniMax-H3 video-VAE spatial tiling.** The tile plan along one axis plus the seam cross-fade, so large canvases can be decoded in overlapping tiles. | the checkpoint's `klvae.py:192-250` (`split_tiles`, `blend`); shipped config tile_size 256 / tile_overlap_min 64 / vae_ratio 16 (= prod(space_down) [2,2,2,2,1,1], the 'f16' in f16t4). | **CPU-GATED EXACT** over six cases (tiled, exactly-one-tile, smaller-than-tile, and a non-default tile/overlap pair). The plan is NOT a simple stride: it takes the smallest tile count whose MINIMUM overlaps still cover the input, then distributes the leftover slack in whole `vae_ratio` units ROUND-ROBIN across the seams — get that wrong and every tile after the first shifts, surfacing as seam artifacts rather than an error. The test also asserts structural invariants (tiles cover the axis, every seam meets the minimum overlap, overlaps stay congruent mod vae_ratio) and that the cross-fade starts fully on the previous tile and ends fully on the next. `test_minimax_h3` 27/27 / 9036 assertions. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-PRESENTATION-TAGS`; branch `feat/minimax-h3`) | **MiniMax-H3 presentation token tags** — the AdaLN tag layout aligned with the prompt presentation, i.e. the fl2va "vision-span override" that `denoise_loop.py` requires callers to have applied to `token_tags` before the forward. | `presentation.py:20-62, 92-129`. | **CPU-GATED EXACT** against upstream driven by a stub tokenizer (only span LENGTHS affect tags). The load-bearing detail: a vision block is `vision_start + pad*count + vision_end` and the WHOLE block — MARKERS INCLUDED — is tagged VIDEO(0); tagging only the pads leaves two markers as TEXT(1) and shifts every AdaLN modulation index after them, which is a silent wrong-result. The test additionally proves every VIDEO run in the output equals a whole emitted vision span, so an off-by-two cannot pass. Tokenization deliberately stays with the caller (it owns the tokenizer); this owns the span->tag mapping, which is the part that must agree with the packed layout. `test_minimax_h3` 28/28 / 9129 assertions. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-VAE-CNN`; branch `feat/minimax-h3`) | **MiniMax-H3 video-VAE 3D-CNN ENCODER primitives** — causal Conv3d, GroupNorm3D, and the ResnetBlock3D that is the repeated unit of the encoder stack. The encoder serves image/video CONDITIONING (fl2va keyframes, ref2va references), not output frames. | the checkpoint's `conv.py:12-88` (BaseConv3d padding), `norm.py:342-357` (32 groups, eps 1e-6) and `vae_cnn.py:83-171` (ResnetBlock3D). | **CPU-GATED EXACT** vs the checkpoint's own module. Two details pinned: the convolution is CAUSAL in time — `padding[0] * 2` frames on the LEFT and none on the right, with CONSTANT (zero) temporal padding and `reflect` spatial padding — and GroupNorm's statistics span TIME as well as space, so a per-frame normalization would silently differ. CAUSALITY is PROVEN, not assumed: on the bare convolution, a change to the last frame leaves earlier frames bit-identical while the last frame's own output changes; at block level (where GroupNorm mixes across time) the weaker claim that the perturbed frame moves strictly more is asserted instead. `test_minimax_h3` 29/29 / 9137 assertions. REMAINS on the encoder: the Downsample3D + EncoderFCN3D assembly. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-VAE-DOWNSAMPLE`; branch `feat/minimax-h3`) | **MiniMax-H3 video-VAE Downsample3D** — the strided convolution between encoder levels, plus stride support in the shared causal Conv3d. | the checkpoint's `vae_cnn.py:34-81`. | **CPU-GATED EXACT.** The subtlety is the ASYMMETRIC pre-pad: when the spatial stride is 2 the input is padded by ONE pixel on the RIGHT of W and the BOTTOM of H (`F.pad(x, (0,1,0,1,0,0))`) BEFORE a stride-2 conv with padding (1, 0, 0). Padding symmetrically instead shifts the whole sampling lattice by half a pixel — a silent wrong latent, not an error. Output extents are asserted (H/W halve; T halves under the causal pad). `test_minimax_h3` 30/30 / 9143 assertions. REMAINS on the VAE encoder: only the EncoderFCN3D level-loop assembly. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-VAE-ENCODER`; branch `feat/minimax-h3`) | **MiniMax-H3 video-VAE 3D-CNN ENCODER complete** — the level loop assembling conv_in, per-level ResnetBlock3D stacks, Downsample3D (or a 1x1x1 channel match when a level does not downsample), GroupNorm, SiLU and conv_out. With this the video VAE is complete on BOTH halves. | the checkpoint's `vae_cnn.py:177-297`. | **CPU-GATED EXACT.** The channel plan is the fiddly part and is pinned: `block_mid[i] = ch*ch_mult[i]`, `block_in[0] = block_mid[0]`, `block_in[i>0] = block_mid[i-1]`; a level gets a Downsample3D when `space_down[i]*time_down[i] > 1`, otherwise a 1x1x1 conv ONLY if its channel count changes, and nothing at all when it does not. **A first run mismatched at 2.25 and the cause was MY TEST FIXTURE, not the port**: the generator's scale rule tested `".norm" in name`, which silently missed `norm_out.weight` (no leading dot), so the two sides seeded that gain differently. Rule corrected to `"norm" in name`; the port was unchanged. `test_minimax_h3` 31/31 / 9150 assertions. The encoder serves image/video CONDITIONING; a t2va generation path does not call it. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-MM-PROCESSOR`; branch `feat/minimax-h3`) | **MiniMax-H3 MM processor — REUSE of the existing Qwen3-VL front end, gated on H3's own config.** H3's `FL2VA/processor` is a stock `Qwen3VLProcessor`, so no new port was needed; what needed proving is that H3's ACTUAL config parses and drives it. | H3's `FL2VA/processor/preprocessor_config.json` and `video_preprocessor_config.json`; our `multimodal/qwen3vl_processor.{h,cpp}`. | **CPU-GATED PASS.** Parses patch 16 / temporal 2 / merge 2 and — notably — **image_mean/std 0.5 rather than the usual CLIP statistics**, so H3 normalizes to [-1, 1]. Grid factor is patch*merge = 32; the 768x1344 default canvas is proven an IDENTITY under smart_resize (resizing it would silently change the conditioning image), off-grid inputs snap to the grid, and the VIDEO bounds (shortest 4096, longest 25165824) are asserted deliberately LOOSER than the image ones in both directions. `test_minimax_h3` 32/32 / 9178 assertions. **This closes the last PORTABLE item in the lane**; the remainder is one dependency decision (ffmpeg media I/O + MP4 muxing) and GPU-blocked work (the device-resident FP4 forward, and therefore any speed number). Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-WAV`; branch `feat/minimax-h3`) | **MiniMax-H3 audio output — RIFF/WAVE serialization.** The decoded stereo waveform is written as 16-bit PCM, converting the audio VAE's CHANNEL-MAJOR layout to INTERLEAVED. | the WAV/RIFF container spec; the audio VAE's 32 kHz stereo output contract (`vae.py`, `dac_audio_vae.py`). | **CPU-GATED PASS.** Header fields (RIFF/WAVE/fmt/data, PCM tag, channels, sample rate, byte rate, block align, bit depth, chunk sizes) are each asserted, the interleave is verified sample-by-sample against the channel-major input, full-scale +/-1.0 maps to +/-32767 WITHOUT wrapping, and out-of-range input is clamped rather than wrapped. **Deliberately dependency-free**: `/v1/videos` ultimately returns MP4 and how this project obtains a muxer is an OPEN DEPENDENCY DECISION (upstream vLLM-Omni shells out to ffmpeg; this tree has NO subprocess precedent in the core library, so a library that forks is a project-owner call). WAV needs none of that and is required under EITHER outcome. `test_minimax_h3` 33/33 / 9207 assertions. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-VIDEO-OUTPUT`; branch `feat/minimax-h3`) | **MiniMax-H3 video output** — PPM frame serialization and the MP4 mux command, completing the output path alongside WAV. | upstream vLLM-Omni's container choice (H.264 + audio via ffmpeg) and its `/v1/videos` contract. | **CPU-GATED PASS, plus an end-to-end EXTERNAL check.** Unit gates: PPM converts the pipeline's PLANAR [C,T,H,W] float frames to row-major INTERLEAVED RGB with [-1,1] mapped to [0,255] and clamped (header, per-pixel channel order, mid-grey, per-frame distinctness and range checks all asserted); the argv carries h264/yuv420p (so every player accepts it), AAC, `-shortest` (no trailing silence or orphan video) and `+faststart` (moov atom first => streamable), and a SILENT clip is asserted to omit the audio codec and `-shortest`. **External check: the exact argv the library builds was RUN through real ffmpeg 6.1.1 over generated PPM+WAV in this project's own formats, producing a VALID MP4 — ffprobe confirms h264 / yuv420p video plus AAC stereo at 32 kHz.** ARCHITECTURE: the library BUILDS artifacts and the command but NEVER spawns a process (`src/vllm/` has no subprocess precedent, and a forking library is a different commitment from a Python serving layer that shells out); the invocation belongs to the example/server layer. `test_minimax_h3` 34/34 / 9233 assertions. Parity pin UNCHANGED. |
+| 2026-08-03 (`CLAIM-MINIMAX-H3-VIDEO-API`; branch `feat/minimax-h3`) | **MiniMax-H3 `/v1/videos` serving surface** — the request contract and the async job store, mirroring vLLM-Omni's two endpoints (`POST /v1/videos` returning a job id, `POST /v1/videos/sync` returning the MP4 inline). | vLLM-Omni's `/v1/videos` + `/v1/videos/sync` contract and its `extra_params` knobs (duration, num_inference_steps, flow_shift, audio_flow_shift, seed). | **CPU-GATED PASS (4 cases / 63 assertions).** Request parsing applies H3's documented defaults (50 steps, flow shift 12 video / 3 audio), accepts BOTH the vLLM-Omni `extra_params` nesting and a flat top-level spelling, and REJECTS malformed input with a specific reason rather than silently defaulting (non-JSON, non-object, missing/mistyped prompt, non-positive steps or shifts, negative duration or extent). The job store enforces queued -> running -> succeeded/failed: illegal transitions THROW rather than corrupting a finished record, an unknown id is reported so the route can 404 instead of returning an empty 200, a succeeded job must carry an output path, a failed job never has an empty reason, and status JSON omits fields that do not apply. Concurrent creation across 8 threads is asserted to keep ids unique and lose no record. The library still spawns NOTHING — generation+mux enter as a caller-supplied `VideoRunner`, whose ffmpeg invocation lives in `examples/` per the developer's ratified decision. REMAINS: route registration + runner injection (mechanical). Parity pin UNCHANGED. |
+| 2026-08-05 (`CLAIM-MINIMAX-H3-AUDIO-ENCODER`; branch `feat/minimax-h3`) | **MiniMax-H3 audio-VAE ENCODER + the last two unwired ref2va conditioning modes.** Ports the DAC analysis stack (Snake1d, ResidualUnit, EncoderBlock, the strided conv stack), the `pre_block` AttnProjection (causal SDPA, mean over heads, adaptive-average-pool narrowing 2048->32, GeGLU MLP) and `mean_proj`; adds `LoadMiniMaxH3AudioVaeEncoderWeights`, `MiniMaxH3AudioVaeEncodeToRows`, `MiniMaxH3EncodeReferenceAudio` and a gated `MiniMaxH3ReadWav`; replaces the two VT_CHECK refusals so `kAudio` and `kVideoAudio` with `ref_audio_t > 0` work, feeding the denoise loop's previously always-empty `audio_ref_rows`. Driver: `--ref-audio f.wav`. | the checkpoint's own remote code `FL2VA/audio_vae/dac_audio_vae.py:25-117,157,201-209` and `dac_attn_proj.py:8-88`, composed the way vLLM-Omni composes the encode in `vae.py:293-341` (there is no `encode` method on the shipped `DacAudioVAE` — it exposes only `decode`, :211-225); reference-row plumbing per `pipeline_minimax_h3.py:708-730,937-975`. | **CPU-GATED vs the CHECKPOINT'S OWN MODULES, stage by stage**: conv stack **2.98e-8**, AttnProjection **1.64e-7**, whole encode-to-latent **1.86e-8** (generator `scripts/gen-minimax-h3-audio-vae-encoder-goldens.py`, same FNV-1a + splitmix64 stream as the DiT/decoder generators, so no weight byte is checked in). The reduced input is 25 samples against a hop of 4, deliberately NOT a multiple, so a port skipping `preprocess` returns 6 frames not 7. Loader gated on the REAL 1087-tensor manifest, which also confirms the shipped geometry from shapes alone (`encoder_rates` [2,4,4,5,5], `latent_dim` 2048, `attn_proj_dim` 32, qkv 3x the INPUT width); all three weight-norm spellings accepted, the materialized one round-tripping to <=1e-6. `mean_proj` and never `logs_proj` — `logs_proj` is not even loaded, so a reference conditions identically every run. WIRING gated on the load-bearing property rather than acceptance: an audio reference moves the AUDIO rows by **0.51**, a video+audio reference by **0.71** against the SILENT same-clip control, a DIFFERENT waveform still by **7.1e-4**, and a DIFFERENT clip with the same audio moves the VIDEO rows by **3.7e-2**. Only the NARROWING AttnProjection branch is implemented (the one the checkpoint ships); the widening branch refuses loudly. NOT gated: any real-checkpoint reference-audio render. 60/60 cases / 29427 assertions, clean CPU build. |
diff --git a/.agents/roadmap_v1.md b/.agents/roadmap_v1.md
index ee8d437ec..a5c9b6216 100644
--- a/.agents/roadmap_v1.md
+++ b/.agents/roadmap_v1.md
@@ -512,6 +512,7 @@ models we already ship + benchmark. Full seam map + M0–M5 W-plan:
 | 13 | `ROAD-V1-D4` | **KV persistent state to disk, and external KV-cache provider interoperability with LMCache** (user-directed 2026-07-22: "let's do the KV persistent state to disk support, and LMCache support too", under the standing same-featureset-as-vLLM-and-better bar) | [`KV-OFFLOAD`](engine-matrix.md), [`KV-EXTERNAL-CACHE`](engine-matrix.md), [`KV-CONNECTORS`](engine-matrix.md), [coverage view §2](feature-matrix.md#2-kv-cache--memory), [LMCache quickstart](https://docs.lmcache.ai/getting_started/quickstart.html) | spike ACCEPTED [kv-persistence-lmcache.md](specs/kv-persistence-lmcache.md) — 60 enumerated features across `vllm/v1/kv_offload/`, the `KVConnectorBase_V1` ABI and the LMCache integration, each with a DONE/PARTIAL/MISSING verdict read out of our source. **The two halves of the user's ask are NOT the same kind of work.** Disk persistence is a faithful MIRROR job and is tractable: vLLM's `fs` tier is ~101 lines of `open`/`write`/`readv` with nothing Python-specific in the byte path, one raw file per block, temp-file + atomic rename under `O_DIRECT`. LMCache is NOT: the vLLM-facing glue is vendored in-tree (~2396 lines) but every file of it imports the EXTERNAL PyPI package at module scope, and the storage engine, wire protocol, config schema and CUDA-IPC handoff all live outside the tree with no upstream test that runs without it — so it is scoped as an interop STUDY with a go/no-go, never a from-scratch client. **REOPENED 2026-07-23 ([LMCache client wire analysis](specs/lmcache-cpp-client-connector.md)), and the "no specified wire protocol" half of that verdict is REFUTED by reading the LMCache package: vLLM connects to a RUNNING LMCache over TWO fully-specified portable wires — the `lm://` remote-store (plain TCP + fixed `struct` header + raw KV bytes, no ZMQ/msgpack/pickle/CUDA-IPC) and the MP server (ZMQ + `msgspec.msgpack` + CUDA-IPC, the user's "zmq" recollection). A from-scratch C++ client is FEASIBLE with ZERO `lmcache` in-process; both wires sidestep the hash blocker because LMCache keys on its own blake3 token hash. Recommend the `lm://` mode first. Residual risk is that LMCache is an unpinned moving target — an interop feature with a version-sync cost, not a mechanical core port. LMCACHE-CLIENT W1 LANDED 2026-07-23 (`CLAIM-LMCACHE-CPP-CLIENT`, `KV-EXTERNAL-CACHE` `SPIKE`→`ACTIVE`): the pure-CPU `lm://` wire codec — fixed-`struct` `ClientMetaMessage`/`ServerMetaMessage` framing, the `CacheEngineKey` string, the blake3 rolling token hash (vendored BLAKE3 1.5.5), and the `KV_2LTD` `[2,L,T,D]` repack — is BYTE/BIT-EXACT vs fixtures from the real Python codec (`test_lmcache_codec` 6/6, 2074 assertions), blake3 verified byte-identical on x86-64 + aarch64, and INERT (no call site; the connector is client-W3). LMCACHE-CLIENT W2 LANDED 2026-07-23 — the go/no-go PASSED: a blocking POSIX-socket `LMCacheRemoteClient` (PUT/GET/EXIST/HEALTH/LIST + `KV_2LTD` repack + `VT_LMCACHE_*` config) round-trips a REAL `lmcache.v1.server` (`8570aad`, run headless from source in a throwaway venv — torch imported before lmcache to dodge a torch circular import, the compiled `c_ops` ext stubbed as unused by the lm:// CPU store) byte-identical (`test_lmcache_client` 36/36), with BIDIRECTIONAL interop proven against LMCache's OWN Python protocol codec; the always-on CI gate is a same-binary C++ mock-server round-trip (45/45, no Python). STILL `ACTIVE`, not DONE. Resume at client-W3 (wire as a `KVConnector` over the parent W5 seam, then key-agreement + DGX every-axis gates).** **Blocking correction found in OUR source:** `NONE_HASH` is seeded from `std::random_device` with no escape hatch, so every block hash differs across processes and a content-addressed disk tier would score 0% hits on restart — we are WORSE than vLLM here, which at least exposes `PYTHONHASHSEED`. This also FALSIFIES the caching spike's §B2 claim that we are deterministic by construction. **Two upstream weaknesses recorded as beyond-parity targets:** the `fs` tier's `config.json` is written and never read (its only identity check is a path digest that omits checkpoint content, weight quantization, rope config and `sliding_window` — a silent-wrong-output hazard we will not copy), and the disk tier has no capacity accounting and no eviction. Three matrix rows `INVENTORIED` -> `SPIKE`; `SharedStorageConnector` found RENAMED to `ExampleConnector` and `P2pNcclConnector` found DELETED at the pin, both stale in the prior record **W1-W3 IMPLEMENTED 2026-07-22, CPU-only.** W1 deterministic block hashes: `init_none_hash` now resolves explicit arg > `$VLLM_PREFIX_CACHING_HASH_SEED` > `$PYTHONHASHSEED` > a fixed built-in default, so hashes are identical across processes with ZERO configuration — the blocking correction is CLOSED, and we now BEAT upstream on this axis rather than trailing it (upstream is random-by-default and documents `PYTHONHASHSEED` as the operator's problem). Proven by comparing hash chains emitted by SEPARATELY LAUNCHED processes, with a negative control confirming the opt-in `=random` mode genuinely disagrees. W2 CPU primary tier: `CachePolicy` (LRU + ARC) with the `ref_cnt == -1` tri-state and the ATOMIC evict, `CPUOffloadingManager` incl. the `prepare_store -> nullopt` skip control path, pinned backing store, and a side-queue event-polled device/host transfer worker. W3 disk `fs` tier: one raw file per block, temp-file + atomic rename publish, self-healing unlink, dual-queue read/write pool. **BOTH recorded upstream weaknesses are now EXCEEDED rather than merely noted** — the identity block is a VERIFIED header read on EVERY open that REFUSES on mismatch across 27 fields (tested per field, with a positive control), and the tier carries a byte budget with policy eviction honoured across restarts. `O_DIRECT` deliberately NOT ported (a header+payload file breaks its alignment requirement); the GIL-releasing batch-lookup C extension is unconditionally unnecessary without a GIL. `KV-OFFLOAD` `SPIKE` -> `PARTIAL`. **W4 IMPLEMENTED 2026-07-23:** the TIERING MANAGER (ONE manager over CPU primary + disk secondary — disk→CPU promotion RETRY→flush→HIT, cascade demotion, reset drains the secondary first and never resets it so a persisted cache survives) and the CONNECTOR/SCHEDULER HALF (`OffloadingConnector`, the semantics of `KVConnectorBase_V1`'s scheduler hooks — nullopt third state, `block_hashes` striding, load-before-compute — wired OPT-IN + DEFAULT-OFF into the scheduler). First measured offload speedup: a restarted-prefix workload through the REAL scheduler saved 32/48 prefill tokens (2/3 blocks HIT from disk), promoted bytes byte-identical to the cold store; identity refusal holds through a promotion. Ported the SEMANTICS not the Python plugin ABI (compile-time wiring); the full abstract ABI is W5. **W5 IMPLEMENTED 2026-07-23, CPU-only:** the connector seam is now a first-class C++ ABI — the abstract `KVConnector` base carrying the full scheduler + worker method set of `KVConnectorBase_V1` (the scheduler methods load-bearing, the worker hooks defaulted no-ops for our synchronous runner, documented), a compile-time `KVConnectorFactory` + `REGISTER_KV_CONNECTOR` (the C++ analogue of vLLM's `importlib` module path), and a `KVTransferConfig` selection surface (default `kv_connector` empty == no connector == zero behaviour change, `kv_role` validation, `fail`-default load policy). The W4 disk connector was refactored ONTO this base behaviour-identically — the restart-hit e2e reproduces byte-for-byte and a config-selected owning connector shortcuts prefill by the identical 32/48. `KV-CONNECTORS` `SPIKE`→`ACTIVE`. This closes the seam so LMCache client-W3 is 'implement the abstract `KVConnector` with the landed W2 `lm://` client'. **LMCACHE-CLIENT W3 LANDED 2026-07-23 — the `lm://` client wired as a `KVConnector` over the W5 seam (`LMCacheConnector`, `REGISTER_KV_CONNECTOR("LMCacheConnector", …)`, default OFF), the FIRST time the whole chain engine -> connector -> W2 client -> a running lm:// server -> back runs.** Scheduler side computes rolling-blake3 chunk hashes and `Exist`-probes the remote store for the longest cached prefix (synchronous `(n, false)`, mirroring `lmcache_connector.py:230-259`); worker `StoreChunk`/`LoadChunk` drive the W2 client with foreign-block REFUSAL. **Gate ACHIEVED = the connector-level round-trip: STORE a prefix -> a fresh "restarted" connector LOOKS UP + shortcuts prefill through the REAL scheduler (32/48 tokens saved) -> LOAD byte-identical; foreign-key REFUSAL; default-off INERT** (`test_lmcache_connector` 5 cases / 50 assertions vs an in-process mock; store->load ALSO GREEN vs a REAL `lmcache.v1.server` 8570aad, 16 assertions, `VT_LMCACHE_LIVE_*`). **LMCACHE-CLIENT W4 LANDED 2026-07-23 — REAL peer KEY-AGREEMENT + a peer->us interop LOAD, both PROVEN — the interop-correctness milestone is COMPLETE; `KV-EXTERNAL-CACHE` stays `ACTIVE` for the DGX full-model output-invariance + throughput arm.** The actual `lm://` key derivation is `ChunkedTokenDatabase` (NOT the blake3 MP hasher): chunk_size 256, a rolling prefix-hash over `(prefix_int, tuple(tokens), extra=())` keyed by vLLM's OWN hash (portable `sha256_cbor`), folded to uint64 each step, `NONE_HASH=fold8(sha256_cbor(str(PYTHONHASHSEED)))`. Mirrored byte-exact (`chunked_token_database.{h,cpp}`, reusing `CborValue`+`sha256_cbor`) and wired as connector `key_mode=kVllmSha256Cbor` (chunk 256) alongside W3's kept-green blake3 path. Key-agreement GREEN: `test_lmcache_key_agreement` 4/85 == the REAL lmcache `ChunkedTokenDatabase.process_tokens()` BYTE-FOR-BYTE (fixtures dumped from the unmodified real driver + vLLM's pinned `sha256_cbor`/`init_none_hash`), sample `meta-llama/Llama-3.1-8B@1@0@33d6862800fff40c@bfloat16`. Peer->us LOAD GREEN over the wire: a REAL lmcache `ChunkedTokenDatabase` derives a key + PUTs KV to a REAL `lmcache.v1.server`, our C++ re-derives the SAME key and GETs the 512 B byte-identical (`run_key_interop.sh`). ASan+UBSan clean. Text-only (mm-hash extra_keys deferred). **LMCACHE-CLIENT W5 LANDED 2026-07-24 — the LAST open arm, connector-ON full-model OUTPUT-INVARIANCE + throughput in a REAL generation loop, is CLOSED (spec gates 4/6 met).** The worker side is now wired into the engine: `GPUModelRunner::execute_model` calls `ConnectorLoadExternalKv` before the forward (writes the external-prefix KV into the allocated GPU blocks, load-before-compute) and `ConnectorStorePromptKv` after (stores each newly-complete prompt block), and `LoadedEngine` builds the connector from an `EngineParams` `KVTransferConfig` and wires it to BOTH the scheduler and the runner. **OUTPUT-INVARIANCE PROVEN on a real OPT-125m loop vs a live `lmcache.v1.server`: connector-ON generated tokens are BIT-IDENTICAL to connector-OFF (cold full prefill) — first-divergence index -1 — on BOTH (a) a store->restart->load cycle in one process AND (b) a genuinely cold second process that only hits the server; prefill saved on the hit = 48 tokens (3×16-token blocks).** `tests/vllm/models/test_lmcache_output_invariance.cpp` PASSES both modes via `scripts/lmcache/run_output_invariance.sh`. THROUGHPUT reported HONESTLY: on a 125M model the wall-clock delta is noise-dominated (fixed TCP/copy overhead ~ tiny compute saved), so NO binding speedup is claimed — a real speed number is owed by an every-axis grid on a larger model + long shared-prefix corpus (docs/BENCHMARKS.md). No-regression: OPT SACRED UNCHANGED default-off (6/6, 96/96, 63/63); connector unit tests green (codec 6/6, client 3/3, connector 5/5, key-agreement 4/4, kv_offload_connector 11/11); ASan+UBSan clean on the connector path; CUDA `-Werror` 0 warnings. Additive + default-off inert (all worker/loader changes are behind a null-connector guard)| `PARTIAL` | **W7 the one genuine beyond-parity item (imperative named per-sequence save/restore), which now has the verified header it depends on; and a binding every-axis LMCache throughput grid on a larger model vs vLLM's `--kv-transfer-config`.** W5 (the abstract ABI) is DONE; LMCache client W1 (codec) + W2 (client) + W3 (connector round-trip) + W4 (peer key-agreement + interop load) + W5 (full-model output-invariance) are DONE. **The benchmark blocker is CLEARED:** the caching spike's W1 prefix-cache counters landed earlier, so the W4 offload arm proved its hits |
 | 13a | `ROAD-V1-D4-APC` | **Prompt / prefix caching to full vLLM parity, then beyond (user-directed 2026-07-22: "same featureset of vLLM and better")** — the headline user-facing caching feature, previously mentioned only once in this roadmap despite being a shipped, default-ON behaviour for dense models | [`KV-PREFIX-CACHE`](engine-matrix.md), [`KV-BLOCK-POOL`](engine-matrix.md), [`KV-HYBRID-COORD`](engine-matrix.md), [`KV-MAMBA-ALIGN`](engine-matrix.md), [`KV-EVENTS`](engine-matrix.md), [`KV-PREFIX-MATCH-UNIT`](engine-matrix.md), [`ENG-CASCADE-ATTN`](engine-matrix.md), [coverage view §2](feature-matrix.md#2-kv-cache--memory) | umbrella spike ACCEPTED [prefix-prompt-caching-parity.md](specs/prefix-prompt-caching-parity.md) — enumerates the complete pinned-vLLM caching surface (38 features) with a per-feature DONE/PARTIAL/MISSING verdict grounded in our source. **The ported core is deeper than the record claimed** (chain hashing, block pool, all three coordinators, the full hybrid fixed-point intersection, four single-type managers); the real gaps are narrower and different: block-hash extra keys are a no-op stub, there are NO prefix-cache statistics at any level, KV events are inert, `cache_salt` and 3 of 4 hash algos are absent, and `reset_prefix_cache` is implemented but unreachable. Three matrix rows corrected, two of them in our favour. `ENG-CASCADE-ATTN` DISPOSITIONED as not owed (default-off, absent from the MRV2 runner we port, unreachable on Blackwell). llama.cpp comparison completed: its "prompt cache" is session/slot state serialization, strictly weaker than APC on every reuse axis, and vLLM already covers disk persistence via the `kv_offload` fs tier — the ONE genuine capability neither vLLM nor we have is an imperative named per-sequence save/restore **W1 IMPLEMENTED 2026-07-22: prefix-cache statistics exist for the first time.** `BaseCacheStats`/`PrefixCacheStats`/`CachingMetrics` ported 1:1 from `vllm/v1/metrics/stats.py:35-142`, recorded in `get_computed_blocks`, flagged by `reset_prefix_cache`, taken-and-swapped per step and folded into a 1000-request sliding window exposed on `Scheduler`/`EngineCore`/`LLMEngine`. Per the standing parity-enabler rule `log_stats` is DEFAULTED ON (mirroring upstream's `disable_log_stats=False`), so no benchmark arm is void for want of a counter. `Request::num_preemptions` un-deferred to feed the mutually-exclusive `preempted_*` triple. **FIRST MEASURED HIT RATE: 0.75** (1920 of 2560 queried tokens over 16 requests sharing a 128-token prefix), with a caching-OFF 0.0 negative control — the first demonstration in this project that APC actually serves cached tokens. The hard blocker on [`BACKEND-GATE-CUDA-SGLANG-PREFIX`](backend-matrix.md) is CLOSED **W2 DONE 2026-07-27 (`CLAIM-ROADMAP-D4APC`, CPU-gated on dgx GB10, NOT pushed):** `generate_block_hash_extra_keys` ported 1:1 (`kv_cache_utils.py:451-591`) — mm hash + LoRA name + `cache_salt`, fixed order lora->mm->salt (prompt_embeds deferred: no prompt-embeds path); `cache_salt`/`lora_name` carried on `Request`/`EngineCoreRequest`, set before the first hash in `FromEngineCoreRequest` (fixes a latent ordering bug). RED-first no-false-share PROVEN: with the stub a differently-salted request false-hits the prior tenant's 48 cached tokens (`n1==48`), with extra keys `n1==0`. Ported extra-key/ordering cases + hash- and manager-level no-false-share (`test_kv_cache_utils.cpp` 29/29, `test_kv_cache_manager.cpp` 10/10). **This unblocks the MM + LoRA cache consumers.** **W3 DONE 2026-07-27 (`CLAIM-ROADMAP-D4APC-W3`, dgx GB10, NOT pushed) — the FIRST-EVER cache-ON model gate:** on `Qwen/Qwen3-4B` (dense, full-attention, APC-default-ON — the vehicle the prior "vehicle-blocked" note missed) a shared-prefix workload runs APC-ON and APC-OFF through the full paged engine, gating token-identity + hits + prefill drop. **NO engine code changed** (`git diff --stat` = tests+scripts+goldens) ⇒ pure GATE over the already-shipped default-ON path; binary byte-identical ⇒ SACRED unaffected. RESULT (`test_qwen3_apc_e2e` 2/2, 84/84 asserts): APC-ON hits **2240/2777 (rate 0.807)**, APC-OFF 0; APC-ON == APC-OFF EXACT on 5/6 (the 1 diff a vLLM-confirmed 0.125-nat near-tie, RCA'd = attention-kernel-path near-tie flip, not a cache bug); **== vLLM-APC-ON** teacher-forced (APC-OFF 6/6 max gap 0.0 nats = exact argmax, APC-ON 6/6 max gap 0.125 nats, 0 outside top-20); **TTFT drop 70.1→39.9 ms = 1.76×** on a cache hit. Existing 4B SACRED gate 16/16 GREEN (no regression). Oracle vLLM 0.25.0 (0.26 venv broken — editable source disk-reclaimed; 4B byte-stable across the pin). | `DONE` (headline) | **Row DONE for the default dense APC path (block hashing incl. extra_keys, pool, coordinators, stats, scheduling, cache-ON e2e all gated).** Named NON-BLOCKING tails tracked in their own rows / future items: W4 KV events (`KV-EVENTS` — event GENERATION + `msgpack` PAYLOAD DONE 2026-07-27 `CLAIM-ROADMAP-D4-KV-EVENTS`, `SPIKE`→`ACTIVE`, byte-exact vs `msgspec`; live ZMQ transport + engine batch wiring DEFERRED), W5 partial-block primitive (upstream dead-code), W6 Mamba-`align` hybrid cache-on (`KV-MAMBA-ALIGN`, SPIKE — feeds `BACKEND-GATE-CUDA-SGLANG-PREFIX`), W7 `reset_prefix_cache` dev-endpoint + `--prefix-caching-hash-algo` + `skip_reading_prefix_cache`, W8/W9 the beyond-vLLM named session save/restore. The every-axis cache-on grid vs vLLM/SGLang is a separate perf follow-on under `ROAD-V1-A`. No `/metrics` route yet (`SERVE-METRICS`), so the hit rate is read from the engine API. **`--prefix-match-unit` (0.26-new fine-grained matching unit) W0 spike + W1 resolver LANDED 2026-07-28 (`CLAIM-PREFIX-MATCH-UNIT`, `KV-PREFIX-MATCH-UNIT` PARTIAL): `resolve_kv_cache_block_sizes` computes `hash_block_size = prefix_match_unit if set else gcd(group_block_sizes)`, RED-first unit-gated; config/CLI/ABI field (W2) + scheduler threading of `hash_block_size != block_size` (W3, needs the `KV-BLOCK-POOL` align path) + benchmark (W4) deferred.** |
 | 14 | `ROAD-V1-D5` | LoRA, local KV/weight offload, expert streaming, wider model zoo | [engine matrix](engine-matrix.md), [model matrix](model-matrix.md) | corrected expert-streaming spike accepted (`ENG-EXPERT-STREAM` READY): bank-only safetensors→Marlin bank, fixed contiguous cache slots matching Marlin dense strides, logical→slot remap after explicit router D2H, chunked C<E prefill, whole-system GB10 memory gate; mirror floor `ENG-WEIGHT-OFFLOAD` inventoried; LoRA/local KV-offload/model-zoo unspiked | `PARTIAL` | claim expert-streaming W0 trace/c1 baseline, then W1 cache policy and W2 bank/reader/pread leaves; rest after T1 dependencies close |
+| H3 | `ROAD-V1-H3` | **DIFFUSION generation — a new capability class.** MiniMax-H3 (`MiniMaxH3DiTModel`): omni-modal video+audio generation via a 50-step flow-matching denoise loop, ported from vLLM-Omni. Not autoregressive: no KV cache, sampler or logits. | [`MODEL-DIFFUSION-minimax-h3-mini-max-h3-dit`](model-matrix.md) | [minimax-h3 spike](specs/minimax-h3.md) | `PARTIAL` | **W0-W2 landed 2026-08-03**: packed layout (fp64 grid bit-exact), latent packing, scheduler and the full DiT forward parity-gated vs the upstream vLLM-Omni modules at reduced dims (max abs diff 1.6e-7, 10/10 cases). **W2b device-resident forward LANDED (f32) and GPU-VERIFIED 2026-08-03** — the whole DiT graph runs with activations resident in device memory, gated vs the same upstream goldens on a Thor sm_110 GPU at video 1.49e-7 / audio 8.94e-8. Only 3 H3 kernels were needed; the port reuses the tuned shared ops. Next gate: bf16 stream + `vt::FusedChain` glue folds, then the FP4 path — which needs sm_121a, since sm_110 resolves every fp4/cutlass feature DISABLED. **HW verdict CORRECTED 2026-08-03: e2e is NOT blocked** — quantized H3 checkpoints fit (GGUF ~41 GB working set; NVFP4 likewise) and the ComfyUI-GGUF arm's 535-tensor manifest already resolves onto our contract, so e2e + a speed comparison are reachable. W7 `/v1/videos` still needs a NEW MP4/AV-encoder dependency decision. |
 
 An area row cannot enter `READY` without a real spike under `specs/`, and cannot
 enter `DONE` without exact code and test/evidence anchors. Closed execution
diff --git a/.agents/specs/minimax-h3.md b/.agents/specs/minimax-h3.md
new file mode 100644
index 000000000..bce2d0e19
--- /dev/null
+++ b/.agents/specs/minimax-h3.md
@@ -0,0 +1,315 @@
+# MiniMax-H3 — omni-modal video+audio diffusion transformer
+
+**Rows:** `MODEL-DIFFUSION-minimax-h3-mini-max-h3-dit` (model-matrix),
+`ROAD-V1-H3` (roadmap portfolio).
+**Claim:** `CLAIM-MINIMAX-H3-W0-W2`, `CLAIM-MINIMAX-H3-W6A-W9`.
+**Upstream:** vLLM-Omni (`vllm-project/vllm-omni`), `vllm_omni/diffusion/models/minimax_h3/`.
+**Checkpoint:** `MiniMaxAI/MiniMax-H3` (gated), ~354 GB, BF16 safetensors.
+**Quantized checkpoints:** `realrebelai/MiniMax-H3_GGUFs` (ComfyUI GGUF),
+`lilcheaty/MiniMax-H3-NVFP4` — these FIT one GB10; see section 0.
+**Status:** W0 spike + W1/W2 (layout, scheduler, DiT forward incl. the bf16
+production stream), W6a (request planning) and W9 shape/geometry (GGUF arm) landed,
+all parity-gated. End-to-end is NOT hardware-blocked on the quantized arms; it is
+gated on the remaining bricks (encoder, VAEs, pipeline).
+
+---
+
+## 0. Honesty statement — what is and is not claimed
+
+MiniMax-H3 is **not an autoregressive LLM**. It is a CFG-distilled joint
+video+audio **diffusion transformer**: one request runs a fixed 50-step
+flow-matching denoise loop in which a 33.1B DiT is forwarded ONCE PER STEP over
+the whole packed sequence, and the resulting latents are decoded to 24 FPS frames
+plus a 32 kHz stereo waveform by two VAEs. There is no KV cache, no sampler, no
+logits, and no token-exact gate — the SACRED near-tie methodology this project
+uses for decoders does not apply to it.
+
+**Hardware — CORRECTED 2026-08-03 (user-directed).** The BF16 release validates on
+**4x NVIDIA B300** at ~133 GB peak per rank (~103 GB with text-encoder TP), and at
+~354 GB of storage it does not fit one GB10 (119 GiB UNIFIED). An earlier revision
+of this spec concluded from that alone that H3 e2e was "impossible on this
+project's hardware". **That was wrong**: it reasoned from the BF16 release only.
+QUANTIZED H3 checkpoints exist and they DO fit:
+
+| Arm | Components | Size |
+|---|---|---|
+| GGUF (ComfyUI format) | DiT `MiniMax-H3-FL2VA-Q3_K_M.gguf` 15.6 GB + Qwen3-VL encoder `qwen3vl-32B-...-Q4_K_M.gguf` 14.6 GB + the two VAEs (fp16 video ~10 GB, fp32 audio ~0.6 GB) | **~41 GB** |
+| NVFP4 (safetensors) | `minimax_h3_ref2va_nvfp4_{full,mixed}.safetensors` + `text_encoders/qwen3vl_32b_..._nvfp4_awq.safetensors` + `vae/minimax_h3_{video_vae_fp16,audio_vae_fp32}.safetensors` | fits, repo 77.2 GB across 3 DiT variants |
+
+Sources: `realrebelai/MiniMax-H3_GGUFs` and `lilcheaty/MiniMax-H3-NVFP4`. Both land
+well inside the 119 GiB pool, so **end-to-end H3 IS reachable here, and therefore
+so is a speed comparison.** NVFP4 is the more interesting arm for this project:
+GB10/sm_121 has native FP4 tensor cores and our NVFP4 stack (cutlass FP4 GEMM,
+Marlin W4A16 grouped MoE, the Laguna arm's tuning) is the most optimized path we
+own. What remains blocked is a like-for-like comparison against vLLM-Omni's own
+published numbers, which were measured on 4x B300 — a different machine class.
+
+**Therefore:** the CORRECTNESS gate is upstream itself executed at REDUCED
+DIMENSIONS on CPU (section 4) — that is available today and is exact. The
+END-TO-END gate is now a matter of finishing the remaining bricks (encoder, VAEs,
+pipeline) and downloading a quantized checkpoint, NOT a hardware wall. Nothing in
+THIS change claims a generated video or a speed figure; what changed is that both
+are now on the critical path rather than out of reach.
+
+## 1. Architecture
+
+From `minimax_h3_transformer.py:47-78` (`MiniMaxH3DiTArchConfig`) — the shipped
+geometry:
+
+| Field | Value | Note |
+|---|---|---|
+| `num_layers` | 50 | AdaLN DiT blocks |
+| `token_refiner_num_layers` | 2 | plain pre-norm blocks over text rows |
+| `hidden_size` | 5376 | |
+| `num_attention_heads` | 56 | **MHA** — `total_num_kv_heads == total_num_heads` |
+| `attention_head_dim` | 128 | |
+| `ffn_hidden_size` | 14336 | SwiGLU, fused `[gate; up]` fc1 |
+| `latents_dim` | 24 | video VAE latent channels |
+| `audio_latents_dim` | 32 | audio VAE latent channels |
+| `patch_size` | (1, 2, 2) | video row width = 24*1*2*2 = **96** |
+| `text_dim` | 5120 | H3-Encoder hidden width |
+| `timestep_input_dim` | 256 | sinusoidal, **cosine before sine** |
+| `time_embed_dim` | 2688 | AdaLN input |
+| `adaln_out_features` | 18*5376 | 6 vectors x 3 modalities x H |
+| `rope_inv_freq_len` | 16 | 3D RoPE rotates 6*16 = **96 of 128** head dims |
+
+Per block: `norm1 -> AdaLN scale/shift -> attention -> AdaLN gated residual ->
+norm2 -> AdaLN scale/shift -> SwiGLU MLP -> AdaLN gated residual`. AdaLN
+parameters are produced per (unique timestep, modality) pair and selected per row
+by `combined_indices = inverse_indices * 3 + token_tags.clamp(min=0)`
+(`minimax_h3_transformer.py:1057`).
+
+Attention is **packed varlen NON-CAUSAL**: rows of all modalities live in one
+sequence, `cu_seqlens = {0, used, seq_len}` gives two documents (content and
+64-alignment padding), and attention never crosses that boundary. This maps
+exactly onto our shared `vt::DFlashBlockAttention(causal=false)` — no new kernel.
+
+12 parameters plus the RoPE buffer stay **FP32** after load
+(`minimax_h3_transformer.py:85-101`, re-asserted by `post_load_weights` at
+`:898-904`): both patch projections, both time-embedder projections, and both
+final output heads. Everything else is BF16.
+
+## 2. Component inventory (the whole chain, not just the DiT)
+
+| Component | Upstream | Size | Our status |
+|---|---|---|---|
+| Omni DiT | `minimax_h3_transformer.py` (1112 L) | 66.3 GB | **W2 LANDED** (CPU reference forward, parity-gated) |
+| Packed layout | `packed_sequence.py` (572 L) | — | **W1 LANDED** (fl2va + ref2va, fp64 grid bit-exact) |
+| Latent packing | `packed_tokens.py` (114 L) | — | **W1 LANDED** (+ round-trip) |
+| Scheduler | `scheduling_..._euler_ancestral.py` (179 L) | — | **W1 LANDED** |
+| Denoise loop | `denoise_loop.py` (249 L) | — | **W2 LANDED** (driver ported, not e2e-gated) |
+| H3-Encoder | `encoder.py` (1214 L) | 51.5 GB | **W3 COMPLETE** — text tower at 1.2e-7 (truncation + UNNORMALIZED output + DeepStack), the FULL vision tower at 6.0e-8, and the MM processor as REUSE of our existing Qwen3-VL front end, gated on H3's own processor config |
+| Video VAE | `vae.py` adapter + checkpoint REMOTE CODE (`FL2VA/video_vae/*.py`) | ~10 GB | **W4 DECODER DONE** — the FULL ViT3D decoder (pack, x_embedder, register/cls tokens, 3D RoPE, 36-block stack, norm_out, proj_out, unpatchify) is ported and gated at **8.9e-8**. Tiling and the 3D-CNN encoder (conditioning only) remain. See 5.1 |
+| Audio VAE | `vae.py` adapter + checkpoint REMOTE CODE (`FL2VA/audio_vae/*.py`) | ~0.6 GB | **W5 LANDED** — DAC/BigVGAN decoder REIMPLEMENTED, gated vs the checkpoint's own modules at 4.2e-9 |
+| Pipeline / tasks | `pipeline_minimax_h3.py` (1196 L) | — | **W6 t2va ASSEMBLED** — the whole path composes and runs (structural e2e gate); fl2va/ref2va conditioning and the torch-RNG noise seed remain |
+| Conditioning | `condition_noise.py`, `reference_video.py`, `presentation.py`, `time_request.py` | — | **PARTIAL** — condition-noise augmentation DONE and reference-video GEOMETRY + FRAME SCHEDULE DONE; the rest of `reference_video.py` is ffmpeg plumbing (see 5.2) and presentation TOKEN TAGS are done (its tokenization stays with the caller) |
+| Serving | vllm-omni `/v1/videos`, `/v1/videos/sync` | — | **W7 DONE (CPU)** — both routes plus `GET /v1/videos/{id}` registered on `ApiServer`, additive and opt-in via `set_video_runner` |
+| GGUF arm (ComfyUI format) | `realrebelai/MiniMax-H3_GGUFs` | 15.6 GB (DiT Q3_K_M) | **W9 DONE** — identity name map (gated on the real 535-tensor manifest) PLUS `LoadMiniMaxH3DitFromGguf`: dequantize through the shared GGUF path, recover the geometry from shapes, bind the forward's views |
+| NVFP4 arm | `lilcheaty/MiniMax-H3-NVFP4` | fits | **W10 LOADER DONE** — `LoadMiniMaxH3DitFromNvfp4` dequantizes the compressed-tensors triple through the project's existing NVFP4 path into a runnable DiT. Previously GROUNDED: — the real 1051-tensor manifest is textbook compressed-tensors NVFP4 (U8 packed + E4M3 group-16 `weight_scale` + F32 `weight_scale_2`), i.e. EXACTLY our existing layout; 258 quantized projections, islands unquantized |
+
+Tasks: `t2va` (text), `fl2va` (first/last-frame), `ref2va` (reference). Duration
+4-15 s snapped to `17n+5` frames at 24 FPS; 50 inference steps; flow shift 12
+(video) / 3 (audio); resolution 1440p or 768p short edge, multiples of 32.
+
+## 3. Dispatch and reuse — what we already have
+
+* **Packed non-causal attention** -> `vt::DFlashBlockAttention(causal=false)`
+  (already CPU + CUDA). Its per-document bidirectional contract IS upstream's
+  varlen FA call; no new attention kernel is needed.
+* **SwiGLU merged gate/up** -> the `layers::MlpGateUpMethodBase` merged-GEMM seam
+  (AGENTS.md "born fused"). The W2 reference forward calls the projections
+  directly; folding onto the seam is part of W2b.
+* **Add+RMSNorm glue** -> `vt::FusedChain` recipes, W2b.
+* **H3-Encoder** -> our existing `qwen3_vl_{text,vision}.cpp` +
+  `multimodal/qwen3vl_processor.cpp`. The deltas are: keep only the first 50
+  decoder layers and consume the UNNORMALIZED hidden state after layer 49; all-ones
+  attention mask; DeepStack injection at the first `len(deepstack_visual_indexes)`
+  layers. This is the single largest reuse in the port.
+* **Multi-GPU** — upstream uses Ulysses sequence parallelism (`--usp 4`) plus
+  optional DiT TP. We have `vt::communicator` / NCCL but no USP; this is W8 and is
+  only reachable on multi-GPU hardware we do not have.
+
+## 4. Gates
+
+**What can be gated on any CPU (and IS, as of W2):** upstream's pure-Python
+modules are imported by file path and executed at reduced dimensions;
+`scripts/gen-minimax-h3-goldens.py` freezes their outputs into
+`tests/vllm/models/minimax_h3_goldens.inc`, and `tests/vllm/models/test_minimax_h3.cpp`
+reproduces them. Weights and inputs are rebuilt on both sides from an identical
+FNV-1a + splitmix64 stream, so not one weight byte is checked in.
+
+Landed results (`build-cpu`, Release, 10/10 test cases, 2539 assertions):
+
+| Gate | Result |
+|---|---|
+| fl2va packed layout (ids, tags, positions, masks, cu_seqlens, doc ids) | **exact** |
+| fl2va fp64 position grid | **bit-exact** (all 192 doubles) |
+| ref2va block layout (image + video_audio reference blocks) | **exact**, incl. fp64 grid |
+| patchify / unpatchify / audio pack / unpack | **exact** + round-trip identity |
+| euler-ancestral eta0 scheduler + `rf_v_to_x0` | **exact** (<= 1e-6) |
+| **DiT forward, reduced dims, f32** | **max abs diff 1.6e-7 (video), 1.5e-7 (audio)** |
+| denoise-loop INVARIANTS (pinned rows reset every step, targets advance, finite) | pass |
+| bf16 PRODUCTION stream vs upstream's dtype policy | max abs diff 2.4e-3 (bf16 scale) |
+| request planning (frames, latent shapes, sigma schedules, canvas, task dispatch) | **exact** |
+| **REAL GGUF manifest** (535 tensors of `MiniMax-H3-FL2VA-Q3_K_M.gguf`) | **exact** — every name and logical shape matches our contract, geometry derived from shapes alone equals the shipped H3 config |
+| **AUDIO VAE decoder** vs the checkpoint's OWN remote code | **max abs diff 4.2e-9** (kaiser-sinc filter 3.0e-8) |
+| **AUDIO VAE ENCODER** vs the checkpoint's OWN remote code, STAGE BY STAGE | **conv stack 2.98e-8, `pre_block` AttnProjection 1.64e-7, whole encode-to-latent 1.86e-8** — `DacAudioVAE` exposes only `decode`, so the encode is composed the way vLLM-Omni composes it (vae.py:317-325): preprocess right-pad -> `Encoder` -> `pre_block` -> `mean_proj`. Generator: `scripts/gen-minimax-h3-audio-vae-encoder-goldens.py`. `mean_proj` and never `logs_proj` — a sampled reference would condition differently every run |
+| **REAL NVFP4 manifest** (1051 tensors) | **exact** — compressed-tensors triple, group 16, islands unquantized, names identical to our contract |
+| **REAL video-VAE manifest** (560 tensors) | **exact** — decoder confirmed a 36-block ViT, encoder the 3D CNN |
+| **VIDEO VAE decoder TransformerBlock** vs the checkpoint's OWN remote code | **max abs diff 6.0e-8** |
+| **VIDEO VAE FULL ViT3D decoder** vs the checkpoint's OWN remote code | **max abs diff 8.9e-8** |
+| **ENCODER text tower** (truncation + unnormalized output + DeepStack) | **max abs diff 1.2e-7** |
+| **ENCODER vision block** (LayerNorm, fp32 rotary, varlen non-causal, tanh-GELU) | **max abs diff 6.0e-8** + boundary isolation proven |
+| **ENCODER FULL vision tower** (patch embed -> pos interp -> 2D rotary -> blocks -> mergers), ragged 2-image batch | **max abs diff <= 1e-4**, DeepStack + merged both |
+| **CONDITION-NOISE augmentation** (fl2va/ref2va anchors, visual + audio) | **exact** (<= 1e-6), noise supplied so the gate isolates row accounting from torch RNG |
+| **REFERENCE-VIDEO geometry + frame schedule** | **exact** (canvas, sampled indices, block timestamps) |
+| **VIDEO VAE tiling plan + seam blend** | **exact** (round-robin slack distribution, cross-fade) |
+| **PRESENTATION token tags** (the fl2va vision-span override) | **exact**; VIDEO runs proven to be whole vision blocks |
+| **VAE encoder ResnetBlock3D** (causal Conv3d + GroupNorm3D) | **exact**; causality PROVEN on the bare convolution |
+| **VAE encoder Downsample3D** (asymmetric pre-pad + strided causal conv) | **exact** |
+| **WHOLE VAE 3D-CNN encoder** (conv_in -> levels -> norm -> conv_out) | **exact** |
+| **MM PROCESSOR reuse** (H3's own processor config through our Qwen3-VL front end) | **pass** — image + video bounds, 0.5 normalization, 32-grid |
+| **WAV serialization** of the decoded waveform | **pass** — header fields, channel-major -> interleaved, clamping |
+| **VIDEO OUTPUT: PPM frames + MP4 mux argv** | **pass**; and the built argv was RUN through real ffmpeg 6.1.1, producing a valid h264/yuv420p + AAC-32kHz MP4 (ffprobe-verified) |
+| **`/v1/videos` request contract + job store** | **pass** — defaults, validation, lifecycle transitions, status JSON, thread safety |
+| **`/v1/videos` route dispatch on `ApiServer`** | **pass** — no-runner 500, unknown-id 404, sync success returns the runner's path, a throwing runner fails the job (async worker never terminates the process), malformed body 400 without reaching the runner |
+| **DEVICE-RESIDENT DiT forward** (CPU backend) | **pass** — same goldens, same 2e-5 tolerance as the CPU reference |
+| **DEVICE-RESIDENT DiT forward on a REAL GPU** (Thor, sm_110) | **pass — video 1.49e-7 / audio 8.94e-8** vs upstream; 36/36 cases, and the CUDA case is proven to have RUN (220 assertions execute, not skip) |
+| **AUDIO-VAE CHECKPOINT LOADER** (real 1087-tensor manifest) | **pass** — and it caught TWO silent-failure mismatches: the shipped file uses torch's LEGACY `weight_g`/`weight_v`, not the `parametrizations.weight.original0/1` the decoder reads, and BigVGAN sits under `decoder.` while `dec_in_proj.*` is top level. Mapping asserted INJECTIVE over the real manifest (2770 assertions) + an end-to-end load-and-DECODE over a synthetic file written in the shipped spellings |
+| **Audio-VAE loader accepts ALL THREE weight-norm spellings** | **pass** — (1) LEGACY `weight_g`/`weight_v` (official checkpoint), (2) MODERN `parametrizations.weight.originalN` (what the decoder reads), (3) MATERIALIZED plain `weight` (repackaged community bundles). The third is reconstructed exactly, round-trip **1.49e-08** |
+| **AUDIO-VAE ENCODER LOADER** (same real 1087-tensor manifest) | **pass** — takes the half the decoder loader skips: strip `encoder.`, keep top-level `pre_block.*`/`mean_proj.*`, drop `logs_proj.*`, and accept all three weight-norm spellings (the materialized one reconstructed to <=1e-6 round-trip). The manifest also confirms the SHIPPED encoder geometry from shapes alone: `encoder_rates` [2,4,4,5,5], `latent_dim` 2048, `attn_proj_dim` 32, qkv 3x the INPUT width (the narrowing AttnProjection branch). A plain Linear's `.weight` must NOT be mistaken for a materialized weight-norm, which is asserted |
+| **ref2va AUDIO + VIDEO+AUDIO references WIRED** | **pass** — the last two unwired conditioning modes. Gated on conditioning CHANGING the result: an audio reference moves the AUDIO rows by **0.51**, a video+audio reference by **0.71** against the SILENT same-clip control, a DIFFERENT waveform still by **7.1e-4**, and a DIFFERENT clip with the same audio moves the VIDEO rows by **3.7e-2**. An audio-bearing block with no encoded rows behind it THROWS. Driver `--ref-audio f.wav` on a library `MiniMaxH3ReadWav`, gated against the writer it inverts and REFUSING a non-32 kHz file |
+| **VIDEO-VAE CHECKPOINT LOADER** (real 560-tensor manifest) | **pass** — mapping is just the `decoder.` prefix (no weight-norm spelling change), asserted INJECTIVE. ★ Surfaced a MISSING STEP: `post_quant_conv` (Conv3d 24->24, kernel 1x1x1) sits OUTSIDE `ViT3DDecoder`, so the 8.9e-8 decoder gate never covered it and NOTHING in this port applied it — a decode that runs, looks plausible and is wrong. Now implemented, gated against a hand-computed contraction, AND wired into `MiniMaxH3GenerateT2va` — the pipeline test re-runs t2va with it present and requires the frames to move (0.056) while the waveform stays bit-identical |
+| **ENCODER CHECKPOINT LOADER** (FL2VA/text_encoder, 14 shards / 1058 tensors) | **pass** — the only loader that TRANSFORMS rather than renames: HF ships `self_attn.{q,k,v}_proj` and `mlp.{gate,up}_proj` SEPARATE, the port (like vLLM) consumes them FUSED, so they are row-concatenated as `[q\|k\|v]` and `[gate\|up]`. Gated byte-exact ACROSS SHARDS (one layer deliberately split between two files), plus layer truncation, plus the H3 deltas: `norm.weight` and `lm_head` are NOT loaded, because H3 reads the UNNORMALIZED truncated output. The VISION tower needs no fusion — HF already ships `attn.qkv` fused |
+| **ASSEMBLY driver** (`examples/minimax-h3-gen`) | **pass (LOAD + PLAN)** — composes the DiT + both VAEs + both shipped configs, over real file formats, on both the dequant and keep-quant GGUF paths. Shape planning verified: 768x1344 / 16 = 48x84 latent. ★ A full generation on a REAL checkpoint is still UNRUN (needs the multi-GB download) |
+| **DEVICE-RESIDENT bf16 PRODUCTION stream** (CPU + Thor GPU) | **pass — video 2.41e-3 / audio 2.05e-3** vs the bf16 goldens (tol 5e-3), essentially the CPU reference's own 2.4e-3 / 2.1e-3, so the CAST POINTS agree; the test also asserts the bf16 result DIFFERS from f32 by >1e-5, without which a no-op dtype policy would pass |
+| **TRUE bf16 STORAGE** (activations AND weights) | **pass — video 6.16e-4 / audio 5.21e-4**, a ~4x IMPROVEMENT on the round-in-place figures above. Cause: the bf16 golden was generated with bf16 WEIGHTS (the generator's `to_bf16_weights`), so staging the bf16-stored modules as bf16 — while keeping upstream's fp32 ISLANDS f32 — matches the golden's model, not just its activation cast points |
+| **WHOLE t2va PATH composes** (layout -> sigmas -> denoise loop -> unpack -> denormalize -> both VAEs) | frames + stereo waveform, correctly shaped, finite, in [-1, 1] |
+| **GGUF LOAD -> runnable DiT** (synthetic ComfyUI-format file) | geometry recovered from shapes; a real forward runs off the loaded weights |
+| **NVFP4 LOAD -> runnable DiT** (synthetic compressed-tensors file) | packed [out, in/2] recovered as logical [out, in]; sidecars excluded; a real forward runs |
+| config-parse invariants + weight contract + grouped-qkv reorder | pass |
+
+The fp64 position grid is gated bit-exact deliberately: it feeds RoPE, and a
+last-ulp drift would silently rotate every video token. The port therefore
+reproduces upstream's arithmetic ORDER — `numpy.linspace(endpoint=False)`
+evaluates `i*step + start`; `_temporal_position_span` uses numpy PAIRWISE
+summation while `_video_t_span` uses Python's SEQUENTIAL `sum()`, which upstream
+keeps separate on purpose (`packed_sequence.py:101-113`).
+
+**What cannot be gated here:** any end-to-end video/audio result, any speed
+number, the encoder/VAE numerics (no checkpoint), and the multi-GPU USP path. All
+are recorded PENDING in `docs/BENCHMARKS.md`, not as passes.
+
+**Reference audio, still ungated:** no real-checkpoint render with `--ref-audio` has been run. The encoder numerics, the loader mapping and the wiring are all gated; what is not is a full generation conditioned on a real waveform, which needs the multi-GB download and a GPU.
+
+**Oracle note.** The parity pin (`555967922`, vLLM 0.26.0.dev0) does NOT contain
+MiniMax-H3 — H3 was released after it, and it lives in the separate `vllm-omni`
+repository, which the pin protocol does not currently cover. Advancing the pin
+does not by itself make H3 gateable; a vllm-omni pin is a prerequisite for W3+ and
+is tracked as an open item in 7.
+
+## 5. Known hard parts
+
+### 5.1 The VAEs are REMOTE CODE, not upstream Python
+
+`vae.py:41-53` loads both VAEs with
+`get_class_from_dynamic_module(config["auto_map"]["AutoModel"], component_path)` —
+i.e. the actual VAE implementations ship INSIDE the HF checkpoint and run under
+`--trust-remote-code`. vLLM-Omni only adapts them. A pure-C++ engine cannot do
+that: W4/W5 must **reimplement both VAEs in C++ from the checkpoint's Python
+source**, which must be fetched separately (the VAE modules and their `config.json`
+are small; the 354 GB of weights are not needed to READ the architecture).
+
+**Status 2026-08-05: BOTH VAEs are DONE IN BOTH DIRECTIONS.** Decoders: audio
+(DAC/BigVGAN, 4.2e-9) and the video ViT3D (8.9e-8). Encoders: the video 3D CNN
+(image/video conditioning) and now the AUDIO encoder — the DAC analysis stack
+plus `pre_block` and `mean_proj`, gated stage by stage at 2.98e-8 / 1.64e-7 /
+1.86e-8. That was the last thing standing between ref2va and its audio-bearing
+reference blocks, which are now wired and gated on moving the result.
+
+**Original note: the remote code is IN HAND** (fetched from the checkpoint's
+`FL2VA/{audio,video}_vae/`, ~130 KB of Python, NOT vendored here — it ships under
+the MiniMax H3 Community License). The **audio VAE is DONE** (W5): a DAC-lineage
+BigVGAN vocoder, reimplemented and gated against the checkpoint's own modules at
+4.2e-9 by `scripts/gen-minimax-h3-audio-vae-goldens.py`. The **video VAE (W4)** is the largest remaining brick, but the real
+checkpoint manifest (560 tensors, `FL2VA/video_vae/source/model.safetensors`,
+captured by range request) makes it materially smaller than `klvae.py`'s 48 KB
+suggested: the **ENCODER** is the 3D CNN (116 tensors, rank-5 Conv3d down blocks)
+while the **DECODER** — the half generation actually needs — is a plain **36-block
+TRANSFORMER** (440 tensors: `attn.to_qkv`/`attn.to_out`, `ff.w1`/`ff.w2`, two
+norms and two learned residual scales per block, plus `x_embedder`, `mask_token`,
+`register_tokens`, `norm_out`, `proj_out`). We have every primitive for that. The
+whole checkpoint is fp32.
+
+Contracts already pinned down from the adapter:
+* Video VAE weights stay **FP32**; keyframe encode is seeded
+  (`MINIMAX_H3_KEYFRAME_ENCODE_SEED = 42`) and its normalize+patchify runs on
+  **CPU in FP32** on purpose (`vae.py:185-202`) — doing it on CUDA measurably
+  changes the conditioned video.
+* Latents are normalized by per-channel `latents_mean`/`latents_std` from the
+  component `config.json`, then patchified with (1,2,2).
+* Audio VAE is FP32 for both encode and decode, 32 kHz, 2 channels, and encode
+  runs under a determinism context that disables TF32, cuDNN, and the fused SDP
+  backends (`vae.py:56-94`) — the C++ port must match that numerically, not just
+  structurally.
+
+### 5.2 Output is a container, not tokens
+
+`/v1/videos` returns MP4 (H.264 video + stereo audio). We have no muxer and no
+video/audio ENCODER anywhere in the tree (`third_party/` has blake3, doctest,
+httplib, minja, nlohmann, vulkan). W7 must choose: vendor a minimal MP4 muxer plus
+an encoder, or take a dependency. This is a genuine new dependency decision and is
+called out rather than assumed.
+
+### 5.3 Speed
+
+Upstream reports the DiT at **88% of request latency** and FL2VA at ~87 s E2E for
+an 8.7 s 1248x768 clip on 4x B300, with regional `torch.compile`, cache-dit block
+caching, and USP-4. Matching that needs the device-resident forward (W2b), the
+fusion folds, and multi-GPU. No speed claim is possible before W2b lands and
+hardware exists to measure on.
+
+## 6. Files ported in this change
+
+| Ours | Upstream |
+|---|---|
+| `include/vllm/model_executor/models/minimax_h3.h` | the module's public contracts |
+| `src/vllm/model_executor/models/minimax_h3_packing.cpp` | `packed_tokens.py`, `packed_sequence.py`, `scheduling_..._euler_ancestral.py` |
+| `src/vllm/model_executor/models/minimax_h3.cpp` | `minimax_h3_transformer.py`, `denoise_loop.py` |
+| `scripts/gen-minimax-h3-goldens.py` | executes the above upstream modules as the oracle |
+| `tests/vllm/models/test_minimax_h3.cpp` | `tests/diffusion/models/minimax_h3/test_minimax_h3_{packing,contract}.py` |
+
+**Tests to port (upstream `tests/diffusion/models/minimax_h3/`):**
+`test_minimax_h3_packing.py` (DONE — layout + patchify goldens),
+`test_minimax_h3_contract.py` (PARTIAL — config/weight contract done, pipeline
+contract pending W6), `test_minimax_h3_e2e.py` (BLOCKED — needs the checkpoint),
+`test_minimax_h3_parallel.py` (BLOCKED — needs multi-GPU).
+
+## 7. Work breakdown
+
+| Brick | Scope | Blocked by |
+|---|---|---|
+| **W0** | Spike, component inventory, hardware verdict | — (DONE) |
+| **W1** | Packed layout + latent packing + scheduler, parity-gated | — (DONE) |
+| **W2** | DiT forward + denoise driver, parity-gated on CPU at reduced dims | — (DONE) |
+| **W2b** | Device-resident forward. **LANDED (f32) and VERIFIED ON A REAL GPU** — `MiniMaxH3DitForwardDevice` keeps every activation in device memory across the whole block stack; gated against the SAME upstream goldens on the CPU backend AND on a Thor sm_110 GPU at **video 1.49e-7 / audio 8.94e-8** (tolerance 2e-5). Only 3 H3 kernels were needed (`kMiniMaxH3` table: two indexed AdaLN modulates + ungated SiLU) because the port reuses the tuned shared ops — H3's 3-axis RoPE is plain NeoX rotate_half, so a per-row cos/sin cache feeds `vt::RopeFromCache` with no bespoke kernel. **bf16 PRODUCTION stream LANDED, and then upgraded to TRUE bf16 STORAGE**: activations are bf16 buffers and the bf16-stored modules are staged as bf16 weights (fp32 islands preserved), so the tuned shared ops run their native bf16 paths and activation bytes halve. It is also MORE accurate — 6.16e-4 vs 2.41e-3 — because the golden itself used bf16 weights. That also unlocked the refiner's add+RMSNorm fold onto `vt::kFusedAddRmsNormStd`, previously declined because it would have dropped a cast point; with a bf16 residual the add rounds on store, so the fold is byte-identical. REMAINS: `vt::FusedChain` glue folds, merged gate/up seam, and the FP4 path (which needs sm_121a — PROBED 2026-08-03: the warp-level `mma.sync kind::mxf4nvf4` is CONSUMER-Blackwell only, rejected by ptxas on both sm_110a and sm_100a; sm_110 does support the datacenter `tcgen05` family, but our sm_100 body is CUTLASS ArchTag=Sm100 guarded by `__CUDA_ARCH__ == 1000` — so retargeting compiles to a DEAD STUB — and CUTLASS has **zero** sm110 kernels even at v4.6.1, only capability macros. There is no upstream body to port, so Thor can never be the FP4 venue) | — |
+| **W3** | H3-Encoder. **TEXT TOWER DONE** (1.2e-7): the three H3 deltas — layer truncation `min(num_hidden_layers, 50)`, the UNNORMALIZED layer-49 output (no final RMSNorm), and DeepStack injection into the first N layers — plus interleaved M-RoPE, fused QKV, per-head q/k RMSNorm, causal GQA and the gated-SiLU MLP. **VISION BLOCK also DONE** (6.0e-8): LayerNorm-with-bias, the [q_all, k_all, v_all] qkv layout, fp32 rotary, cu_seqlens-segmented NON-CAUSAL attention (boundary isolation asserted), and the TANH-approximate GELU. REMAINS: the vision surround (Conv3d patch embed, learned pos-embed interpolation, 2D rotary table, patch mergers + DeepStack mergers) and the MM processor | — |
+| **W4** | Video VAE. **DECODER DONE** — the full ViT3D decoder gated at 8.9e-8 (block 6.0e-8), real hyperparameters 36 layers / 32 heads x 64 / rope_theta 100 / rope_dim_ratio 0.75 from the checkpoint's `vit_decoder_kwargs`. **TILING also DONE** (plan + seam blend, exact). **3D-CNN ENCODER primitives also DONE** (causal Conv3d with reflect spatial padding, GroupNorm3D, ResnetBlock3D). **DONE — encoder AND decoder both complete.** The 3D-CNN encoder (conv_in, per-level ResnetBlock3D + Downsample3D, norm_out, conv_out) is gated exact; it serves image/video CONDITIONING, which a t2va path does not need | — |
+| **W5** | Audio VAE reimplementation | **DONE** — DAC-lineage BigVGAN decoder (weight-norm materialization, anti-aliased SnakeBeta with kaiser-sinc up/down resampling, replicate padding, final clamp). Encode-side determinism context is still open |
+| **W6** | Pipeline. **t2va ASSEMBLED** — `MiniMaxH3GenerateT2va` wires layout -> sigma schedules -> denoise loop -> unpatchify/audio-unpack -> denormalize -> both VAE decoders, gated by a structural end-to-end test. REMAINS: fl2va/ref2va conditioning (condition noise, reference video, presentation) and bit-exact torch-RNG noise seeding | — |
+| **W7** | Serving. **DONE (CPU)**: PPM frames + WAV + the MP4 mux argv (validated end-to-end against real ffmpeg); the `/v1/videos` request contract and job store (lifecycle, status JSON, thread-safe); and the routes themselves — `POST /v1/videos` (async, joinable worker drained in `~ApiServer`), `POST /v1/videos/sync`, `GET /v1/videos/{id}` — registered ONLY when `set_video_runner` has been called, so a server without video support is byte-identical to before. The runner is a caller-supplied callback precisely because the ffmpeg invocation lives in `examples/` per the developer's ratified decision: `src/vllm/` never spawns a process | W6 |
+| **W8** | Speed: USP sequence parallelism, block caching, DiT TP | W2b + multi-GPU HW |
+| **W9** | **GGUF arm — DONE.** Identity name map, `ne` reversal, the `comfy.gguf.orig_shape` reshape rule, and `LoadMiniMaxH3DitFromGguf` (shared K-quant dequant -> owned f32 -> bound views), gated by the real 535-tensor manifest plus a synthetic-file load-and-run test | — |
+| **W10** | **NVFP4 arm** — `lilcheaty/MiniMax-H3-NVFP4` onto our existing NVFP4 stack (cutlass FP4 GEMM on sm_121). **LOADER DONE** — `LoadMiniMaxH3DitFromNvfp4` reuses the project's existing NVFP4 dequant, so no new quant code. REMAINS: the DEVICE path that keeps FP4 packed and routes projections through the cutlass FP4 GEMM (that is where the speed is), plus a run on the real file | W9 |
+
+**Open items.** (0) Run the assembled t2va path on a REAL quantized checkpoint — the
+pipeline now composes end to end at reduced dimensions, so what remains is loader
+wiring (W9 dequant / W10 NVFP4), the encoder's vision tower, and a GPU. This
+supersedes the old "hardware-blocked" framing. (0b) Noise seeding is currently an
+INPUT: upstream seeds a torch CPU generator, and matching it bit-exactly decides
+WHICH sample you get, not whether the pipeline is correct.
+(a) A vllm-omni parity pin — the upstream-sync protocol currently
+covers only the vLLM repo; H3 lives outside it. (b) The MP4 dependency decision.
+(c) Hardware: nothing past W2b/W3 can be END-TO-END gated on this project's boxes,
+so W4-W8 should be reviewed as structural ports with unit gates, and the honest
+lifecycle cap for this row is "correctness-complete, hardware-blocked".
diff --git a/.agents/state.md b/.agents/state.md
index 4c3604f4b..cc0310030 100644
--- a/.agents/state.md
+++ b/.agents/state.md
@@ -34536,3 +34536,1497 @@ unchanged. A RED-first source regression test pins that ownership boundary.
 This is build portability only and changes no runtime, model lifecycle,
 correctness result, or benchmark disposition. Darwin consumer CI remains the
 binding AppleClang verification.
+
+## 2026-08-03 - MiniMax-H3 W0-W2: first DIFFUSION architecture lands (`CLAIM-MINIMAX-H3-W0-W2`)
+
+**What it is.** `MiniMaxAI/MiniMax-H3` is not a text LLM. It is a 33.1B CFG-distilled
+joint video+audio DIFFUSION transformer served by vLLM-Omni over `/v1/videos`: one
+request runs a 50-step flow-matching denoise loop, forwarding the DiT ONCE PER STEP
+over the whole packed sequence, then decodes latents to 24 FPS frames + 32 kHz stereo
+through two VAEs. No KV cache, no sampler, no logits - the SACRED token-exact
+methodology does not apply, and the model is deliberately NOT registered in the
+causal-LM registry (so the born-on-the-runner seam does not apply either).
+
+**Hardware verdict (settled, not revisitable by software).** ~354 GB checkpoint;
+upstream validates on 4x NVIDIA B300 at ~133 GB peak per rank. One GB10 has 119 GiB
+UNIFIED memory, so CPU offload cannot help (the pool IS host RAM). End-to-end H3 is
+IMPOSSIBLE on this project's hardware. Recorded as such; no e2e claim exists.
+
+**What that leaves, and why it is strong.** vLLM-Omni's H3 implementation is pure
+Python that runs on CPU. So the gate is upstream ITSELF, executed at reduced
+dimensions: `scripts/gen-minimax-h3-goldens.py` imports `packed_sequence.py`,
+`packed_tokens.py` and the scheduler BY FILE PATH (bypassing the package `__init__`,
+which needs neither vllm nor aenum) and restates the DiT at TP=1, then freezes the
+outputs. Both sides rebuild weights and inputs from an identical FNV-1a + splitmix64
+stream, so not one weight byte is checked in. Result: 10/10 cases, 2539 assertions,
+**DiT forward max abs diff 1.6e-7** - f32 round-off, i.e. the algorithm is right.
+
+**Two things worth remembering.**
+1. The FP64 position grid is gated BIT-EXACT because it feeds RoPE. Reproducing it
+   required matching upstream's arithmetic ORDER, not its formulas: numpy's
+   `linspace(endpoint=False)` evaluates `i*step + start`, and upstream keeps a
+   numpy-PAIRWISE span sum and a Python-SEQUENTIAL span sum deliberately separate
+   because they diverge in the last ulp from n=16 (`packed_sequence.py:101-113`).
+2. The two VAEs are **checkpoint REMOTE CODE** loaded via
+   `get_class_from_dynamic_module` under `trust_remote_code` (`vae.py:41-53`).
+   vLLM-Omni only ADAPTS them. A no-Python engine must REIMPLEMENT them in C++ from
+   the checkpoint's own source - that is W4/W5 and it is not a small brick.
+
+**Reuse that paid off.** The packed varlen non-causal attention is exactly the
+contract of our shared `vt::DFlashBlockAttention(causal=false)`, and the H3-Encoder is
+a Qwen3-VL we already ship (layer-50 truncation + DeepStack + all-ones mask). No new
+kernel was added in this change.
+
+**Next.** W2b device-resident/bf16 forward + fusion folds (also where any speed work
+belongs - upstream reports the DiT at 88% of request latency), W3 encoder on the
+existing Qwen3-VL tower, W4/W5 the two VAEs, W6 pipeline/tasks, W7 `/v1/videos` + MP4
+muxing (needs a NEW dependency decision - the tree has no muxer or A/V encoder), W8
+USP multi-GPU. OPEN: there is no vllm-omni parity PIN; the upstream-sync protocol
+covers only the vLLM repo. Spec: `.agents/specs/minimax-h3.md`.
+
+## 2026-08-03 - MiniMax-H3 W6A/W9 + I had the hardware verdict WRONG (`CLAIM-MINIMAX-H3-W6A-W9`)
+
+**The correction first.** The previous entry concluded H3 end-to-end was
+"IMPOSSIBLE on this project's hardware". That was wrong, and the error was
+reasoning from ONE artifact: the BF16 release (~354 GB, 4x B300). The user pointed
+at quantized checkpoints and they change the verdict outright:
+
+  * `realrebelai/MiniMax-H3_GGUFs` - DiT `MiniMax-H3-FL2VA-Q3_K_M.gguf` 15.6 GB,
+    Qwen3-VL encoder `qwen3vl-32B-...-Q4_K_M.gguf` 14.6 GB, VAEs ~11 GB from the
+    Comfy-Org base repo => a **~41 GB working set** in a 119 GiB pool.
+  * `lilcheaty/MiniMax-H3-NVFP4` - NVFP4 DiT variants + an AWQ Qwen3-VL encoder +
+    BOTH VAEs, also a fit.
+
+So e2e AND a speed comparison are REACHABLE; they are gated on the remaining
+bricks, not on hardware. **Lesson worth keeping: a size-based "does not fit"
+verdict is only as good as the artifact list it was computed over - enumerate the
+QUANTIZED community releases before declaring a model out of reach.**
+
+**What landed.**
+1. The DiT forward now runs the **bf16 production dtype policy** as well as f32:
+   upstream's cast points with the fp32 islands (both patch projections, the time
+   embedder, both output heads) preserved. Gated against a bf16 upstream golden at
+   max abs diff 2.4e-3 - bf16 scale, same cast points, different GEMM accumulation.
+2. **Request planning** (`minimax_h3_planner.cpp`): 17n+5 frame snapping, video and
+   audio latent shapes, the rectified-flow time-shift sigma schedule, canvas
+   resolution, reference-image rescale, and t2va/fl2va/ref2va dispatch. All EXACT.
+   Watch out for Python's banker's rounding - `round()` is half-to-even and both
+   `_align_multiple` and `_audio_latent_t` depend on it.
+3. The **ComfyUI-GGUF arm**. The best news in this change: **the name map is the
+   IDENTITY.** Every one of the 535 tensors in the real Q3_K_M DiT matches the
+   contract `EnumerateMiniMaxH3DitTensors` derived from upstream SOURCE - the
+   weight contract is now validated against a real checkpoint. Two shape rules:
+   GGUF `ne` is reversed vs torch, and `comfy.gguf.orig_shape.<name>` overrides it
+   where ComfyUI reshaped for quant-block alignment (the 50 AdaLN projections:
+   logical [96768, 2688], and 2688 is not a multiple of the 256-element Q3_K block).
+   Geometry is derived from SHAPES ALONE, because a ComfyUI GGUF ships no config.
+
+**Method note worth reusing:** the GGUF gate needed no download. The header is at
+the front of the file and self-delimiting, so a 4 MiB HTTP range request yields the
+whole 535-tensor manifest, which `scripts/gen-minimax-h3-gguf-manifest.py` freezes
+into a fixture. Real-checkpoint grounding for the cost of one curl.
+
+**Next.** Download a quantized checkpoint and close the e2e loop (encoder on our
+Qwen3-VL tower -> the two VAEs -> pipeline), then the NVFP4 arm (W10) for speed -
+sm_121 has native FP4 tensor cores and our NVFP4 stack is the most tuned one we own.
+
+## 2026-08-03 - MiniMax-H3 W5: the audio VAE is reimplemented (`CLAIM-MINIMAX-H3-W5`)
+
+**The blocker I flagged is half-resolved.** H3's two VAEs ship as checkpoint REMOTE
+CODE and vLLM-Omni only adapts them, so a no-Python engine has to reimplement them.
+That was the biggest unknown in the lane. The remote code is now IN HAND (~130 KB
+of Python fetched from `FL2VA/{audio,video}_vae/`; NOT vendored - it ships under the
+MiniMax H3 Community License), and the AUDIO side is done.
+
+**What it is.** A DAC-lineage BigVGAN vocoder: `dec_in_proj` (32 -> 2048, k=1) then
+conv_pre -> 7 upsample stages (ConvTranspose1d, rates 5,5,2,2,2,2,2 / kernels
+9,9,4,4,4,4,4), each followed by 3 AMPBlock1 residual stacks (kernels 3,7,11,
+dilations 1,3,5) whose outputs are AVERAGED -> anti-aliased SnakeBeta -> conv_post
+-> clamp[-1,1]. 32 kHz stereo.
+
+**Two things that would have been easy to get wrong, both now gated:**
+1. Every conv is WEIGHT-NORMALIZED, so the checkpoint stores (g, v) pairs as
+   `parametrizations.weight.original0/original1` and the loader must materialize
+   `g * v / norm(v)` with the norm over every dim except dim 0. Note ConvTranspose1d
+   weight is [in, out, k], so its weight-norm dim 0 is the INPUT channel.
+2. The anti-aliased activation is up 2x -> SnakeBeta -> down 2x through a
+   KAISER-SINC filter that is COMPUTED at load time, never loaded. It needs a
+   Bessel I0, torch's periodic=false kaiser window, and REPLICATE padding. The
+   filter is gated separately (3.0e-8) so a filter bug cannot masquerade as a
+   decoder bug.
+
+**Result: waveform max abs diff 4.2e-9** vs the checkpoint's own modules - f32
+round-off. One methodology note: the first golden had 18 of 32 samples pinned at the
+final clamp, which would have HIDDEN errors, so the generator's weight scale was
+tuned down until the output was fully unsaturated, and the test now asserts
+non-saturation explicitly.
+
+**Next.** The VIDEO VAE (W4) is the largest remaining brick - `klvae.py` alone is
+~48 KB, plus a CNN/ViT hybrid, tiling, and a parallel path. Then the encoder (W3,
+mostly reuse of our Qwen3-VL tower) and the pipeline (W6), after which an
+end-to-end run on a quantized checkpoint is reachable.
+
+## 2026-08-03 - MiniMax-H3: NVFP4 arm grounded, video VAE scoped (`CLAIM-MINIMAX-H3-W10-SCOPE`)
+
+Two de-risking results, both obtained from REAL checkpoints without downloading a
+byte of payload. Generalized the GGUF header trick: a **safetensors header is also
+front-loaded** (8-byte length + JSON) and only tens of KB even for a 10 GB file, so
+one range request captures the entire manifest
+(`scripts/gen-minimax-h3-safetensors-manifest.py`).
+
+**1. The NVFP4 checkpoint is our layout, exactly.** `lilcheaty/MiniMax-H3-NVFP4`
+(1051 tensors) is the textbook compressed-tensors triple:
+  weight          U8       FP4 packed 2-per-byte  ([21504, 2688] for logical [21504, 5376])
+  weight_scale    F8_E4M3  one per group of **16** along K  ([21504, 336])
+  weight_scale_2  F32      one global scalar
+258 quantized projections, each with all three; the fp32/bf16 islands (patch
+projections, time embedder, output heads, norms, rope) are left unquantized; and the
+names are IDENTICAL to the contract we derived from source. **So W10 is loader
+WIRING onto the NVFP4 stack we already tuned for Laguna, not a new quant scheme.**
+That matters because W10 is the speed path: sm_121 has native FP4 tensor cores.
+
+**2. The video VAE decoder is a ViT, not a CNN.** I had scoped W4 as "port a 48 KB
+klvae.py" and treated it as the scary brick. The real 560-tensor manifest says
+otherwise: the ENCODER is the 3D CNN (116 tensors, rank-5 Conv3d down blocks), but
+the DECODER — the only half generation needs — is a **36-block transformer** (440
+tensors: attn.to_qkv/to_out, ff.w1/w2, two norms and two learned residual scales per
+block, plus x_embedder, mask_token, register_tokens, norm_out, proj_out). fp32
+throughout. We have every primitive for that.
+
+**Method note (now used three times, worth keeping):** read the checkpoint's HEADER,
+not the checkpoint. GGUF and safetensors both front-load a self-delimiting manifest;
+a 4-16 MiB range request grounds a loader contract against a real multi-GB file. It
+has now caught/confirmed the identity name map twice and correctly re-scoped a brick
+I had over-estimated.
+
+**Next.** W4 video-VAE decoder (a ViT port), W3 encoder (Qwen3-VL reuse), W6
+pipeline; then W10 loader wiring, after which an e2e run on a quantized checkpoint —
+and only then a speed number — is reachable.
+
+## 2026-08-03 - MiniMax-H3 W4 (partial): the video-VAE decoder block is ported
+
+The repeated unit of the 36-block ViT decoder now matches the checkpoint's own
+remote code at **6.0e-8**. Structure per block (all fp32):
+  h += scale1 * Attention(RMSNorm(h))
+  h += scale2 * GatedSiLU_FeedForward(RMSNorm(h))
+with `scale1`/`scale2` LEARNED PER-CHANNEL vectors (not scalars), and per-head RMS
+q/k normalization with NO affine weight.
+
+**The trap this caught, and it would have been nasty:** this ViT's `to_qkv` output
+is PER-HEAD INTERLEAVED. Upstream does `qkv.view(B, S, -1, 3*dim_head)` then
+`chunk(3, dim=-1)`, so the layout is [head0_q | head0_k | head0_v | head1_q | ...]
+— NOT the [q_all | k_all | v_all] the H3 DiT's fused qkv uses. The two are the same
+SIZE, so reading it the DiT way produces no error, no shape mismatch, and a
+plausible-but-wrong image. Only a numeric gate against the real module catches it.
+
+**Tooling note:** the bundle imports a few diffusers symbols (a logger, two mixin
+bases, two no-op decorators). The generator STUBS them rather than pulling the whole
+diffusers dependency in just to run an oracle - cheaper and more reproducible.
+
+**Remains for W4:** the stack surround - `x_embedder`, `mask_token`/`register_tokens`,
+3D RoPE, `norm_out`/`proj_out`, unpatchify, and tiling - plus the 3D-CNN encoder
+(only needed for image/video CONDITIONING, not for generation output).
+
+## 2026-08-03 - MiniMax-H3 W4: the video-VAE ViT3D decoder is complete
+
+Both VAE DECODERS are now done. The video VAE's full ViT3D decoder reproduces the
+checkpoint's own `ViT3DDecoder` at **8.9e-8** (the block alone was 6.0e-8), at its
+REAL hyperparameters read from `source/config.json::vit_decoder_kwargs`: 36 layers,
+32 heads x 64, rms_norm affine, qk rms_norm WITHOUT affine, gated SiLU,
+rope_theta 100.0, rope_dim_ratio 0.75.
+
+The surround, all now ported: `_pack_tensors_3d` (channels-last flatten),
+`x_embedder`, a suffix of register tokens plus a ZERO cls token, 3D RoPE, the block
+stack, a LayerNorm `norm_out` (note: LAYER norm, while the blocks use RMS),
+`proj_out`, and `_unpack_tensors_3d` back to [C, T*pt, H*ps, W*ps].
+
+**3D RoPE detail worth keeping:** RotaryEmbeddingND builds angles from
+LENGTH-NORMALIZED token ids ((i+0.5)/n mapped to [-1,1)), multiplies by an angle
+scale of 2*pi (use_angle=True), and concatenates the three per-axis frequency blocks
+then TILES the result twice to fill rot_dim. The suffix tokens carry id 0, so their
+cos/sin are 1/0 - i.e. identity - which falls out of initializing the tables that way.
+
+**What remains on the VAE side:** video tiling (vae_tile_size 256, overlap 64) and
+the 3D-CNN ENCODER. The encoder matters only for image/video CONDITIONING
+(fl2va/ref2va), NOT for producing output frames, so a t2va path does not need it.
+
+**Next:** W3 (the H3-Encoder on our Qwen3-VL tower) and W6 (pipeline) are what stand
+between here and an end-to-end t2va run on a quantized checkpoint.
+
+## 2026-08-03 - MiniMax-H3 W3 (partial): the encoder TEXT tower is ported
+
+The H3-Encoder's text tower - which produces the [seq, 5120] prompt_embeds the DiT
+consumes - now matches upstream at **1.2e-7**, on both the plain and the DeepStack
+paths.
+
+Its ARCHITECTURE is a Qwen3-VL, which this project already ports, so the value here
+is pinning the three H3-specific deltas:
+  1. LAYER TRUNCATION: num_layers = min(config.num_hidden_layers, 50). The gate's
+     config deliberately declares MORE layers than are selected so this is actually
+     exercised, and a second assertion checks truncation never EXTENDS a shallower
+     model.
+  2. UNNORMALIZED OUTPUT - the load-bearing one. H3 consumes the hidden state
+     straight out of layer 49 with NO final RMSNorm, unlike a stock Qwen3-VL text
+     model. Applying one produces no error and no shape change; it just silently
+     shifts every conditioning vector.
+  3. DEEPSTACK: visual features added at the visual token positions after each of
+     the first len(deepstack_visual_embeds) layers. The test asserts DeepStack
+     actually CHANGES the result, so a no-op injection cannot pass.
+
+**Oracle note:** encoder.py imports exactly one vllm symbol (`vllm.logger`), so a
+one-line stub lets it run without vllm or any of its dependencies. Same pattern as
+the diffusers stub for the video VAE.
+
+**Remains for W3:** the VISION tower (a reuse of our `qwen3_vl_vision.cpp` rather
+than a new port) and the MM processor.
+
+**State of the lane:** DiT, scheduler, layout, request planning, both VAE decoders,
+and now the encoder text tower are all ported and gated. W6 (pipeline assembly) is
+the main thing standing between here and an end-to-end t2va run.
+
+## 2026-08-03 - MiniMax-H3 W6: the whole t2va path composes end to end
+
+`MiniMaxH3GenerateT2va` now wires the separately-gated stages into one path:
+
+  prompt_embeds -> packed layout -> sigma schedules (video shift 12, audio 3)
+                -> denoise loop (DiT forward per step, euler-eta0 update)
+                -> unpatchify / audio unpack -> per-channel denormalize
+                -> video ViT3D decoder + audio BigVGAN decoder
+                -> frames [3, T*pt, H*ps, W*ps] + stereo waveform at 32 kHz
+
+A structural end-to-end test runs it at reduced dimensions with random weights.
+That is explicitly NOT a quality result - it is proof the stages COMPOSE: shapes
+are right, everything is finite, the waveform lands inside [-1, 1], and the denoise
+loop demonstrably moves the latents rather than passing noise through.
+
+**Assembling it caught a real gap**, which is exactly why assembly is worth doing
+before the checkpoint arrives: the audio decode was missing the checkpoint's
+`dec_in_proj` (Conv1d k=1 from vae_latent_channels to num_mels) ahead of BigVGAN.
+The DiT emits a 32-wide audio latent and BigVGAN expects 2048 mels; without that
+projection the two never meet. Now applied when the weight is present, leaving the
+standalone BigVGAN gate untouched.
+
+**Deliberate design note:** noise is an INPUT, not generated internally. Upstream
+seeds a torch CPU generator; reproducing torch's RNG bit-exactly decides WHICH
+sample you get, not whether the pipeline is correct, so it is recorded as an open
+item rather than guessed at.
+
+**What now stands between this and a real generation:** the encoder's VISION tower
+(reuse of qwen3_vl_vision.cpp) and MM processor, fl2va/ref2va conditioning, the
+quantized loader wiring (GGUF dequant / NVFP4), and a GPU with the checkpoint on it.
+The device-resident forward (W2b) and NVFP4 wiring (W10) are where speed work then
+begins.
+
+## 2026-08-03 - MiniMax-H3 W9: the GGUF arm is complete (load -> runnable DiT)
+
+`LoadMiniMaxH3DitFromGguf` closes the GGUF arm. It resolves the manifest (identity
+name map, `ne` reversal, the `comfy.gguf.orig_shape` reshape rule), derives the
+geometry from SHAPES alone - a ComfyUI GGUF ships no transformer config - and
+dequantizes every tensor through the SHARED `DequantGgufRowToF32`, so the
+Q2_K/Q3_K/Q4_K families the H3 GGUFs use are covered by the same code path every
+other GGUF model in this tree uses. No new quant code.
+
+Gated by a synthetic-file **load-and-run** test rather than a shape check: the
+geometry comes back exactly, a loaded weight carries the LOGICAL (torch) shape
+rather than the reversed ne, and a REAL DiT forward executes off the loaded weights
+with finite, correctly-sized outputs. Missing tensors throw BY NAME instead of
+yielding a null view the forward would silently read as zeros.
+
+**Environment note:** dgx.casa is currently UNREACHABLE ("no route to host"), and
+this workstation has no GPU at all. So no run on a real checkpoint - and therefore
+no speed number - is possible from here regardless of how much of the port is done.
+
+**What remains before a real generation:** the encoder's VISION tower (reuse of
+qwen3_vl_vision.cpp) + MM processor, fl2va/ref2va conditioning, NVFP4 loader wiring
+(W10 - the layout is already proven identical to ours), and a machine with a GPU.
+W2b (device-resident forward) and W10 are where speed work then begins.
+
+## 2026-08-03 - MiniMax-H3 W10 loader: both quantized arms now load
+
+`LoadMiniMaxH3DitFromNvfp4` completes the loader half of the NVFP4 arm. The
+compressed-tensors triple (U8-packed [out, in/2] + E4M3 group-16 weight_scale + F32
+scalar weight_scale_2) goes through the project's EXISTING `DequantNvfp4ToBf16` -
+no new quant code, because the manifest gate had already proven the checkpoint's
+layout IS ours. Quant sidecars are excluded from the model tensor set, and the
+geometry is recovered from the dequantized shapes.
+
+The view binding is now SHARED between the GGUF and NVFP4 arms
+(`BindMiniMaxH3DitViews`) since both land on the same weight contract.
+
+**A mistake worth recording.** Extracting that shared binder, I applied a blind
+`out.` -> `out->` rewrite, which corrupted six tensor NAME STRINGS -
+"time_embedder.proj_out.bias" became "...proj_out->bias". Two lessons: (1) never
+mechanically rewrite across code and string literals in one pass; (2) the loader's
+throw-BY-NAME-on-missing-tensor design caught it instantly, where a null-view
+default would have silently bound zeros and produced a plausible-but-wrong forward.
+That design choice paid for itself the first time it was exercised.
+
+**Where the lane stands.** Ported and gated: DiT forward (f32 + bf16), packed
+layout, scheduler, request planning, denoise loop, BOTH VAE decoders, the encoder
+text tower, the assembled t2va pipeline, and BOTH quantized loaders.
+
+**Remaining:** the encoder's VISION tower (reuse of qwen3_vl_vision.cpp) + MM
+processor, fl2va/ref2va conditioning, video tiling, /v1/videos + MP4 muxing (needs a
+dependency decision), and the DEVICE-resident forward - which is where speed work
+actually begins, since the reference forward is CPU and deliberately unoptimized.
+
+**Environment:** dgx.casa unreachable, no local GPU. No run on a real checkpoint and
+no speed number is possible from this machine.
+
+## 2026-08-03 - MiniMax-H3 W3 vision block: both encoder towers' cores are ported
+
+The encoder's vision-tower block now matches upstream at **6.0e-8**, so both towers'
+repeated units are done (text tower was 1.2e-7).
+
+**The two ViTs in this model disagree on qkv layout, and that is the trap.** The
+VIDEO VAE decoder's ViT is PER-HEAD INTERLEAVED ([head][q,k,v]); this VISION tower
+is [q_all|k_all|v_all]. Same tensor size, no error either way - just a wrong result.
+Having ported both, it is worth stating plainly: never assume a qkv layout carries
+across ViTs inside one checkpoint; read the reshape/permute in the source each time.
+
+Other deltas from the text tower, all exercised: LayerNorm WITH BIAS rather than
+RMSNorm, fp32 rotary, and the TANH-approximate GELU rather than exact erf.
+
+The attention is `cu_seqlens`-segmented, and the test proves the isolation rather
+than assuming it: perturbing a token in the second packed image leaves every output
+of the first BIT-IDENTICAL, while the second's outputs do change. A segmentation bug
+would otherwise pass a tolerance check.
+
+**Remaining for the encoder:** the vision surround (Conv3d patch embed, learned
+pos-embed interpolation, the 2D rotary table, patch + DeepStack mergers) and the MM
+processor.
+
+## 2026-08-03 - MiniMax-H3 W3 COMPLETE: the encoder is ported
+
+The full vision tower lands, so both encoder towers are done end to end. Gated over
+a RAGGED two-image batch (different h/w), which is what actually exercises the
+position-embedding interpolation and the per-frame cu_seqlens: merged output and
+DeepStack features are both within 1e-4 of upstream.
+
+Details that were load-bearing and are now pinned:
+  * the patch embed's Conv3d has kernel == stride, so it is a plain linear over
+    the flattened patch - no sliding window;
+  * `torch.linspace(0, n-1, 1)` returns the START, not the end (the single-row
+    grid case);
+  * `.int()` TRUNCATES when picking the bilinear corners, it does not round;
+  * the two merger flavours differ - the FINAL merger norms the PRE-shuffle width
+    while the DEEPSTACK mergers norm the POST-shuffle width, and both use
+    exact-erf GELU rather than the block MLP's tanh approximation. Three different
+    GELU/norm conventions inside one encoder.
+
+**Encoder status: complete apart from the MM processor** (image/video preprocessing
+into patches), which is input plumbing rather than model math.
+
+**Lane status.** Ported and gated: DiT forward (f32 + bf16), packed layout,
+scheduler, request planning, denoise loop, both VAE decoders, BOTH encoder towers,
+the assembled t2va pipeline, and BOTH quantized loaders.
+
+**Remaining:** MM processor, fl2va/ref2va conditioning, video tiling, /v1/videos +
+MP4 muxing (blocked on a dependency decision), and the DEVICE-resident forward -
+which is where speed work begins and which needs a GPU to be worth doing.
+
+## 2026-08-03 - MiniMax-H3: condition-noise augmentation (fl2va/ref2va anchors)
+
+fl2va and ref2va pin their keyframe and reference-audio rows to a NOISED anchor
+rather than the clean latent. The mix itself is one line; the reason this needed a
+gate is the ROW ACCOUNTING around it, all three parts of which are easy to get
+subtly wrong and none of which would raise an error:
+
+  * each visual condition draws noise of length
+    `target_latent_t + imgvid_cond_num_frames` and slices the PREFIX matching its
+    own latent_t - a shorter condition does NOT get a shorter draw;
+  * every condition RESTARTS the same seed, so concatenating all conditions and
+    drawing once would be numerically different for multi-reference requests;
+  * rows advance by that condition's own patchified row count.
+
+Gated exact (<= 1e-6) with the noise SUPPLIED, so the comparison isolates the
+accounting from torch's RNG. That keeps the RNG a single tracked open item rather
+than smearing it across every conditioning path.
+
+Tooling note: `condition_noise.py` uses a RELATIVE import, so the golden generator's
+by-path loader now registers a synthetic package whose __path__ is the upstream
+directory - still bypassing the real vllm_omni __init__ (which would drag in vllm
+and aenum) while letting relative imports resolve.
+
+**Remaining in the lane:** MM processor, reference_video/presentation conditioning,
+video tiling, /v1/videos + MP4 muxing (blocked on a dependency decision), and the
+device-resident forward.
+
+## 2026-08-03 - MiniMax-H3: reference-video geometry + frame schedule
+
+The pure-math half of `reference_video.py` is ported and exact: the canvas pipeline
+(aspect clamp -> 768 short edge -> max-pixel rescale -> nearest multiple of 32) and
+the frame schedule (24 FPS resampled to the 2 FPS Qwen rate, duplicates dropped,
+timestamps averaged per temporal patch with the tail padded by repeating the last).
+
+**A test-authoring lesson.** I added an extra invariant of my own -- "the snapped
+canvas respects the max-pixel budget" -- and it FAILED on 3840x1080 (1920x544 =
+1,044,480 > 1,032,192). The port was right; MY invariant was wrong. Upstream applies
+the budget BEFORE snapping to 32 and never re-checks. I corrected the test rather
+than the port. Worth remembering: when a self-invented invariant fails, check
+whether the REFERENCE actually holds it before touching the implementation.
+
+**DEPENDENCY BOUNDARY, now explicit.** The rest of reference_video.py -- probe,
+transcode, frame extraction, audio decode -- shells out to ffmpeg/soundfile. That is
+the SAME blocker as /v1/videos MP4 muxing: **one dependency decision unlocks
+reference-video INPUT decode and generated-video OUTPUT encode together.** This is
+the single item in the lane that needs a project decision rather than more porting.
+
+**Remaining:** MM processor, presentation.py (ref2va prompt assembly), video tiling,
+the ffmpeg-dependent media I/O above, and the device-resident forward.
+
+## 2026-08-03 - MiniMax-H3: video-VAE spatial tiling
+
+The tile plan and seam blend are ported and exact, so the video VAE side is
+complete for GENERATION (only the 3D-CNN encoder remains, and that is needed for
+image/video CONDITIONING, not for producing output frames).
+
+The plan is not a simple stride, which is the whole reason it needed a gate: it
+takes the SMALLEST tile count whose MINIMUM overlaps still cover the axis, then
+distributes the leftover slack in whole vae_ratio units ROUND-ROBIN across the
+seams. Get that distribution wrong and every tile after the first shifts - which
+surfaces as seam artifacts in the output, not as an error anywhere.
+
+Shipped config: tile 256, overlap_min 64, vae_ratio 16 (= prod(space_down)
+[2,2,2,2,1,1] - the "f16" in f16t4; vae_ratio_t = 4 is the "t4").
+
+**Lane status.** Ported and gated: DiT (f32 + bf16), packed layout, scheduler,
+request planning, denoise loop, BOTH VAE decoders + tiling, BOTH encoder towers,
+condition-noise anchors, reference-video geometry/schedule, the assembled t2va
+pipeline, and BOTH quantized loaders.
+
+**Remaining, and each is now blocked on something specific rather than on effort:**
+  * MM processor + presentation.py - portable, still to do;
+  * the VAE's 3D-CNN encoder - portable, conditioning-only;
+  * media I/O (ffmpeg) and MP4 muxing - ONE dependency decision, needs the project owner;
+  * device-resident FP4 forward and any speed number - needs a GPU (dgx.casa is
+    unreachable; this workstation has none).
+
+## 2026-08-03 - MiniMax-H3: presentation token tags (fl2va vision-span override)
+
+This closes a gap I had explicitly flagged when porting the denoise loop: its
+contract says "token_tags must already carry any fl2va vision-span overrides", and
+nothing in the port produced them. Now it does.
+
+**The load-bearing detail:** a vision block is
+`<|vision_start|> + pad*count + <|vision_end|>`, and the WHOLE block - markers
+included - is tagged VIDEO(0). Tagging only the pads leaves two markers as TEXT(1)
+and shifts every AdaLN modulation index after them. No error, no shape change, just
+wrong modulation for the rest of the sequence. The test proves each VIDEO run in the
+output equals a whole emitted vision span, so an off-by-two cannot pass.
+
+Tokenization deliberately stays with the CALLER (it owns the tokenizer); this owns
+the span -> tag mapping, which is the part that has to agree with the packed layout.
+The gate drives upstream with a stub tokenizer, since only span LENGTHS affect tags.
+
+**Remaining in the lane:** the MM processor and the VAE's 3D-CNN encoder (both
+portable, conditioning-side); ffmpeg media I/O + MP4 muxing (ONE dependency
+decision, needs the project owner); and the device-resident FP4 forward plus any
+speed number (needs a GPU - dgx.casa unreachable, none local).
+
+## 2026-08-03 - MiniMax-H3: video-VAE 3D-CNN encoder primitives
+
+Causal Conv3d, GroupNorm3D and ResnetBlock3D are ported and exact. These serve the
+video VAE's ENCODER, which is used for image/video CONDITIONING (fl2va keyframes,
+ref2va references) - a t2va generation path does not need it.
+
+Two details pinned by the gate:
+  * the convolution is CAUSAL in time: `padding[0] * 2` frames on the LEFT, none
+    on the right, with CONSTANT (zero) temporal padding and `reflect` SPATIAL
+    padding. A symmetric temporal pad would let a frame see the future.
+  * GroupNorm's statistics span TIME as well as space (32 groups, eps 1e-6), so a
+    per-frame normalization would silently differ.
+
+**Causality is PROVEN, not assumed.** On the bare convolution, changing the last
+frame leaves earlier frames BIT-IDENTICAL while the last frame's own output moves.
+At block level GroupNorm mixes across time, so exact equality would be the wrong
+assertion there; the weaker claim (the perturbed frame moves strictly more than the
+first) is asserted instead, with the strict proof done where it is actually valid.
+Worth remembering as a test-design pattern: assert the strong invariant at the
+layer that holds it, not at the layer where a legitimate mixing step breaks it.
+
+**Remaining:** the encoder's Downsample3D + EncoderFCN3D assembly, the MM
+processor, ffmpeg media I/O + MP4 muxing (ONE dependency decision), and the
+device-resident FP4 forward plus any speed number (needs a GPU).
+
+## 2026-08-03 - MiniMax-H3: video-VAE Downsample3D
+
+The strided inter-level convolution is ported and exact, and the shared causal
+Conv3d now carries stride. Only the EncoderFCN3D level-loop assembly remains on the
+VAE encoder (and the encoder is conditioning-only - a t2va path does not use it).
+
+**The subtlety:** when the spatial stride is 2 the input is padded by ONE pixel on
+the RIGHT of W and the BOTTOM of H before a stride-2 conv with padding (1, 0, 0).
+That asymmetric pre-pad is what keeps the sampling lattice aligned; padding
+symmetrically instead shifts everything by half a pixel - a silent wrong latent, not
+an error anywhere.
+
+**Housekeeping:** a clean-rebuild hit ENOSPC partway through - about fifteen
+throwaway build trees at ~4.7 GB each had accumulated over this session. Removed
+them (71 GB free again) and re-verified from scratch. Worth doing at the END of any
+long session that rebuilds repeatedly.
+
+## 2026-08-03 - MiniMax-H3: the video VAE is COMPLETE (encoder + decoder)
+
+The 3D-CNN encoder level loop lands, so both halves of the video VAE are ported and
+gated. The channel plan is the fiddly part and is now pinned:
+`block_mid[i] = ch*ch_mult[i]`, `block_in[0] = block_mid[0]`,
+`block_in[i>0] = block_mid[i-1]`; a level gets a Downsample3D when
+`space_down[i]*time_down[i] > 1`, otherwise a 1x1x1 conv ONLY if its channel count
+changes, and nothing at all when it does not.
+
+**The failure was mine, in the TEST, not the port.** The first run mismatched at
+2.25 with correct shapes. Cause: the generator's scale rule tested `".norm" in name`,
+which silently misses `norm_out.weight` (no leading dot), so generator and test
+seeded that group-norm gain differently. Rule corrected to `"norm" in name`; the
+port needed no change. Same lesson as the reference-video invariant earlier -- when
+a gate fails, establish WHICH side is wrong before touching the implementation. Two
+for two this session, the fixture was at fault.
+
+**Remaining in the lane:** the MM processor (portable); ffmpeg media I/O + MP4
+muxing (ONE dependency decision, needs the project owner); and the device-resident
+FP4 forward plus any speed number (needs a GPU - dgx.casa unreachable, none local).
+
+## 2026-08-03 - MiniMax-H3: MM processor is reuse; ALL PORTABLE WORK IS DONE
+
+H3's FL2VA/processor is a stock Qwen3VLProcessor, so the multimodal front end is
+REUSE of the Qwen3-VL processor this project already ships. What needed proving -
+and is now gated - is that H3's ACTUAL config parses and drives it: patch 16 /
+temporal 2 / merge 2, and notably **image_mean/std 0.5 rather than the usual CLIP
+statistics**, so H3 normalizes to [-1, 1]. The 768x1344 default canvas is proven an
+IDENTITY under smart_resize (resizing it would silently change the conditioning
+image), and H3's VIDEO bounds are asserted looser than its image bounds both ways.
+
+**This closes the last portable item.** Everything outstanding is blocked on
+something that is NOT more porting:
+  1. ffmpeg media I/O + MP4 muxing - ONE dependency decision, belongs to the project
+     owner; it unblocks reference-video INPUT decode and generated-video OUTPUT
+     encode together.
+  2. the device-resident FP4 forward, and therefore ANY speed number - needs a GPU.
+     dgx.casa is unreachable and this workstation has none. The reference forward is
+     deliberately CPU and unoptimized, so the speed work IS that brick.
+
+While updating STATUS I found a sentence that had drifted into self-contradiction
+across successive edits ("the video VAE is COMPLETE ... the 3D-CNN VAE encoder ...
+remain"). Restated it. Worth watching for on any long-running lane: repeated
+in-place edits to a summary line accumulate damage that no checker catches, because
+it is prose rather than structure.
+
+**Final lane state.** Gated against upstream, the checkpoint's own remote code, or
+real checkpoint headers, with no weight bytes checked in: DiT forward (f32 + bf16),
+packed layout, scheduler, request planning, denoise loop, the video VAE COMPLETE
+(ViT3D decoder + 3D-CNN encoder + tiling), the audio VAE decoder, the encoder
+COMPLETE (text + vision towers + MM processor), BOTH quantized loaders (GGUF,
+NVFP4), fl2va/ref2va anchor conditioning, reference-video math, presentation token
+tags, and the assembled t2va pipeline.
+
+## 2026-08-03 - MiniMax-H3: WAV output, and the muxer decision stays open
+
+The decoded stereo waveform now serializes to RIFF/WAVE 16-bit PCM, converting the
+audio VAE's CHANNEL-MAJOR layout to INTERLEAVED (getting that backwards yields audio
+that plays but with the channels time-smeared into each other) and clamping rather
+than wrapping at full scale.
+
+**Why this and not the muxer.** I re-examined my own "blocked on a dependency
+decision" claim, since the project's PRIME POLICY is to mirror upstream rather than
+ask, and upstream vLLM-Omni simply shells out to `ffmpeg` (which IS present on this
+box, 6.1.1). But the relevant asymmetry is that vLLM-Omni is a Python SERVING layer
+while vllm.cpp is a LIBRARY, and `src/vllm/` has NO subprocess precedent anywhere. A
+library that forks a process is a real architectural commitment (PATH dependence,
+sandboxing, process lifetime) - not the same class of choice as a server script
+calling ffmpeg. So the decision stays with the project owner, and a plausible
+resolution to offer is: put any ffmpeg invocation in the EXAMPLE/SERVER layer, not
+the core library.
+
+WAV sidesteps all of it: 44-byte header plus samples, no dependency, and needed
+under either outcome (a muxer consumes PCM; a standalone audio artifact is useful
+regardless).
+
+**Lane state unchanged otherwise.** Every portable piece is done. The two open items
+remain (a) the muxer/media-I/O decision and (b) the device-resident FP4 forward and
+any speed number, which need a GPU that is not reachable.
+
+## 2026-08-03 - USER DIRECTIVE: pause all GPU-requiring MiniMax-H3 work
+
+The developer flagged that **dgx.casa may already be busy with other GPU work** and
+directed: **pause if we need a GPU.** Recording it so a later session does not
+casually pick the GPU bricks back up and contend for the box.
+
+**PAUSED (needs a GPU, do NOT start without checking with the developer first):**
+  * the device-resident FP4 forward (W2b/W10b) - the actual speed work;
+  * any e2e t2va run on a real quantized checkpoint;
+  * therefore ANY speed number vs vLLM-Omni.
+
+Per the project's GPU-contention rule, a benchmark is only valid on an uncontended
+box, so attempting these while dgx.casa is busy would produce void numbers anyway -
+the pause is the correct call on measurement grounds as well as courtesy.
+
+**NOT paused (CPU-only, still open):** the ffmpeg media-I/O + MP4 muxer DEPENDENCY
+DECISION, which is a project-owner call rather than GPU work. A plausible resolution
+to offer: put any ffmpeg invocation in the EXAMPLE/SERVER layer rather than the core
+library, since `src/vllm/` has no subprocess precedent.
+
+**State at pause.** Every PORTABLE piece of the lane is ported and gated on CPU:
+DiT forward (f32 + bf16), packed layout, scheduler, request planning, denoise loop,
+the video VAE COMPLETE (ViT3D decoder + 3D-CNN encoder + tiling), the audio VAE
+decoder + WAV output, the encoder COMPLETE (text tower + vision tower + MM
+processor), BOTH quantized loaders (GGUF, NVFP4), fl2va/ref2va anchor conditioning,
+reference-video math, presentation token tags, and the assembled t2va pipeline.
+33/33 test cases, 9207 assertions, no weight bytes checked in.
+
+## 2026-08-03 - MiniMax-H3: video output path done (and validated against real ffmpeg)
+
+The output path is complete: PPM frame serialization + WAV audio + the MP4 mux argv.
+
+**Resolved the dependency question without over-committing.** I had escalated "how
+does this project get a muxer" as a project-owner decision. The resolution actually
+follows from the tree's own shape: the LIBRARY builds the artifacts and the command
+but never spawns a process (`src/vllm/` has no subprocess precedent, and a forking
+library is a different commitment from a Python serving layer that shells out); the
+example/SERVER layer performs the invocation. That mirrors upstream's behaviour while
+keeping the library dependency-free, and it makes both halves unit-testable.
+
+**Validated end to end against real ffmpeg 6.1.1**: the exact argv the library builds
+was run over PPM+WAV written in this project's own formats and produced a VALID MP4 —
+ffprobe confirms h264/yuv420p video plus AAC stereo at 32 kHz. So the command is not
+merely plausible; it works.
+
+Details pinned by the gates: PPM converts PLANAR [C,T,H,W] to row-major INTERLEAVED
+RGB ([-1,1] -> [0,255], clamped); the argv carries yuv420p so every player accepts
+it, `-shortest` so no trailing silence or orphan video leaks in, and `+faststart` so
+the moov atom leads and the file streams; a SILENT clip omits the audio codec and
+`-shortest` entirely.
+
+**What is left in the lane** is now only: the server wiring itself (`/v1/videos`,
+`/v1/videos/sync`, job store) and the GPU-blocked work that remains PAUSED per the
+developer's directive (device-resident FP4 forward, e2e run, any speed number).
+
+## 2026-08-03 - DEVELOPER RATIFICATION: ffmpeg invocation lives in examples ONLY
+
+Recording the decision so it is not re-litigated. Asked whether the muxer should be
+a library dependency, the developer answered: **"re: ffmpeg invocation, correct -
+let's keep in the examples only."**
+
+So the boundary is now a PROJECT DECISION, not an implementation convenience:
+  * `src/vllm/` (the library) builds the ARTIFACTS (PPM frames, WAV audio) and
+    BUILDS the ffmpeg argv - all pure data transforms, unit-tested;
+  * `examples/` (CLI + server) performs the actual INVOCATION.
+
+**Do NOT add process spawning to src/vllm/.** The library retains zero subprocess
+usage, which was the property that motivated the split.
+
+## 2026-08-03 - MiniMax-H3: /v1/videos request contract + job store
+
+The serving surface's LOGIC is implemented and tested; what is left there is
+mechanical glue (registering the two routes on ApiServer and injecting the runner).
+
+Request parsing applies H3's documented defaults (50 steps, flow shift 12 video / 3
+audio), accepts BOTH vLLM-Omni's `extra_params` nesting and a flat top-level
+spelling so a plain client need not nest, and REJECTS malformed input with a
+specific reason rather than silently defaulting - a bad request should be a 400 with
+a cause, never a surprising generation.
+
+The job store enforces queued -> running -> succeeded|failed. Deliberate choices:
+illegal transitions THROW rather than corrupting a finished record; an unknown id is
+REPORTED so the route can 404 instead of returning an empty 200; a succeeded job must
+carry an output path; a failed job never has an empty reason. Concurrent creation
+across 8 threads is asserted to keep ids unique and lose nothing, since the HTTP
+worker pool touches it from several threads.
+
+The library still spawns NOTHING: generation+mux enter as a caller-supplied
+`VideoRunner`, and the ffmpeg invocation lives in examples/ per the developer's
+ratified decision.
+
+
+## 2026-08-03 - MiniMax-H3: /v1/videos routes registered — W7 serving DONE on CPU
+
+The last glue is in: `POST /v1/videos`, `POST /v1/videos/sync` and
+`GET /v1/videos/{id}` now exist on ApiServer, closing W7 for everything that does
+not need a GPU.
+
+Registration follows the server's EXISTING additive/opt-in pattern (the one
+/metrics and /tokenize already use): the routes are registered only when
+`set_video_runner` has been called, so a server built without video support is
+byte-identical to before - no new constructor parameter, no existing caller
+touched.
+
+Two decisions worth recording:
+
+Async means a REAL background worker, not a detached one. `POST /v1/videos`
+returns the job id immediately because a 50-step denoise would otherwise hold an
+HTTP worker for minutes (which is exactly why upstream splits async from /sync).
+The worker is a JOINABLE thread drained in `~ApiServer`; a detached thread would
+outlive `this` and write into a destroyed job store. `~ApiServer` was `= default`
+and now has that body - it is out-of-line already, so no caller changed.
+
+A throwing runner fails the JOB, not the process. The worker catches everything
+(an escaping exception would be std::terminate) and always leaves the job in a
+terminal state, or a poller would wait on "running" forever. The sync twin maps
+the same throw to a 500 carrying the reason.
+
+Gate: 4 new dispatch cases in test_openai_api_server (36 cases / 438 assertions,
+all green) covering no-runner 500, unknown-id 404, sync success returning the
+runner's path, a throwing runner failing the job on BOTH endpoints, and a
+malformed body rejected 400 WITHOUT reaching the runner. Clean full CPU build,
+zero warnings.
+
+One near-miss worth keeping: the new tests first passed the harness temporaries
+(`ServerHarness h(MakeConfig(), ...)`), but the harness stores REFERENCES - every
+existing case binds locals first. Caught by reading the neighbours rather than by
+a crash, which is the kind of bug that would have surfaced later as flaky.
+
+Still PAUSED per the developer's standing directive: the device-resident FP4
+forward, any e2e run on a real quantized checkpoint, and therefore any speed
+number vs vLLM-Omni all need the GPU.
+
+## 2026-08-03 - MiniMax-H3 W2b: device-resident DiT forward, verified on a real GPU
+
+The developer opened a second GPU box (Thor, sm_110, aarch64, container-only) and
+asked for H3-2b there. It landed: MiniMaxH3DitForwardDevice runs the whole DiT
+graph with every activation in device memory, so the block stack -- and above it
+the 50-step denoise loop -- never round-trips through the host.
+
+THREE kernels, not thirty. The instinct was to port ~49 host glue loops; almost all
+of them already had a tuned shared op. The one that looked like it needed a bespoke
+kernel was the RoPE, and it did not: H3's _apply_rope is plain NeoX rotate_half over
+the leading rot_dim, and only the ANGLES are unusual (three axes off the fp64
+position grid rather than one scalar). vt::RopeFromCache takes a per-row cos/sin
+cache, so building that cache from the position grid reproduces it exactly. That
+left the two indexed AdaLN modulates and an ungated SiLU (the shared set has
+SiluAndMul/MoeSiluMul, both GATED). Those three live in a kMiniMaxH3 glue table
+mirroring the kLaguna precedent -- but registered on BOTH kCPU and kCUDA, where
+Laguna's is CUDA-only, so the whole device path is gated in CPU CI and a GPU is
+needed only for the kernels.
+
+THE BUG WORTH REMEMBERING. The AdaLN chunk views are ROW-STRIDED: chunk c of row r
+lives at r*(6*hidden) + c*hidden, so rows are hidden-wide but 6*hidden apart. The
+first kernels indexed them as contiguous. The result was not garbage -- it was
+1.7e-2 off, which is exactly the magnitude f32-vs-double reduction drift would
+produce, so the failure ARGUED FOR ITSELF as acceptable numerical slack. It was a
+real defect reading the wrong memory. The stride is now an explicit kernel
+parameter rather than an assumption. Generalizes: when a device port lands "close
+but not close enough", suspect a LAYOUT assumption before blaming reduction order,
+and make strides parameters instead of conventions.
+
+Gate: CPU backend 36/36; on Thor's GPU 36/36 with video max|diff| 1.49e-7 and audio
+8.94e-8 vs the upstream goldens (tolerance 2e-5) -- on par with the CPU reference's
+own 1.6e-7. Proven to have RUN, not skipped: the CUDA case executes 220 assertions
+(9673 total on GPU vs 9453 on CPU). CUDA build 1043/1043 clean, zero warnings.
+
+NOT bit-identical to the CPU reference, deliberately: vt::RmsNorm reduces in f32
+where the reference accumulates in double. f32 is what upstream torch does, so the
+device path is arguably the closer mirror; it is held to the same goldens instead.
+
+Thor CANNOT settle H3's speed question: sm_110 resolves every fp4/cutlass/marlin/fa2
+feature DISABLED, so the NVFP4 path still needs sm_121a (dgx). What Thor gave is the
+correctness foundation the FP4 layer drops onto -- device-resident tensors first.
+
+## 2026-08-03 - MiniMax-H3: bf16 production stream on the device forward + the FP4-on-sm_110 question settled
+
+Two things.
+
+(1) The device forward now runs upstream's PRODUCTION dtype policy, not just f32:
+a bf16 block stream with fp32 islands (both patch projections, the time embedder,
+both output heads), plus the explicit bf16 casts inside the two AdaLN modulates.
+Implemented the way the CPU reference does it - ROUND IN PLACE on f32 buffers at
+the cast points rather than switching storage - because what the bf16 golden gates
+is WHERE the casts happen. One new glue kernel (round_bf16), an integer
+round-to-nearest-even transcription of the reference's RoundBf16 including inf/nan
+passthrough; deliberately NOT __float2bfloat16, whose different rounding rule would
+be indistinguishable from a misplaced cast.
+
+Gate: 38/38 CPU, and on Thor's GPU video 2.41e-3 / audio 2.05e-3 vs the bf16
+goldens - essentially the CPU reference's own 2.4e-3 / 2.1e-3, which is the real
+evidence the cast points agree. The test also asserts the bf16 result DIFFERS from
+f32 by >1e-5; without that, a no-op dtype policy would pass silently.
+
+CORRECTION to what I claimed last commit: adopting bf16 did NOT clear the
+merged-GEMM allowlist entry. The shared seam allocates kBF16 DBufs; this forward
+keeps f32 STORAGE. The allowlist reason was rewritten rather than left stale.
+
+(2) FP4 ON sm_110 IS SETTLED - PROBED, not inferred from CMake messages. There are
+TWO DISJOINT Blackwell FP4 families:
+
+  mma.sync kind::mxf4nvf4 (warp)  : sm_120a/121a YES | sm_100a NO | sm_110a NO
+  tcgen05.alloc      (datacenter) : sm_120a/121a NO  | sm_100a YES | sm_110a YES
+
+So our warp-level FP4 GEMM can NEVER widen to sm_110 - that is an ISA boundary,
+not a porting gap. Thor's FP4 would have to come via tcgen05, and cannot today:
+our datacenter body is CUTLASS ArchTag=Sm100 guarded by __CUDA_ARCH__ == 1000, so
+retargeting it to sm_110 compiles to a DEAD STUB (silently - the dangerous failure
+mode), and CUTLASS ships ZERO sm110 kernels even at v4.6.1 (verified by shallow
+clone: no *sm110* files, no arch::Sm110 tag) - only capability macros in config.h.
+With no upstream body to port, an sm_110 FP4 GEMM would be from-scratch tcgen05
+work, which ground-every-impl-in-upstream forbids as a casual move.
+
+CONSEQUENCE: Thor is a CORRECTNESS venue. Every NVFP4 speed question - H3 and
+Laguna alike - still needs sm_121a on dgx. The FEATURE-TABLE's optimistic
+"sm_103a/sm_110 are separate later bricks" note is now qualified in the spec.
+
+FA2 is a separate hole on that box: the fa2 cell is 8.0,8.6,8.7,8.9,12.0a,12.1a -
+no sm_100, no sm_110 - which is exactly why the MLA/DeepSeek-V2 tests fail there.
+
+## 2026-08-03 - MiniMax-H3: AdaLN modulate + bf16-cast fold (and what was deliberately NOT fused)
+
+Folded the stream-dtype bf16 cast INTO the two AdaLN modulate kernels (`round_out`),
+removing 5 launches per bf16 forward (4 per block + 1 in the final layer). Verified
+BYTE-IDENTICAL on Thor's GPU: same digits as before the fold (2.4063e-3 / 2.05244e-3
+bf16, 1.49012e-7 / 8.9407e-8 f32) and the same 9481-assertion count.
+
+This is the one fold here that is safe BY CONSTRUCTION rather than by argument: these
+kernels already own the arithmetic, so rounding their store is the same cast point
+the unfused {modulate; round_bf16} pair produced. No reduction is involved.
+
+TWO FOLDS DELIBERATELY DECLINED, both for the same underlying reason - fusing across
+a boundary would MOVE a bf16 cast point, and where the casts happen is exactly what
+the bf16 golden gates:
+
+1. The refiner's {vt::Add; vt::RmsNorm} onto the catalog recipe kFusedAddRmsNormStd.
+   That recipe does `residual = x + residual` then `rms_norm(residual)` with NO cast
+   between, which is right for f32 but drops the rounding that belongs between them.
+   Folding only in the f32 branch would add a dtype-conditional path benefiting only
+   the NON-production dtype, over the refiner's small num_text rows. Recorded at the
+   call site so it reads as a decision, not an oversight.
+2. The block stack's {modulate_gate; RmsNorm}. That "add" is a GATED INDEXED add with
+   no catalog recipe, and fusing it into the tuned shared vt::RmsNorm would mean
+   reimplementing that reduction - trading a gated numeric for a launch, the wrong
+   trade while the real lever (FP4) is untouched.
+
+BOTH become correct AND free once activations are true bf16 STORAGE, because then the
+recipes' own operand stores do the rounding. That makes bf16 storage the next lever,
+and it is the same change that would clear the merged-GEMM allowlist entry.
+
+NO SPEED NUMBER is claimed. The only GPU available (Thor sm_110) cannot run the
+production FP4 config and the gate runs at reduced dimensions, so launch count is the
+honest unit of improvement, not wall clock.
+
+## 2026-08-03 - MiniMax-H3: TRUE bf16 storage - faster AND ~4x more accurate
+
+Replaced the round-in-place bf16 stream with REAL bf16 storage: activations are
+bf16 buffers, and the bf16-STORED modules are staged as bf16 WEIGHTS while
+upstream's fp32 ISLANDS (both patch projections, both time-embedder projections,
+both output heads, rope.inv_freq) stay f32.
+
+THE FINDING THAT DROVE IT. CUDA's MatmulBT requires a.dtype == b.dtype (mixed
+bf16-activation x f32-weight throws), so bf16 activations FORCE bf16 weights. That
+looked like a numerics risk until I checked the generator: the bf16 golden was
+produced with `bf16_model.to_bf16_weights()` - upstream rounds those weights too.
+Our round-in-place stream had been multiplying f32 weights by bf16 activations, an
+approximation that merely fit inside the 5e-3 tolerance. Matching the golden's
+actual model dropped the error ~4x: video 2.41e-3 -> 6.16e-4, audio 2.05e-3 ->
+5.21e-4. So the FAST path is also the FAITHFUL one; those pulled the same way.
+
+Generalizes: when a dtype-policy port "passes but only just", check whether the
+ORACLE quantized something you left in full precision. The tolerance can hide a
+model mismatch that looks like rounding noise.
+
+It also PAID OFF the fold I declined last milestone. The refiner's {Add; RmsNorm}
+is now folded onto vt::kFusedAddRmsNormStd: the objection was that the recipe casts
+nothing between its two steps, but with a bf16 RESIDUAL operand the add is rounded
+on store before the f32 variance (vt::RmsNorm's documented bf16-residual behaviour,
+matching csrc fused_add_rms_norm). Byte-identical - the numbers did not move.
+
+One op forced a choice: vt::RopeFromCache requires q/k/cache to share a dtype, so a
+bf16 stream needs a bf16 cos/sin cache. The ANGLES are still computed in f32 on the
+host; only the cached cos/sin round. This follows the project's other bf16 models
+(qwen3_vl builds the cache f32 then CastBf16's it), and the error above is measured
+WITH it.
+
+MERGED-GEMM ALLOWLIST, corrected AGAIN: bf16 storage removed the DTYPE half of that
+blocker (the seam wants kBF16 DBufs; we now have them). What remains is WEIGHT
+RESIDENCY - layers::UnquantizedMlpGateUpMethod takes an OwnedTensor (host bytes
+staged on demand via ResidentWeight) while H3 stages device tensors UP FRONT. That
+is an ownership-model difference, so adopting the seam means moving H3's loaders
+onto OwnedTensor residency: an architectural change to the quantized loaders, not a
+fold. Reason rewritten rather than left stale (third revision of this entry - each
+time the previous one turned out to name the wrong blocker).
+
+Gate: 38/38 CPU (9481 assertions). Thor GPU verification follows.
+
+## 2026-08-03 - MiniMax-H3: KEEP-QUANT GGUF arm (and why it matters for the Thor box)
+
+The developer asked the right question: if FP4 tensor cores are unavailable on
+sm_110, what about a DIFFERENT quant? GGUF block-quant turns out to sidestep the
+whole problem.
+
+THE FINDING: src/vt/cuda/cuda_quant_dot.cu contains ZERO #if/#ifdef - the ggml
+block-quant GEMM has no arch gate whatsoever, unlike every cutlass/marlin/fp4 path.
+Thor's DISABLED feature list is only fp4-mma / cutlass-nvfp4 / cutlass-fp8 /
+scaledmm-c3x / marlin-nvfp4 / fa2; nothing quant-related. Verified on the sm_110 GPU:
+test_cuda_quant_dot 9/9 (110,432 assertions) and test_gguf_keep_quant 37/37 pass.
+So the GGUF arm runs NATIVELY on Thor, and that box becomes a usable speed venue for
+it - see [[thor-sm110-first-runtime-verification]].
+
+But our H3 GGUF loader was throwing the compression away: it dequantized every
+tensor to f32 (DequantGgufRowToF32) and staging hard-asserted f32. Correct, and
+zero benefit.
+
+LANDED: LoadMiniMaxH3DitFromGguf(file, keep_quant=true) leaves ELIGIBLE 2-D
+projections in their block encoding (the shared rule: KeepQuantDType + K a whole
+number of blocks); norms, biases and anything unported still dequantize, so the
+weight struct is uniform either way. Staging uploads those bytes VERBATIM.
+
+The forward did not change AT ALL, and that is the nice part: vt::MatmulBT already
+dispatches a block-typed weight to kMatmulBTQuant (ops.cpp:146), so keep-quant is a
+loader + staging change, not a forward rewrite.
+
+THE TRAP, avoided by construction: a keep-quant slice feeding a DEVICE GEMM must
+point at DEVICE memory. A raw host-byte view reads as ALL ZEROS on the GPU and a
+CPU-only gate cannot catch it, because there the host pointer is perfectly valid.
+Our staging already allocates + copies to device, so this is satisfied - and the
+test asserts the output magnitude is non-zero specifically to catch that mode.
+
+Gate: 39/39 (9512 assertions). Resident bytes 3.77x smaller (215,424 vs 811,008 on
+the synthetic checkpoint), and the keep-quant forward agrees with the DEQUANTIZED
+forward at video 4.39e-5 / audio 7.50e-5 - consistent with kMatmulBTQuant's
+documented contract that only the K-reduction ORDER differs. The test also asserts
+the load really kept tensors quantized and really left the 1-D tensors alone, so a
+silently-dequantizing loader cannot pass it.
+
+CAVEAT on what a GGUF speed number means: vLLM/vllm-omni does not serve GGUF, so it
+is NOT quant-matched to upstream - it is comparable to llama.cpp (the project's
+labeled secondary bar) or to our own NVFP4 arm. The headline vs-vllm-omni number
+still needs NVFP4 on sm_121a. See [[vllm-is-the-bar-not-llamacpp]].
+
+## 2026-08-03 - MiniMax-H3: keep-quant gated on the GPU (the CPU-only gate was the hole)
+
+The keep-quant test ran on the CPU backend, which left the arm's whole premise
+UNGATED: kMatmulBTQuant's CUDA kernel was never touched with H3's shapes. Worse, the
+CPU backend is structurally incapable of catching the failure mode that matters --
+a keep-quant slice whose bytes never reach the device reads as perfectly valid host
+memory on CPU and as ALL ZEROS on the GPU.
+
+Split into CPU + CUDA cases over a shared helper. On Thor: 2/2, 62 assertions, and
+the two runs report DIFFERENT digits -- 4.39323e-05 (CPU) vs 4.39249e-05 (CUDA).
+That difference is the evidence: it proves the CUDA case dispatched its own kernel
+rather than repeating the CPU path. A matching number would have been ambiguous.
+
+Generalizes: when a gate's whole point is a DEVICE code path, running it on the CPU
+backend can pass while proving nothing. Look for a discriminator that could only
+differ if the intended kernel ran.
+
+## 2026-08-03 - MiniMax-H3 path 2 begins: audio-VAE checkpoint loader
+
+The VAE/encoder FORWARDS were all gated against the checkpoint's own remote code,
+which proved the MATH. What that could never prove is that the SHIPPED file's
+tensors BIND onto the structs those forwards read. For the audio VAE they do not,
+and reading the real header found two mismatches - both silent-failure shaped:
+
+1. WEIGHT-NORM SPELLING. The checkpoint ships torch's LEGACY weight_norm pair
+   `weight_g` / `weight_v`. The decoder reads `parametrizations.weight.original0` /
+   `original1`, because the generator ran the checkpoint's remote code under a
+   MODERN torch, where weight_norm is a parametrization. Same tensors, different
+   era of torch.
+2. PREFIX. Every BigVGAN tensor is under `decoder.`, but `dec_in_proj.*` - the
+   Conv1d that runs BEFORE BigVGAN - is at the top level.
+
+Neither would have been visible from the forward's own gate. Both came out of an
+HTTP range request over the file's first 2 MiB (1087 tensors, no payload), the same
+technique used for the GGUF/NVFP4/video-VAE manifests.
+
+A THIRD thing surfaced while writing the fixture, and this one was MY bug: I wrote
+the `ups.N.0` weight as [out, in, k]. It is a ConvTranspose1d, so the real shape is
+[in, out, k] with the weight-norm magnitude sized by INPUT channels
+(decoder.ups.0.0.weight_v is [1024, 512, 9], bias [512]). The decoder's own
+precondition caught it - the port was right and the test fixture was wrong. Worth
+remembering: when a fixture fails a precondition, suspect the fixture first if the
+implementation was gated against the oracle.
+
+Gate: 42/42 (12389 assertions). The name mapping is asserted INJECTIVE over the real
+manifest, the shipped geometry (dec_in_proj 32->2048 k=1, conv_pre 2048->1024 k=7,
+conv_post 8->1 k=7) is recovered from manifest SHAPES alone and matches the config
+the decoder was gated with, and an end-to-end load-and-decode over a synthetic file
+written in the SHIPPED spellings produces a finite in-range waveform.
+
+REMAINING for path 2: the video VAE decoder loader (560-tensor manifest already
+gated), and the two encoder towers (likely large reuse of our Qwen3-VL loader).
+
+## 2026-08-03 - MiniMax-H3: video-VAE loader, and the step nobody was applying
+
+The mapping itself was easy - strip the `decoder.` prefix, ignore the encoder half
+and `quant_conv` (an encoder-side stage). No weight-norm spelling change here,
+unlike the audio VAE. Asserted INJECTIVE over the real 560-tensor manifest.
+
+THE REAL FIND: `post_quant_conv`. The checkpoint ships it ([24, 24, 1, 1, 1] + bias),
+it is a Conv3d with a 1x1x1 kernel - i.e. a per-position CHANNEL MIX of the 24
+latent channels - and it runs on the latent BEFORE the decoder. Nothing in this port
+applied it. Grep for it across every H3 TU returned NOTHING.
+
+Why it was missed is instructive rather than embarrassing: the video decoder was
+gated at 8.9e-8 against the checkpoint's OWN ViT3DDecoder, whose first op is
+x_embedder. post_quant_conv belongs to the outer AutoencoderKL WRAPPER, so the gate
+was correct for what it covered and simply could not see a step upstream of its own
+entry point. The manifest shapes are what made it visible: post_quant_conv's output
+channel count (24) is exactly x_embedder's input, so it sits between the latent and
+the decoder.
+
+That is the worst class of gap - loading the tensor and not applying it yields a
+decode that RUNS, looks plausible, and is wrong. So it is implemented (a straight
+f32 contraction over input channels) and gated against a hand-computed result, plus
+an assertion that it is NOT a passthrough.
+
+GENERALIZES: a component gated against an oracle SUBMODULE cannot see steps in the
+wrapper around it. When loading a real checkpoint, tensors that map to nothing in
+the port are the signal - do not skip them silently just because the forward never
+asked for them.
+
+Gate: 44/44 (13310 assertions).
+
+REMAINING for path 2: the two encoder towers (likely large reuse of the Qwen3-VL
+loader), and wiring post_quant_conv into the pipeline's decode path.
+
+## 2026-08-03 - MiniMax-H3: post_quant_conv WIRED (the branch no test entered)
+
+Implementing post_quant_conv was only half the fix. MiniMaxH3GenerateT2va still did
+not call it, so the function was correct and unused - the same shape of gap as
+before, one layer up.
+
+Wired into the decode step, guarded on the weights actually carrying the tensor
+(reduced-dimension weight sets need not ship every wrapper tensor, and the
+structural t2va test does not).
+
+The guard created a NEW hazard: a conditional branch that no test enters. So the
+t2va test now runs the whole path TWICE - once without post_quant_conv, once with -
+and requires the frames to MOVE (delta 0.056). It also requires the WAVEFORM to stay
+BIT-IDENTICAL, since a video-side wrapper tensor has no business touching audio.
+
+The fixture uses identity-plus-one-off-diagonal rather than a random matrix: an
+identity would pass a "did it run" check while proving nothing, and the off-diagonal
+term is what makes it a genuine channel MIX.
+
+Gate: 44/44 (13321 assertions).
+
+## 2026-08-03 - MiniMax-H3: a THIRD weight-norm spelling, from the community quant repo
+
+The developer linked Abiray/Minimax-H3-nvfp4-INT4-INT8-Convrot. Inspecting its
+headers (range requests, no payload) split it cleanly into useful and not:
+
+USEFUL - `vae/minimax_h3_video_vae_fp16.safetensors` (562 tensors) and
+`vae/minimax_h3_audio_vae_fp32.safetensors` (917). Standalone, and they carry
+`latents_mean`/`latents_std` [32], the denorm statistics the pipeline needs. Our
+video loader already handles that file as-is (same decoder./encoder./post_quant_conv
+layout, and F16 is covered by the shared reader).
+
+BUT the audio one exposed a THIRD weight-norm spelling: `decoder.conv_pre.weight
+[1024, 2048, 7]` - no weight_g/weight_v, no parametrizations. The norm was FOLDED at
+conversion time. Our loader mapped (1)->(2) only, so this file would have thrown by
+name at decode.
+
+Now handled, and reconstructed EXACTLY rather than approximately: given materialized
+w, set v = w and g = per-dim-0-slice ||w||; the decoder's own g * v / ||v|| then
+returns w. Round-trip error 1.49e-08 (f32 precision). `dec_in_proj` is excluded - it
+is a PLAIN Conv1d, not weight-normalized, so synthesizing a pair for it would be
+wrong; the test asserts it survives verbatim.
+
+NOT USEFUL FOR PARITY - the INT4/INT8 "convrot" DiTs. Two disqualifiers, both from
+the manifest:
+  * The filenames say `pruned`, and pruning changes the MODEL. Gating a pruned
+    checkpoint against upstream goldens measures a different network.
+  * They are RESTRUCTURED: `adaln_t_table [1025, 8]` is a precomputed time-embedding
+    table we have no contract for, and `blocks.0.adaln_proj.linear.weight` is
+    [96768, 8] - input dim 8, not time_embed_dim. Plus a `comfy_quant` suffix on 200
+    tensors (ComfyUI's own quant metadata, not compressed-tensors).
+They may still be interesting as a SPEED experiment, but they cannot answer a
+correctness question, and a throughput number off a pruned+restructured model is not
+comparable to anything upstream.
+
+The packaged text encoder (`text_encoders/qwen3vl_32b_minimax_h3_int8_convrot`,
+1602 tensors) is more promising for path 2: ONE file carrying both towers in standard
+HF names (`model.*` 1251 + `visual.*` 351, 50 layers - matching H3's documented
+layer truncation). It is INT8 (I8 + weight_scale), so bf16 Qwen3-VL shards remain the
+cleaner correctness source; this one is the convenience/size option.
+
+Gate: 45/45 (13342 assertions).
+
+## 2026-08-03 - MiniMax-H3: encoder loader — path 2's loaders are COMPLETE
+
+The last and least trivial of the four. The VAE loaders renamed tensors; this one
+TRANSFORMS them.
+
+The real manifest came free: FL2VA/text_encoder ships model.safetensors.index.json,
+so the complete 1058-tensor name list needed no range request at all. Worth
+remembering - an index JSON is cheaper and more complete than a header prefix.
+
+WHAT IT SHOWED: HF ships `model.language_model.layers.N.self_attn.{q,k,v}_proj` and
+`mlp.{gate,up}_proj` SEPARATE (64 layers). The port, like vLLM, consumes them FUSED
+as `self_attn.qkv_proj` / `mlp.gate_up_proj`. So the loader row-concatenates
+[q_all|k_all|v_all] and [gate|up].
+
+ORDER IS LOAD-BEARING and that is why it is gated element-by-element rather than by
+size: the forward slices qkv_proj at [0,q) / [q,q+kv) / [q+kv,..), so a wrong
+concatenation order still RUNS and silently feeds keys into the query path. The test
+splits ONE layer's tensors across TWO shards, which a single-shard test would never
+exercise.
+
+The VISION tower needs no fusion - HF already ships `attn.qkv` fused and
+`mlp.linear_fc{1,2}` already match our names. Only the `model.visual.` prefix goes.
+
+H3 DELTAS honoured explicitly, and asserted NEGATIVELY:
+  * `model.language_model.norm.weight` is NOT loaded - H3 reads the UNNORMALIZED
+    layer-49 output, and carrying the tensor would imply it is applied.
+  * `lm_head.weight` is NOT loaded - the encoder produces hidden states.
+  * `max_layers` truncates the text tower (H3 keeps min(num_hidden_layers, 50); the
+    file ships 64), which also avoids materializing 14 unused layers of a 32B model.
+
+Gate: 46/46 (13740 assertions).
+
+PATH 2 LOADERS ARE DONE: audio VAE, video VAE, encoder. What remains before a real
+generated video is ASSEMBLY - a driver that opens the four checkpoints, runs the
+pipeline and writes the mp4 - plus the MM processor's image preprocessing on real
+inputs.
+
+## 2026-08-03 - MiniMax-H3: ASSEMBLY - the four checkpoints compose
+
+`examples/minimax-h3-gen` opens the DiT (GGUF, dequant or keep-quant), both VAE
+safetensors and both shipped config.json files, plans the request shape, generates,
+writes PPM frames + WAV, and muxes to MP4. It lives in examples/ because that is
+where the ffmpeg invocation is allowed.
+
+Verified over REAL file formats (not mocks) on both GGUF paths: geometry recovered
+from the GGUF (layers/hidden/heads), both VAEs loaded through the loaders written
+this session, text_len derived from the prompt-embeddings file, and the shape plan
+correct - 768x1344 canvas / VAE ratio 16 = 48x84 latent, latent_t 62, 50 steps.
+
+NEW CONFIG PARSERS, gated against the REAL config.json files embedded verbatim
+(they are ~2 KB each, so embedding beats a hand-copied summary that could drift):
+  * `latent_dim` (2048) is BigVGAN's MEL count; `latent_channels` (32) is the VAE
+    latent width dec_in_proj maps FROM. Reading the wrong one is wrong by 64x, and
+    both keys sit in the same file.
+  * rope_apply_dim = int(dim_head * rope_dim_ratio) = int(64 * 0.75) = 48.
+  * Both configs carry per-channel latents_mean/latents_std (32 audio, 24 video),
+    which the pipeline denormalizes with - previously the caller had to supply them.
+The parsed geometry is cross-checked against the MANIFEST, not just itself:
+x_embedder's [2048, 24] must equal (block.dim, in_channels).
+
+DELIBERATE SCOPE: prompt EMBEDDINGS are an input file, not computed in the driver.
+The encoder tower needs a tokenizer plus a 32B forward, which is its own driver, and
+separating them keeps "do the checkpoints compose?" answerable independently.
+
+Noise is drawn from a local splitmix64 stream, seeded for reproducibility, and the
+code says explicitly that this does NOT reproduce torch's RNG - matching it decides
+WHICH sample you get, not whether the pipeline is right, and pretending otherwise
+would invite comparing our sample to upstream's as if they should match.
+
+HONEST LIMIT: no full generation on a REAL checkpoint has run. Everything is gated
+on synthetic files and real manifests/configs. That download is the next step, and
+it is the only thing between here and a video that can actually be watched.
+
+Gate: 47/47 (13763 assertions).
+
+## 2026-08-03 - MiniMax-H3: the denoise loop finally runs DEVICE-RESIDENT
+
+Found while preparing the real-checkpoint run: MiniMaxH3DenoiseLoop called
+MiniMaxH3DitForward - the CPU REFERENCE - not MiniMaxH3DitForwardDevice. So every
+device-forward milestone this session was reachable only through the DiT unit test,
+never through the loop that actually drives generation.
+
+That made a real run infeasible rather than merely slow: 50 layers x hidden 5376 x
+~250k latent positions x 50 steps is not a CPU workload.
+
+Now: on a non-CPU device the loop stages the DiT weights ONCE (a 50-step loop that
+re-uploaded ~16 GB per iteration would be dominated by transfer - which is exactly
+what StageMiniMaxH3DitWeights was built for) and runs every step device-resident.
+
+Gated by re-running the WHOLE t2va path on CUDA and comparing frames AND waveform
+against the CPU pipeline at 2e-3 - the same tolerance class the DiT forward is held
+to, carried through both VAE decoders.
+
+GENERALIZES, and it is the third instance this session: a component can be gated and
+still be UNREACHED by the code path that matters. post_quant_conv was implemented but
+uncalled; the keep-quant test ran on the CPU backend; the device forward was gated in
+a unit test while the loop used the CPU one. Ask what CALLS the thing, not just
+whether the thing is correct.
+
+## 2026-08-03 - MiniMax-H3: /v1/videos wired into examples/server
+
+`--video-dit` (+ --video-vae/--audio-vae and their configs) makes examples/server
+load the H3 checkpoints at startup and register a real VideoRunner: generate ->
+PPM frames + WAV -> ffmpeg -> MP4, returning the path. Omit it and the routes are
+never registered, so the server is byte-identical to before (36/36 api-server cases
+unchanged).
+
+The runner is a CALLBACK living in examples/ because that is where process spawning
+is allowed; the library still builds only artifacts and argv.
+
+HONEST GAP, and it is stated at STARTUP rather than buried in a doc: turning a
+PROMPT into conditioning needs the H3-Encoder (32B tower + tokenizer), which is not
+wired. Until it is, every request is conditioned on the SAME `--video-prompt-embeds`
+file, so the prompt text does NOT steer the output - and with no such file the
+runner REJECTS requests with that explanation rather than silently generating
+something unconditioned. Wiring the encoder is the next step for a truthful API.
+
+Shape/seed/steps DO come from the request (MiniMaxH3ResolveShape over task,
+duration, frames, height, width; seed drives the noise stream), so everything except
+text conditioning is live.
+
+## 2026-08-04 - MiniMax-H3: FIRST real-checkpoint run on Thor - measured, not guessed
+
+Downloaded the real stack to Thor (DiT MiniMax-H3-FL2VA-Q3_K_M 15.58 GB, video VAE
+5.21 GB fp16, audio VAE 605 MB fp32, both configs) and ran it.
+
+WHAT WORKS: the DiT LOADS - geometry recovered from GGUF SHAPES alone as layers=50,
+hidden=5376, heads=56, i.e. the shipped H3 - both VAEs load through the loaders
+written this session, both configs parse, and the DiT forward RUNS on the GPU.
+
+★ KEEP-QUANT IS REQUIRED, NOT AN OPTIMIZATION. The dequant path is OOM-KILLED:
+Q3_K -> f32 is ~145 GB against 122 GB of unified memory. With --keep-quant the DiT
+stays at 15.6 GB and loads. The arm built earlier today is what makes a real run
+possible at all - a nice case of an "optimization" turning out to be the enabling
+condition.
+
+MEASURED (the VT_H3_PROGRESS trace added for exactly this):
+  weight staging to device   32.8 s, ONCE
+  DiT forward                199.96 s per step at seq_len 576
+So the 50-step default is ~2.8 h of DiT alone. Slow, but running.
+
+BLOCKER: the run TIMED OUT (EXIT=124) in the VIDEO VAE DECODE. That decoder is still
+CPU-ONLY - MiniMaxH3VideoVaeDecode has no device path - and it is a 36-layer,
+dim-2048 ViT3D on the host. So even with the DiT on GPU the decode is a serial CPU
+wall. This is a MISSING DEVICE PATH, not a tuning problem.
+
+METHOD NOTE worth keeping: nvidia-smi's GPU utilization is NOT reliable on this
+Tegra-class board (it also reports Memory-Usage "Not Supported"). I spent ~20 minutes
+treating "GPU 0%, CPU 75%" as evidence the device path was not taken; it WAS taken.
+One stderr phase trace settled in a single run what speculation had not. On this box,
+instrument - do not read the utilization counter.
+
+Also: --steps 1 is INVALID (N steps needs N+1 sigmas); the minimum is 2.
+
+## 2026-08-04 - MiniMax-H3: ★ END-TO-END VIDEO ON REAL WEIGHTS (Thor)
+
+A playable MP4 out of the real 15.58 GB MiniMax-H3-FL2VA-Q3_K_M checkpoint on Thor's
+GPU. ffprobe: h264 / yuv420p 128x128 + AAC stereo 32 kHz. EXIT=0 in 6m22s.
+
+The whole chain is now proven on real weights, not fixtures:
+  GGUF keep-quant load -> device-resident denoise loop -> post_quant_conv ->
+  ViT3D video decode + BigVGAN audio decode -> PPM frames + WAV -> ffmpeg mux
+
+Measured at latent 2x8x8 / 2 steps: staging 22.3 s (once), DiT forward 21.1 s/step at
+seq_len 64. The earlier 256x256 attempt gave 200 s/step at seq_len 576 and TIMED OUT
+in the CPU-only VAE decode, which is why this run used smaller dims - the milestone is
+that the chain COMPLETES on real weights, not that these dims are useful output.
+
+WHAT THIS DOES NOT SHOW: the video is not prompt-conditioned. The H3-Encoder is not
+wired, so conditioning is a fixed embeddings file and the prompt text steers nothing.
+That is the next piece for a truthful API.
+
+TWO PERFORMANCE GAPS, both now measured rather than suspected:
+  1. DiT forward 200 s/step at seq_len 576 - the 50-step default is ~2.8 h of DiT.
+  2. The VIDEO VAE DECODE IS CPU-ONLY (36-layer dim-2048 ViT3D on the host) and is
+     the wall at realistic resolutions. A missing device path, not tuning.
+
+## 2026-08-04 - MiniMax-H3: ★ /v1/videos SERVED end-to-end from examples/server
+
+The second half of the goal. `examples/server` started on Thor with BOTH the
+Qwen3-0.6B LLM and the H3 checkpoints logs:
+
+  server: /v1/videos on (dit layers=50, device=cuda, keep-quant)
+  server: WARNING /v1/videos ignores the request PROMPT - text conditioning needs
+          the H3-Encoder, which is not wired yet
+
+Then over HTTP:
+  POST /v1/videos  -> {"id":"vid_1","status":"queued"}
+  GET  /v1/videos/vid_1 (poll) -> {"status":"succeeded","output_path":"..."}
+  ffprobe(output_path) -> h264 / yuv420p 128x128 + AAC stereo 32 kHz
+  GET  /v1/videos/video-0 (a wrong id) -> 404 NotFoundError
+
+So the async route, the job store's queued->running->succeeded lifecycle, the
+runner callback, the ffmpeg mux and the 404 path are all exercised against the REAL
+checkpoint, not fixtures. Server-side trace: staging 58.0 s, DiT forward 22.4 s/step.
+
+STILL TRUE, and stated at startup rather than buried: the PROMPT does not steer the
+output. Conditioning is the fixed --video-prompt-embeds file because the H3-Encoder
+is not wired. That is the next piece for a truthful API.
+
+Housekeeping: pruned 8 stale per-SHA build trees on Thor (80G -> 52G used), per
+[[grid-per-sha-trees-fill-disk]].
+
+## 2026-08-04 - MiniMax-H3: encoder KEEP-QUANT GGUF loader (toward real text conditioning)
+
+Wiring the encoder is what turns the generated video from unconditioned noise into
+something a prompt steers. Step one is loading it at all: the tower is 32B, and the
+safetensors loader materializes f32 (~128 GB), which does not fit the 122 GB box.
+
+LoadMiniMaxH3EncoderFromGguf keeps the projections in their ggml blocks - the real
+file is qwen3vl-32B-MiniMax-H3-Q4_K_M.gguf, 902 tensors, all Q4_K - holding the tower
+at ~14.6 GB. As with the DiT, the block-quant GEMM has no arch gate, so it runs
+natively on hardware that cannot do FP4.
+
+THE INTERESTING PART: the two fusions the forward needs (q/k/v -> qkv_proj, gate/up
+-> gate_up_proj) are performed on the QUANTIZED BYTES. That is sound because ggml
+rows are INDEPENDENT block sequences and every K here is a multiple of the
+256-element block, so concatenating whole rows yields a valid block-quant tensor with
+rows [q_all|k_all|v_all]. No dequantize/requantize round trip, and no precision lost
+to one. Gated BYTE-FOR-BYTE against `q ++ k ++ v` and `gate ++ up`.
+
+Also gated: geometry recovered from the fused shapes alone (hidden/head_dim/heads/
+kv_heads/intermediate/layers), truncation to min(num_hidden_layers, 50), and the H3
+delta that `norm.weight` is NOT bound because H3 reads the UNNORMALIZED output.
+
+GGUF prefixes differ from safetensors and that is now pinned: `model.layers.N.` here
+vs `model.language_model.layers.N.` there, `visual.` vs `model.visual.`.
+
+REMAINS for conditioning: a DEVICE encoder forward that consumes these quantized
+weights (the existing MiniMaxH3EncoderTextForward is a host f32 reference), plus
+tokenization and the embedding gather.
+
+## 2026-08-04 - MiniMax-H3: the REAL 32B encoder loads keep-quant on Thor
+
+`--encoder /ckpt/enc_q4km.gguf --encoder-max-layers 50` on the real 14.58 GB file:
+
+  encoder layers=50 hidden=5120 heads=64 kv_heads=8 head_dim=128 ffn=25600
+  encoder resident (keep-quant) = 13.2421 GiB
+
+Geometry recovered from SHAPES alone, and it is Qwen3-32B exactly (64 heads x 128,
+8:1 GQA, ffn 25600). Layers are 50 because H3 truncates - the file ships 64. It loads
+ALONGSIDE the keep-quant DiT, so the full stack fits the box.
+
+THE REAL FILE CORRECTED A DESIGN ASSUMPTION. My loader asserted a fused group shares
+one ggml encoding; the shipped Q4_K_M encoder stores v_proj as Q6_K while q/k are
+Q4_K - the usual K_M recipe of keeping V at higher precision. So the attention group
+CANNOT be byte-concatenated.
+
+Fusion is now conditional: uniform groups fuse (gate/up still do), mixed groups keep
+their members separate in their own encodings. Dequantizing to force the fusion was
+the alternative and would have discarded exactly the precision the recipe exists to
+keep - so a mixed checkpoint costs extra GEMM launches, not precision.
+
+Worth noting the assertion is what found this. A loader that silently took the first
+member's dtype would have produced a tensor whose v rows were garbage, and nothing
+downstream would have said so.
+
+## 2026-08-04 - MiniMax-H3: the DEVICE keep-quant ENCODER forward runs
+
+MiniMaxH3EncoderTextForwardDevice: the 32B conditioning tower running from its ggml
+blocks. Gated at max abs diff 3.76e-4 against the host f32 reference on a scale of
+~1.0 - 0.04% relative, which is Q8_0 quantization error and nothing else, because
+the test feeds BOTH paths the same DEQUANTIZED numbers so the only difference is
+where quantization enters.
+
+No dequantization on the device path: the projections go through vt::MatmulBT, which
+dispatches kMatmulBTQuant on a block-typed weight. That is what lets a 32B tower fit
+a 122 GB box (13.2 GiB resident) alongside the DiT.
+
+TWO THINGS THAT LOOKED LIKE THEY NEEDED BESPOKE KERNELS AND DID NOT:
+  * M-RoPE. Upstream builds emb = cat(freqs, freqs), so cos/sin REPEAT across the
+    two halves - exactly vt::RopeFromCache's [cos_half | sin_half] layout. Only the
+    ANGLES are unusual (three axes interleaved [THW THW ...] across frequency slots),
+    and those are host-side, once per prompt.
+  * Causal GQA attention. vt::DFlashBlockAttention(causal=true) already broadcasts
+    kv heads across their query group.
+So the whole tower is shared ops plus the loader.
+
+The MIXED-ENCODING path is handled in the forward too: when the checkpoint kept
+q/k/v separate (the shipped Q4_K_M does, v_proj being Q6_K) it issues three GEMMs
+instead of one, and likewise gate/up. Costs launches, not precision.
+
+All three H3 deltas preserved: layer truncation to min(num_hidden_layers,
+selected_layer), the UNNORMALIZED output (no final RMSNorm - which is why
+norm.weight is never even loaded), and DeepStack left to the caller.
+
+Gate: 49/49 (14606 assertions).
+
+REMAINS for a prompt-steered video: tokenization + the embedding gather (the table is
+block-quant, so a gather dequantizes only the selected rows), then wiring prompt ->
+embeddings into the driver and the server.
+
+## 2026-08-04 - MiniMax-H3: tokenizer + embedding gather -> REAL text conditioning
+
+The last two pieces. `minimax-h3-gen --encoder <gguf> --prompt "..."` now goes
+prompt -> ids -> embeddings -> encoder -> conditioning, with no --video-prompt-embeds
+file anywhere in the path.
+
+TOKENIZER: the encoder GGUF carries its own vocab, so tok::Tokenizer::FromGguf(ef)
+needs no side-car tokenizer.json. One fewer file to keep in sync with the weights.
+
+EMBEDDING GATHER: the table is [151936, 5120] - ~1.5 GB even quantized - and a prompt
+touches a few dozen rows, so MiniMaxH3EncoderEmbedTokens decodes ONLY the requested
+rows. That is valid for the same reason the byte-level fusion was: ggml rows are
+INDEPENDENT block sequences, so a row decodes from its own bytes alone. Gated
+BIT-IDENTICAL against slicing a full-table dequant, with a repeated id and both vocab
+ends in the id list, and out-of-range ids required to THROW rather than read past the
+table.
+
+That required recording each kept tensor's ggml TYPE ID alongside its vt::DType - the
+single-row dequant entry point is keyed by the ggml id, not by the vt dtype.
+
+Gate: 50/50 (15254 assertions).
+
+## 2026-08-04 - MiniMax-H3: ★★ PROMPT-CONDITIONED video, end to end on real weights
+
+  --prompt "a cat playing a piano"
+    -> tokenizer (tokenizer.json)                  5 tokens
+    -> block-quant embedding gather                [5, 5120]
+    -> 32B keep-quant encoder ON DEVICE            conditioning [5, 5120]
+    -> DiT (keep-quant, device denoise loop)       21.6 s/step, seq_len 64
+    -> ViT3D + BigVGAN decode -> PPM/WAV -> ffmpeg
+    -> cond.mp4  (h264/yuv420p 128x128 + AAC stereo 32 kHz), EXIT=0
+
+No --video-prompt-embeds anywhere in the path. BOTH towers resident at once: DiT
+15.6 GB + encoder 13.2 GiB, which is only possible because both are keep-quant.
+
+ONE WRONG ASSUMPTION, corrected by the real file in a single run: I had the driver
+call Tokenizer::FromGguf because "the GGUF carries its own vocab". The ComfyUI-style
+encoder export is WEIGHTS ONLY - no tokenizer.ggml.* metadata, unlike a llama.cpp
+export - so it threw. `--tokenizer` now takes the checkpoint's own tokenizer.json,
+falling back to FromGguf for exports that do embed one.
+
+Encoder staging is 162.3 s (vs 32.8 s for the DiT), which is the next obvious cost to
+look at if prompts are encoded per request rather than once.
+
+## 2026-08-05 - MiniMax-H3: audio-VAE ENCODER ported; ref2va AUDIO and VIDEO+AUDIO wired
+
+The last two unwired conditioning modes were blocked on one missing half. Only the
+audio VAE's DECODER was ported (DAC/BigVGAN, 4.2e-9), so `MiniMaxH3DenoiseT2va`
+THREW on any reference block carrying audio: a `kAudio` block, or a `kVideoAudio`
+block with `ref_audio_t > 0`.
+
+WHAT THE ENCODE PATH ACTUALLY IS. There is no `encode` on the shipped module -
+`DacAudioVAE` exposes only `decode` (dac_audio_vae.py:211-225). vLLM-Omni composes
+the encode by hand (vae.py:317-325), and that composition is the contract:
+preprocess right-pad to a whole hop -> `Encoder` -> `pre_block` -> `mean_proj`.
+Ported with upstream citations: Snake1d (:25-40 - one parameter, NEVER log-scaled,
+and it both scales the sine and forms the reciprocal, so it is not the decoder's
+SnakeBeta), ResidualUnit (:50-66), EncoderBlock (:69-87), Encoder (:90-117), and
+the AttnProjection block (dac_attn_proj.py:8-88) whose qkv bias is ASSEMBLED as
+[q_bias | zero_k_bias | v_bias] so keys carry no bias at all. Only the NARROWING
+branch (in_dim > out_dim) is implemented - the one the checkpoint ships; the
+widening branch refuses loudly rather than running untested.
+
+GATED STAGE BY STAGE against the checkpoint's own modules, via a new generator on
+the same FNV-1a + splitmix64 pattern: conv stack 2.98e-8, AttnProjection 1.64e-7,
+whole encode-to-latent 1.86e-8. Three stages rather than one end-to-end number,
+because a single figure says something is wrong without saying which of three
+quite different subsystems it is. The reduced input is 25 samples against a hop of
+4, deliberately NOT a multiple, so a port that skipped `preprocess` returns 6
+frames instead of 7 and fails.
+
+`mean_proj` and never `logs_proj`, same rule the video side follows: a sampled
+reference would condition differently on every run. `logs_proj` is not even loaded.
+
+LOADER on the same real 1087-tensor manifest the decoder loader is gated on, which
+also CONFIRMED the shipped geometry from shapes alone - encoder_rates [2,4,4,5,5],
+latent_dim 2048, attn_proj_dim 32, qkv 3x the INPUT width. One trap worth naming:
+`pre_block`'s Linears and `mean_proj` are PLAIN modules, so their bare `.weight`
+must not be swept up by the materialized-weight-norm rule that exists for the
+encoder's convs. Asserted.
+
+WIRING gated on the property that matters. What is refused now is an audio-bearing
+block with NO encoded rows behind it - the layout would grow around packed rows
+nothing ever wrote. Under identical prompt, noise and schedule: an audio reference
+moves the audio rows by 0.51, a video+audio reference by 0.71 against the SILENT
+same-clip control, a DIFFERENT waveform still by 7.1e-4, and a DIFFERENT clip with
+the same audio moves the video rows by 3.7e-2. The last two are the ones a wiring
+that reserved the rows and then pinned a constant would fail; everything
+structural would still pass.
+
+The WAV reader went into the LIBRARY next to the writer it inverts rather than
+into the example, so it is unit-gated: chunk-list walk (not a fixed 44-byte
+header), mono repeated to stereo, and a non-32 kHz file REFUSED rather than
+mis-encoded - there is no audio dependency here to resample with.
+
+NEXT: no real-checkpoint render conditioned on a real waveform has been run. That
+needs the multi-GB download and a GPU, and it is the one thing here that is not
+gated.
+
+Suite: 60/60 cases, 29427 assertions, clean CPU build.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2cbd6d4c2..d1808d6f3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -463,6 +463,25 @@ add_library(vllm STATIC
   src/vllm/model_executor/models/kimi_k3_registry.cpp
   src/vllm/model_executor/models/kimi_k3_weights.cpp
   src/vllm/model_executor/models/kimi_k3.cpp
+  src/vllm/model_executor/models/minimax_h3.cpp
+  src/vllm/model_executor/models/minimax_h3_packing.cpp
+  src/vllm/model_executor/models/minimax_h3_planner.cpp
+  src/vllm/model_executor/models/minimax_h3_gguf.cpp
+  src/vllm/model_executor/models/minimax_h3_nvfp4.cpp
+  src/vllm/model_executor/models/minimax_h3_audio_vae.cpp
+  src/vllm/model_executor/models/minimax_h3_video_vae.cpp
+  src/vllm/model_executor/models/minimax_h3_video_vae_device.cpp
+  src/vllm/model_executor/models/minimax_h3_vae_cnn.cpp
+  src/vllm/model_executor/models/minimax_h3_encoder.cpp
+  src/vllm/model_executor/models/minimax_h3_pipeline.cpp
+  src/vllm/model_executor/models/minimax_h3_wav.cpp
+  src/vllm/model_executor/models/minimax_h3_mux.cpp
+  src/vllm/model_executor/models/minimax_h3_device_resolve.cpp
+  src/vllm/model_executor/models/minimax_h3_device.cpp
+  src/vllm/model_executor/models/minimax_h3_vae_loader.cpp
+  src/vllm/model_executor/models/minimax_h3_encoder_gguf.cpp
+  src/vllm/model_executor/models/minimax_h3_encoder_device.cpp
+  src/vllm/entrypoints/openai/video_api.cpp
   src/vllm/model_executor/models/kimi_kda.cpp
   src/vllm/model_executor/models/glm4_registry.cpp
   src/vllm/model_executor/models/glm4_weights.cpp
@@ -716,6 +735,7 @@ add_library(vllm STATIC
   src/vt/cpu/cpu_backend.cpp
   src/vt/cpu/cpu_threadpool.cpp
   src/vt/cpu/cpu_ops.cpp
+  src/vt/cpu/cpu_minimax_h3.cpp
   src/vt/cpu/cpu_matmul_elem.cpp
   src/vt/cpu/cpu_quant_dequant.cpp
   src/vt/cpu/cpu_quant_act.cpp
@@ -888,7 +908,8 @@ if(VLLM_CPP_CUDA)
     src/vt/cuda/cuda_combine_tokens.cu
     src/vt/cuda/cuda_sample.cu
     src/vt/cuda/cuda_deepseek_v4.cu
-    src/vt/cuda/cuda_laguna.cu)
+    src/vt/cuda/cuda_laguna.cu
+    src/vt/cuda/cuda_minimax_h3.cu)
   find_package(CUDAToolkit REQUIRED)
   # cublasLt is linked now so the Task 4 matmul lands without a build change.
   target_link_libraries(vllm PUBLIC CUDA::cudart CUDA::cublasLt)
diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md
index 2b0965c07..633c7f2aa 100644
--- a/docs/BENCHMARKS.md
+++ b/docs/BENCHMARKS.md
@@ -1,5 +1,124 @@
 # Benchmarks
 
+## MiniMax-H3 (omni-modal video+audio DiT) — PENDING; hardware verdict CORRECTED (2026-08-03, `CLAIM-MINIMAX-H3-W0-W2`, `CLAIM-MINIMAX-H3-W6A-W9`)
+
+**Serving (W7) is DONE on CPU and the DEVICE-RESIDENT forward (W2b, f32) is LANDED and GPU-VERIFIED as of 2026-08-03**; still no SPEED number — the FP4 path — and therefore any QUANT-MATCHED comparison against vLLM-Omni — needs sm_121a. NOTE the GGUF arm is different: the ggml block-quant GEMM has NO arch gate at all (`src/vt/cuda/cuda_quant_dot.cu` contains no `#if`), so it runs natively on sm_110 — `test_cuda_quant_dot` 9/9 (110,432 assertions) and `test_gguf_keep_quant` 37/37 pass on Thor. That makes sm_110 a usable venue for GGUF-arm speed work, though a GGUF number is not quant-matched to vLLM-Omni (which does not serve GGUF). PROBED, not inferred: the warp-level `mma.sync kind::mxf4nvf4` our FP4 GEMM uses is CONSUMER-Blackwell only (ptxas accepts it on sm_120a/121a, rejects it on BOTH sm_110a and sm_100a); sm_110 does support the datacenter `tcgen05` family, but our sm_100 body is CUTLASS `ArchTag=Sm100` guarded by `__CUDA_ARCH__ == 1000` (retargeting it compiles to a dead stub) and CUTLASS ships **zero** sm110 kernels even at v4.6.1 — only capability macros. So Thor is a correctness venue only. Every figure below is a CORRECTNESS gate, not a throughput one.
+
+**Throughput disposition: PENDING — no number is owed yet, and the earlier
+"not reproducible on this project's hardware" verdict is WITHDRAWN.**
+That verdict reasoned from the BF16 release alone (~354 GB, validated on 4x NVIDIA
+B300 at ~133 GB peak per rank, against one GB10 with 119 GiB unified). Quantized
+MiniMax-H3 checkpoints exist and DO fit:
+
+| Arm | Working set | Fits 119 GiB? |
+|---|---|---|
+| ComfyUI GGUF (`realrebelai/MiniMax-H3_GGUFs`) | DiT Q3_K_M 15.6 GB + Qwen3-VL encoder Q4_K_M 14.6 GB + VAEs ~11 GB = **~41 GB** | yes |
+| NVFP4 (`lilcheaty/MiniMax-H3-NVFP4`) | NVFP4 DiT + AWQ encoder + both VAEs | yes |
+
+So an end-to-end run and a speed comparison ARE reachable here; they are gated on
+the remaining bricks (encoder, VAEs, pipeline), not on hardware. NVFP4 is the
+likely speed path: sm_121 has native FP4 tensor cores and our NVFP4 stack is the
+most optimized one we own. A like-for-like comparison against vLLM-Omni's own
+published figures remains machine-class-limited (they are 4x B300 numbers).
+
+**Reference figures (upstream, NOT ours):** FL2VA 8.7 s clip at 1248x768 in ~87 s
+E2E on 4x B300 with USP-4 + regional torch.compile; the DiT is ~88% of request
+latency; 50 inference steps at 24 FPS.
+
+**Correctness that IS gated (no GPU, no checkpoint).** Upstream's H3 modules are
+pure Python, so they are executed at reduced dimensions as the oracle
+(`scripts/gen-minimax-h3-goldens.py`; both sides rebuild weights and inputs from an
+identical FNV-1a + splitmix64 stream, so no weight byte is checked in):
+
+| Component | Result |
+|---|---|
+| fl2va packed layout + fp64 position grid | exact / **bit-exact** |
+| ref2va block layout (image + video_audio refs) | exact, incl. fp64 grid |
+| patchify / unpatchify / audio pack / unpack | exact + round-trip identity |
+| euler-ancestral eta0 scheduler + `rf_v_to_x0` | exact |
+| **DiT forward (reduced dims, f32)** | **max abs diff 1.6e-7 video / 1.5e-7 audio** |
+| **DiT forward (bf16 production stream)** | **max abs diff 2.4e-3 video / 2.1e-3 audio** |
+| request planning (frames, latents, sigmas, canvas, task dispatch) | exact |
+| denoise-loop invariants | pass |
+| **REAL GGUF manifest** (535 tensors, `MiniMax-H3-FL2VA-Q3_K_M.gguf`) | exact name + shape match; geometry derived from shapes alone equals the shipped config |
+| **AUDIO VAE decoder** vs the checkpoint's own remote code | **max abs diff 4.2e-9** (kaiser-sinc filter 3.0e-8) |
+| **REAL NVFP4 manifest** (1051 tensors) | exact: compressed-tensors triple, group 16, islands unquantized |
+| **REAL video-VAE manifest** (560 tensors) | exact: decoder is a 36-block ViT, encoder the 3D CNN |
+| **VIDEO VAE decoder TransformerBlock** vs the checkpoint's own remote code | **max abs diff 6.0e-8** |
+| **VIDEO VAE FULL ViT3D decoder** (pack -> RoPE -> 36 blocks -> proj_out -> unpatchify) | **max abs diff 8.9e-8** |
+| **ENCODER text tower** (truncation + unnormalized output + DeepStack) | **max abs diff 1.2e-7** |
+| **ENCODER vision block** (LayerNorm, fp32 rotary, varlen non-causal, tanh-GELU) | **max abs diff 6.0e-8** |
+| **ENCODER FULL vision tower** (ragged 2-image batch, DeepStack + merged) | **max abs diff <= 1e-4** |
+| **CONDITION-NOISE augmentation** (visual + audio anchors) | exact (<= 1e-6) |
+| **REFERENCE-VIDEO geometry + frame schedule** | exact |
+| **VIDEO VAE tiling plan + seam blend** | exact |
+| **PRESENTATION token tags** (fl2va vision-span override) | exact |
+| **VAE encoder ResnetBlock3D** (causal Conv3d + GroupNorm3D) | exact; causality proven |
+| **VAE encoder Downsample3D** (asymmetric pre-pad + strided causal conv) | exact |
+| **WHOLE VAE 3D-CNN encoder** | exact |
+| **MM processor reuse** (H3's processor config on our Qwen3-VL front end) | pass |
+| **WAV serialization** (interleave + 16-bit PCM + clamping) | pass |
+| **Video output: PPM frames + MP4 mux argv** | pass; argv RUN through real ffmpeg -> valid h264 + AAC MP4 |
+| **`/v1/videos` request contract + job store** | pass (4 cases / 63 assertions, incl. concurrency) |
+| **`/v1/videos` ROUTE DISPATCH on ApiServer** | pass (4 cases): no-runner 500, unknown-id 404, sync success returns the runner's path, a throwing runner fails the JOB on both endpoints (process survives), malformed body 400 without reaching the runner |
+| **MP4 mux END TO END through the example binary** | pass; 12 PPM frames + WAV -> ffprobe reports h264 / yuv420p + stereo AAC 32 kHz (previously only the argv was validated) |
+| **Full CPU suite with the serving surface landed** | **333/333 pass**, clean build, zero warnings |
+| **DEVICE-RESIDENT DiT forward** (brick H3-2b, CPU backend) | pass — same upstream goldens, same 2e-5 tolerance as the CPU reference |
+| **DEVICE-RESIDENT DiT forward on a REAL GPU** (Thor, sm_110, in-container) | **video max abs diff 1.49e-7 / audio 8.94e-8** — ~134x inside tolerance and on par with the CPU reference's own 1.6e-7. 36/36 cases; the CUDA case is proven to have RUN (220 assertions execute rather than skip), and the CUDA build is 1043/1043 clean, zero warnings |
+| **DEVICE-RESIDENT bf16 PRODUCTION stream** (CPU backend + Thor GPU) | **video 2.41e-3 / audio 2.05e-3** vs the bf16 goldens (tolerance 5e-3) — essentially the CPU reference's own 2.4e-3 / 2.1e-3, i.e. the CAST POINTS agree. Also asserts the bf16 result differs from f32 by >1e-5, so a no-op dtype policy cannot pass |
+| **AdaLN modulate + bf16-cast FOLD** (CPU + Thor GPU) | pass, and byte-identical: after folding the stream-dtype cast into the two modulate kernels the GPU reports the SAME digits (2.4063e-3 / 2.05244e-3 bf16; 1.49012e-7 / 8.9407e-8 f32) and the same 9481-assertion count. Removes 5 launches per forward in bf16 (4 per block + 1 in the final layer). NO speed number: the only GPU here (sm_110) cannot run the production FP4 config and the gate is at reduced dims, so launch count is the honest unit |
+| **TRUE bf16 STORAGE** (bf16 activations + bf16 weights, fp32 islands preserved) | **video 6.16e-4 / audio 5.21e-4** vs the bf16 goldens — a **~4x improvement** on the 2.41e-3 / 2.05e-3 of the round-in-place stream. The bf16 golden was generated WITH bf16 weights, so matching upstream's weight dtypes (not just its activation cast points) moves us onto the golden's actual model. Activation bytes halve and the shared ops take their native bf16 paths |
+| **KEEP-QUANT GGUF arm** (Q8_0 projections stay block-encoded) | pass — resident weight bytes **3.77x smaller** (215,424 B vs 811,008 B on the gate's synthetic checkpoint), and the forward agrees with the DEQUANTIZED load at **video 4.39e-5 / audio 7.50e-5** (only the K-reduction order differs). Gate also asserts the load actually kept tensors quantized, left 1-D norms/biases alone, and produced non-zero output — the exact failure mode a keep-quant slice hits when its bytes never reach the device |
+| **KEEP-QUANT GGUF arm ON A REAL GPU** (Thor, sm_110) | pass — 2/2 cases, and the CPU and CUDA runs report *different* digits (4.39323e-05 vs **4.39249e-05**), which is the proof the CUDA case exercised `kMatmulBTQuant`'s own kernel rather than repeating the CPU path. Confirms the arm's premise: block-quant needs no fp4 tensor cores, so it runs natively on an arch where NVFP4 can only be emulated |
+| **AUDIO-VAE checkpoint loader** (path 2, first component) | pass — name mapping gated against the REAL 1087-tensor manifest (2770 assertions) and an end-to-end load-and-decode producing a finite in-range waveform. Found the shipped file uses LEGACY `weight_g`/`weight_v` (not the parametrization spelling the decoder reads) and prefixes BigVGAN with `decoder.` while `dec_in_proj.*` is top level |
+| **VIDEO-VAE checkpoint loader** (path 2) | pass — 560-tensor manifest mapping asserted injective; found and closed a MISSING STEP (`post_quant_conv`, a 1x1x1 channel mix outside ViT3DDecoder that nothing applied) |
+| **THIRD weight-norm spelling** (repackaged community VAE bundles) | pass — those bundles fold the weight-norm at conversion and ship a plain `<conv>.weight`. The loader reconstructs the (g, v) pair EXACTLY (v = w, g = per-slice ‖w‖), so the decoder's own materialization returns the checkpoint weight: round-trip error **1.49e-08**. `dec_in_proj` is excluded (a plain Conv1d, not weight-normalized) |
+| **SHIPPED VAE config.json parsing** | pass — both real configs embedded verbatim and parsed into the decoders' configs plus their per-channel `latents_mean`/`latents_std` (32 audio / 24 video). Catches the trap that `latent_dim` (2048) is BigVGAN's mel count while `latent_channels` (32) is the VAE latent width — reading the wrong one is wrong by 64x |
+| **ENCODER checkpoint loader** (path 2, final component) | pass — q/k/v and gate/up fused byte-exact and IN ORDER across shards (398 assertions). Order is load-bearing: the forward slices qkv_proj at [0,q)/[q,q+kv)/[q+kv,..), so a wrong order would still run and silently feed keys into the query path |
+| **ASSEMBLY: `minimax-h3-gen` driver** | pass (LOAD + PLAN) — opens a GGUF DiT (dequant AND keep-quant), both VAE safetensors and both real config.json files, derives text_len from the prompt embeddings and plans the shape: 768x1344 canvas / VAE ratio 16 = **48x84** latent, latent_t 62, 50 steps. **NOT yet verified: a full generation on a REAL checkpoint** — that needs the multi-GB download, and no such run has happened |
+| **DEVICE path through the WHOLE pipeline** | pass — the denoise loop now stages the DiT weights ONCE and runs every step device-resident, instead of calling the CPU reference forward. Gated by re-running the whole t2va path on CUDA and comparing frames AND waveform against the CPU pipeline (tolerance 2e-3, the same class the DiT forward is held to, carried through both VAEs). This is what makes a real-checkpoint run feasible at all: 50 layers x hidden 5376 x ~250k latent positions x 50 steps is not a CPU workload |
+| **`/v1/videos` wired in `examples/server`** | builds and stays OPT-IN (36/36 api-server cases unchanged; no `--video-dit` => routes unregistered). Loads the DiT + both VAEs + both configs at startup and registers a runner that generates → frames+WAV → ffmpeg → MP4. **Text conditioning NOT wired**: the prompt does not steer output until the H3-Encoder is, and the server says so at startup |
+| **FIRST REAL-CHECKPOINT RUN** (Thor sm_110, MiniMax-H3-FL2VA-Q3_K_M, 15.58 GB) | **The real DiT LOADS and its forward RUNS on GPU.** Geometry recovered from GGUF shapes alone: layers=50, hidden=5376, heads=56. ★ **keep-quant is REQUIRED, not an optimization**: the dequant path is OOM-KILLED (Q3_K -> f32 is ~145 GB vs 122 GB of unified memory); keep-quant fits in 15.6 GB. Measured (VT_H3_PROGRESS): weight staging to device **32.8 s ONCE**, DiT forward **200 s/step at seq_len 576**. NOT yet an end-to-end video: the run timed out in the VIDEO VAE DECODE, which is still CPU-ONLY (36-layer, dim-2048 ViT3D on the host) — that is the next blocker, and it is a missing device path, not a tuning problem |
+| **★ END-TO-END VIDEO ON REAL WEIGHTS** (Thor sm_110) | **PASS — a playable MP4 out of the real 15.58 GB checkpoint.** `ffprobe`: h264 / yuv420p 128x128 + AAC stereo 32 kHz. Run: latent 2x8x8, 2 steps, `EXIT=0` in **6m22s** — staging 22.3 s, DiT forward **21.1 s/step at seq_len 64**, remainder in the CPU-only VAE decode. Chain proven: GGUF keep-quant load -> device denoise loop -> post_quant_conv -> ViT3D video decode + BigVGAN audio decode -> PPM+WAV -> ffmpeg mux. NOT prompt-conditioned (the encoder is not wired, so the conditioning is a fixed embedding file) |
+| **★ `/v1/videos` SERVED from the OpenAI example server** (Thor) | **PASS end to end over HTTP.** `examples/server` started with the Qwen3-0.6B LLM AND the H3 checkpoints logs `/v1/videos on (dit layers=50, device=cuda, keep-quant)`. `POST /v1/videos` returned `{"id":"vid_1","status":"queued"}`; polling `GET /v1/videos/vid_1` reached `succeeded` with an `output_path`, and ffprobe confirms that file is h264 / yuv420p 128x128 + AAC stereo 32 kHz. An unknown id correctly 404s. Server-side trace: staging 58.0 s, DiT forward 22.4 s/step. The prompt is NOT yet conditioning (encoder unwired) and the server says so at startup |
+| **★★ PROMPT-CONDITIONED video, end to end on real weights** (Thor) | **PASS.** `--prompt "a cat playing a piano"` -> tokenizer (5 tokens) -> block-quant embedding gather -> the 32B keep-quant encoder on device -> conditioning **[5, 5120]** -> DiT -> VAEs -> MP4 (ffprobe: h264/yuv420p 128x128 + AAC stereo 32 kHz), `EXIT=0`. No `--video-prompt-embeds` anywhere in the path. Both towers resident at once: DiT 15.6 GB + encoder 13.2 GiB. Encoder staging 162.3 s, DiT 21.6 s/step at seq_len 64 |
+| **★★ ATTENTION on sm_110: 27x on the H3 step loop** (Thor) | **PASS.** sm_110 has NO FlashAttention-2 (the `fa2` cell is `8.0,8.6,8.7,8.9,12.0a,12.1a`), so H3 fell back to `DFlashBlockAttentionKernel` — one BLOCK per query row, walking keys ONE AT A TIME with a shared-memory tree reduction and ~11 `__syncthreads()` per key, re-reading Q from global for every key. That is O(seq^2) with a barrier in the inner loop, and it made the cost QUADRATIC: **14.61 s/step at seq 576 but 509.78 s/step at seq 3264**. Added a warp-per-query fast path (Q and the online-softmax accumulator in REGISTERS, `__shfl_down_sync` reductions, ZERO barriers), taken when `head_dim` is a whole number of warp widths — 64 and 128 cover every head here. Measured with the new `--denoise-only`: **18.68 s/step at seq 3218**, i.e. **~27x**, and the scaling is now near-LINEAR in seq (5.6x the sequence for 1.28x the time) rather than quadratic. Same online-softmax recurrence, so this is a scheduling change, not a numerical one: gated by `test_ops_dflash_block_attn` (198,412 assertions), `test_ops_dflash_paged_block_attn` (795,648), `test_ops_attention` and `test_qwen27_dflash_spec_decode`, all green on the sm_110 board |
+| **★★★ ATTENTION on sm_110, ROUND 2: chunked warp REDUCE-SCATTER — 1.76x on the whole H3 step, 1.80x on attention** (Thor) | **PASS.** The warp-per-query kernel above left attention at **0.63 TFLOP/s against 30.0 TFLOP/s for our own cuBLASLt GEMMs on the same chip** — 47x — because it still reduced ONE KEY AT A TIME: ~4 useful FMAs per lane, then a 5-stage `__shfl_down_sync` tree plus a broadcast, and every key's `(m, l, acc)` update read the previous key's, so the warp was LATENCY-bound at ~8% of the CUDA-core ceiling rather than throughput-bound at the ~32% its instruction mix allowed. `DFlashAttnChunkKernel` processes keys **32 AT A TIME**: each lane keeps its 32 per-key partials in registers, ONE butterfly **reduce-scatter** (5 rounds, **31 shuffles** against 192, with compile-time array indices so `p[32]` never spills) turns the 32x32 partial matrix into “lane L holds the complete score for key L”, and there is **one online-softmax update per 32 keys instead of 32** — 2 `expf` per chunk against 64. Loads stay `lane == element` and COALESCED (the partition is contiguous+vector at head_dim 64/128, strided at 96, whichever keeps the warp's sectors minimal). Same-binary A/B, `--denoise-only --steps 3`, **per FORWARD**: **seq_len 3264 28.08 → 16.33 s (1.72x)**, **seq_len 6080 91.61 → 51.97 s (1.76x)**, **seq_len 15424 558.39 → 316.95 s (1.76x)** — the warp arm reproduces the standing 28.16/91.81/559.46 s baselines to within 0.3%. A joint `t = G*seq + A*seq^2` fit with a SHARED linear term (the GEMMs are untouched) puts attention at **542.81 → 301.01 s** at the production canvas, i.e. **1.80x** and **0.63 → 1.13 TFLOP/s** over the 341.1 TFLOP that canvas actually costs (seq 15424, head_dim 128, 56 heads, 50 layers). A 50-step 864x480/124f render goes from **~7.8 h to ~4.4 h**. Still only ~15% of the ~7.7 TFLOP/s CUDA-core ceiling — the residual is the reduce-scatter itself plus the bf16→f32 converts, **NOT** memory. ★ RED PROOF (a green suite does not prove the kernel ran): perturbing this kernel's store by 1.001x turned **7 of 12 cases red, 193,127 assertions**, and the 7 are exactly the CUDA-touching ones — the 5 semantic corners, LONG causal, LONG SWA, LONG non-causal, LONG multi-request (H3's real `{0, used, seq_len}` TWO-document packing), LONG ragged causal, and the new LONG head_dim 96 case; reverted, 12/12 green again. Gates on the sm_110 board: `test_ops_dflash_block_attn` 12/12 (3,260,884 assertions), `test_ops_dflash_paged_block_attn` 1/1 (795,648), `test_ops_attention` 9/9, `test_qwen27_dflash_spec_decode` 3/3, `test_minimax_h3` 62/62. **head_dim 96 was previously UNTESTED** — the fast path's `head_dim/32 == 3` instantiation shipped unexercised (every case was 16/32/64/128), so two short and two LONG d=96 cases were added with it. ★ `--denoise-only` also had a real REPORTING bug: an N-sigma schedule runs N-1 forwards but the driver divided elapsed time by N, under-reporting per-forward cost by 1.5x at `--steps 3` — enough to make an A/B look like a regression. It now prints `forwards=` and `per_forward=`. |
+| **★★★★ ATTENTION on sm_110, ROUND 3: bf16 TENSOR CORES — 9.82x on the whole H3 step, 13.5x on attention** (Thor) | **PASS.** Rounds 1 and 2 rescheduled attention; both left it on the CUDA CORES, and after the reduce-scatter it still ran at **1.09 TFLOP/s against 30.0 TFLOP/s for our own cuBLASLt GEMMs on the same chip** — the residual was never a scheduling problem, it was the wrong MATH UNIT. `DFlashAttnMmaKernel` puts BOTH GEMMs of attention on the bf16 tensor cores with `mma.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32`. PROBED first, not assumed: that instruction assembles, launches and accumulates on sm_110 — the `kind::mxf4nvf4` restriction recorded for this box is specific to the BLOCK-SCALED FP4 MMA and does not reach standard bf16 MMA, so "sm_110 is portable-kernels-only" was too strong. SHAPE: one WARP owns 16 query rows and the FULL head_dim of output, 4 warps per block share a staged 32-key K/V tile, `S = Q·Kᵀ` is d/16 k-steps x 4 n-tiles and `O += P·V` is 2 k-steps x d/8 n-tiles. **S, P and the entire O accumulator stay in REGISTERS**: the m16n8k16 C fragment (rows gid/gid+8, cols tig*2+{0,1}) IS the next MMA's A fragment, so P needs zero shuffles and zero shared round-trip, and the online-softmax (m, l) state reduces across a QUAD with two `__shfl_xor` — no block barrier at all. Only K and V are staged: **17,408 B/block at head_dim 128** (4,608 B at 64), which is HALF what the round-1 shared-memory attempt spent when it measured 23% slower. **168 registers/thread, STACK 0, LOCAL 0 (no spill)** => 3 blocks x 4 warps = **12 of Thor's 48 warps/SM, 25% occupancy, register-limited** — deliberately low, which is what a tensor-core kernel trades for. K-fragment shared reads are conflict-free by construction (row stride d+8 => an ODD multiple of 4 banks); the V fragment reads a COLUMN, which is 4 separate 16-bit loads but still conflict-free (lane pairs land on the same 32-bit word and BROADCAST). **Same-binary A/B** (`VT_DFLASH_ATTN_MMA=0` selects the round-2 arm), `--denoise-only --steps 3`, **per FORWARD**: **seq_len 3264 16.34 → 3.25 s (5.03x)**, **seq_len 6074 51.96 → 7.11 s (7.31x)**, **seq_len 15421 321.13 → 32.71 s (9.82x)** — the disabled arm reproduces the standing 16.33/51.97/316.95 s baselines to within 1.3%. A joint `t = G*seq + A*seq^2` fit over all six points with a SHARED linear term (the GEMMs are untouched) puts attention at **311.6 → 23.1 s** at the production canvas, i.e. **13.5x** and **1.09 → 14.75 TFLOP/s** over that canvas's 341.1 TFLOP. A 50-step 864x480/124f render goes from **~4.4 h to ~27 min** (from ~7.8 h before round 2). Still only ~11% of Thor's bf16 tensor-core peak: the next lever is `ldmatrix.trans` for the V fragment (it would collapse 128 scalar shared loads per warp per key-tile into a handful of instructions) and a wider key tile, neither attempted here. **NUMERICS, stated rather than hidden**: Q/K/V are already bf16 in the production stream so QKᵀ loses nothing, but the P·V GEMM must round the probabilities to bf16 exactly as FlashAttention does — a bounded ~2^-9 relative perturbation. So this path is gated at a **bf16 tolerance (5e-3 max, 1e-3 RMS)**, the same bar `test_minimax_h3` already uses for its bf16 stream, and **f32 inputs deliberately stay on the CUDA-core kernel**, which still gates at 2e-5. Nothing was loosened: the f32 cases are unchanged and still green. ★ RED PROOF: perturbing this kernel's store by +0.25 turned **2 of 15 `test_ops_dflash_block_attn` cases red (26 assertions)** — exactly the two new bf16 parity cases — and **1 of 62 `test_minimax_h3` cases red**, which is the CUDA bf16 DEVICE FORWARD, proving the kernel is on the real H3 production path and not merely on a unit test; `test_ops_dflash_paged_block_attn` and `test_ops_attention` stayed green (they do not route here), and reverting restored 15/15 and 62/62. ★ The f32-only CUDA coverage would have shipped this kernel NEVER-EXECUTED — every pre-existing CUDA case in `test_ops_dflash_block_attn` uploads f32 — so bf16 coverage was added with it: 7 short semantic corners (non-causal/causal/block-isolation/SWA/GQA-extreme/d=96/bf16-out), 6 LONG cases (two-document `{0, used, seq_len}` at d=128, d=96, causal, SWA, ragged causal, ragged non-causal) and a bf16 RED case pinning causal-vs-non-causal separation at >0.5, ~100x the tolerance the parity cases allow. Gates on the sm_110 board: `test_ops_dflash_block_attn` **15/15** (6,352,687 assertions), `test_ops_dflash_paged_block_attn` 1/1 (795,648), `test_ops_attention` 9/9, `test_qwen27_dflash_spec_decode` 3/3, `test_minimax_h3` 62/62. |
+| **One-key-per-lane attention — MEASURED NEGATIVE, not dispatched** | The obvious way to delete the per-key reduction is to give each lane a WHOLE key: lane L computes the entire d-length dot product for key `base+L` with Q broadcast from shared, so no lane ever reduces against another. Implemented, RED-proved (perturbing its store turned 6 of 11 cases red, 168,630 assertions, all five LONG cases among them) and measured: **43.35 s/forward against 28.08 s for the incumbent at seq_len 3264 — 54% SLOWER**, same binary. **WHY**: giving a lane a whole K row makes every K load instruction **32-WAY SCATTERED** (one 32-byte sector per lane, ~32 per instruction against 2–4 coalesced). The rows are L1-resident so nothing reaches HBM, but the load/store unit still replays every address — the work simply moved from the shuffle pipe to the memory pipe. That is the measurement that produced the winning design: kill the per-key reduction WITHOUT surrendering `lane == element` coalescing, which is what the reduce-scatter does. Kept in-tree behind `VT_DFLASH_ATTN_KEYLANE=1` so the three-way verdict reproduces on ONE binary. |
+| **Q-BLOCKED attention — MEASURED NEGATIVE, reverted; and it CORRECTS the diagnosis above** | Carrying kQ queries per warp loads each K/V row once and reuses it kQ times, in REGISTERS (ptxas: 64 regs at kQ=4, 108 at kQ=8, zero stack, zero local, no shared memory — deliberately avoiding what sank the tiling attempt). Paired reps, order reversed between arms, box noise <=0.07%, 2-step `--denoise-only` totals: at 864x480 seq 15424 baseline **557.81/557.78 s** vs kQ=4 **553.13/553.15 s (-0.84%)** and kQ=8 **765.57 s (+37.2%)**; at 512x512 seq 3264 baseline **28.05/28.03 s** vs kQ=4 **28.99 s (+3.32%)**. Output checksums identical across all arms. REVERTED: a wash at the production canvas does not buy a reproducible regression at the short one. ★ **The premise was WRONG, and it was the same wrong premise behind the shared-memory attempt**: one head's K+V at seq 15424 is **3.9 MB against Thor's 32 MB L2**, and every warp on a given `blockIdx.y` streams the same rows — so the ~341 TB/step figure was never the bound, that traffic was already L2-resident. Q-blocking removes re-reads that cost nothing and does NOT remove the per-key warp-shuffle reduction (kQ of them per K row, the same total), while adding a serial expf dependency chain of kQ softmax updates — which is why kQ=8 is far worse than kQ=4 rather than twice as good. **The open lever is the per-key REDUCTION, not the memory source** — TAKEN, and the row above records how: one key per lane was the WRONG way to take it (54% slower, it scatters the loads), a chunked reduce-scatter is the right one (1.76x). Kernel kept in-tree uninstantiated and annotated, since a part with small L2 relative to one head's K/V could flip the verdict. ★ Green suites do not prove a kernel RAN: verified by a RED proof (perturbing the Q-block store turned 6/11 cases red, 2,321,426 -> 195,823 failures) and three new LONG cases — causal T=2560, causal sliding-window T=2048/D=128/window=48, and ragged multi-request T=2185 in both masks. The two pre-existing long cases are both non-causal single-document, the one mask where every query sees the SAME key range, so they could not have caught a per-query mask bug |
+| **Shared-memory K/V tiling for long attention — MEASURED NEGATIVE, reverted** | At the real default canvas (864x480 / 124f, latent 37x30x54) a step costs **557.74 s at seq_len 15424**: 4.7x the sequence of the 512x512 run for 29x the time, so ~85% of the step is attention and the quadratic term dominates again. Tried staging K/V tiles in shared memory so a block's warps share the keys they read. Result: **686.91 s/step — 23% SLOWER**, reverted. Diagnosis: tiling moved where K comes from, but the real cost is the per-key warp-shuffle reduction (5 shuffles + a broadcast for EVERY key), which is unchanged, while 32 KB of shared memory per block crushed occupancy — and K/V were likely already being served from L2. **The promising direction is one reduction per 32 keys rather than one per key.** Both ways of getting there have since been ATTEMPTED and measured: one key PER LANE (a whole d-length dot product per lane, Q in shared) is **54% SLOWER** because it scatters the K loads, while a chunked **reduce-scatter** that keeps `lane == element` coalescing is **1.76x FASTER**. See the two rows above. ★ The first version of this kernel also silently never ran: it was guarded to `num_reqs == 1` while H3 packs `{0, used, seq_len}` (content + padding = TWO documents), and the step time came back byte-identical, which is what exposed it. The long-sequence gates added to catch that are KEPT — nothing in the suite previously exercised attention above seq 2048 |
+| **ref2va VIDEO references (silent) wired** | pass — needed NO new porting: the 3D CNN is causal in time, so a clip is the image path with `t > 1`. Emitted as a **kVideoAudio** block, because `kImage` counts exactly ONE frame however large its `latent_t` — a clip returned as kImage would silently lose its temporal extent, so the gate asserts a video reference occupies MORE rows than an image one. `ref_audio_t = 0` keeps it honest: no audio rows are claimed, since the audio-VAE encoder that would fill them is not ported, and a video reference WITH audio THROWS. Moves the video rows by **0.83** under identical prompt/noise/schedule. Driver `--ref-video DIR` reads `DIR/frame_%06d.ppm` — exactly what this example WRITES — so a previous run's workdir feeds straight back in as a reference, which is how clips get chained |
+| **ref2va IMAGE REFERENCES wired; audio references REFUSED** | pass — reference blocks now build the ref2va packed layout and their visual rows ride the same pinned-condition mechanism keyframes use, so this reuses the image→latent path rather than duplicating it. Gated on the same load-bearing property as fl2va: an image reference **moves the video rows by 0.98** under identical prompt, noise and schedule. Two refusals are gated as behaviour, not left to chance — an AUDIO reference block THROWS (the audio VAE's ENCODER is not ported, only its decoder, so honouring one is impossible and silently conditioning on nothing would be worse), and fl2va + ref2va together THROW as mutually exclusive. Driver: repeatable `--ref-image f.ppm`. Audio-bearing blocks are covered by the row below (the audio-VAE ENCODER landed); what is refused now is an audio-bearing block with no encoded rows behind it |
+| **★ AUDIO-VAE ENCODER ported; ref2va AUDIO and VIDEO+AUDIO references wired** | pass — the last two unwired conditioning modes. The shipped `DacAudioVAE` exposes only `decode` (dac_audio_vae.py:211-225), so the encode path was composed the way vLLM-Omni composes it (vae.py:317-325): `preprocess` right-pad to a whole hop -> DAC `Encoder` (Snake1d, three dilated ResidualUnits per block, the strided conv stack) -> `pre_block` `AttnProjection` (causal SDPA, MEAN over heads, adaptive-average-pool narrowing 2048->32, GeGLU MLP) -> `mean_proj`. Gated STAGE BY STAGE against the CHECKPOINT'S OWN remote code executed at reduced dimensions by `scripts/gen-minimax-h3-audio-vae-encoder-goldens.py`: **conv stack 2.98e-8, AttnProjection 1.64e-7, whole encode-to-latent 1.86e-8**. `mean_proj` and never `logs_proj` — a sampled reference would condition differently every run, so `logs_proj` is not even loaded. `LoadMiniMaxH3AudioVaeEncoderWeights` takes the half the decoder loader skips, gated against the same REAL 1087-tensor manifest (which also confirms the shipped geometry from shapes alone: encoder_rates [2,4,4,5,5], latent_dim 2048, attn_proj_dim 32) and accepting all three weight-norm spellings, the materialized one reconstructed to **<=1e-6** round-trip. Wiring gated on the load-bearing property, not on acceptance: an AUDIO reference **moves the audio rows by 0.51** and the video rows by 5.5e-3; a VIDEO+AUDIO reference moves the audio rows by **0.71** and the video rows by 5.5e-3 against the SILENT same-clip control; and a DIFFERENT reference waveform moves the audio rows by **7.1e-4**, which is what a wiring that reserved the rows and pinned a constant would fail. Audio-bearing blocks with no rows behind them still THROW. Driver: `--ref-audio f.wav`, backed by `MiniMaxH3ReadWav` in the library (16-bit PCM, chunk-list walk, mono repeated to stereo), gated against the writer it inverts and REFUSING a non-32 kHz file rather than mis-encoding it. NOT covered: no real-checkpoint reference-audio render has been run |
+| **fl2va REFERENCE CONDITIONING wired end to end** | pass — the fl2va primitives were all ported and gated in PIECES (packed keyframe layout, the VAE 3D-CNN encoder, condition-noise augmentation, the loop's pinned condition rows) but nothing connected them, so the feature was UNREACHABLE: `MiniMaxH3GenerateT2va` passed `{}` for both conditioning arguments. Closed the two real gaps — the decoder loader deliberately skips `encoder.*`, so `LoadMiniMaxH3VideoVaeEncoderWeights` now loads the encoder half (strips `encoder.`, KEEPS `quant_conv` which is the encoder's output stage), and `MiniMaxH3VideoVaeEncodeToLatent` takes the distribution MEAN rather than a sample so one reference image conditions identically every run. fl2va is modelled as a PARAMETERIZATION of the t2va pipeline rather than a parallel path, exactly as upstream models it. The gate asserts the thing that matters: with identical prompt, noise and schedule, conditioning **moves the video rows by 1.20** — a wiring that accepted the rows and ignored them would produce perfectly finite, correctly shaped output and pass every structural check. Caught in the process that `z_channels` is the MOMENTS width (48), not the latent width (24). Driver: `--first-frame` / `--last-frame` (binary PPM, the format this example already writes, so one run's frame can condition the next) and `--noise-aug` |
+| **★★★ Q3_K_M IS NOT USABLE FOR THIS MODEL — use Q4_K_M** | **One bit is the difference between unusable and production-grade.** Controlled A/B at 864x480/124f/50 steps: identical prompt, seed, code and VAE, ONLY the DiT quantisation changed. Q3_K_M gives a murky silhouette with a visible lattice; **Q4_K_M gives a photoreal facial close-up** — correct anatomy, hair detail, layered robes, bamboo receding into mist, snow as genuine bokeh. Measured on the same frame (period score vs a ~1.00 control): the VAE-patch lattice at p16 collapses **1.18 -> 1.07** and the DiT-token lattice at p32 **1.19 -> 1.13**, with mean exposure 50.7 -> 60.7. Upstream predicted exactly this: ComfyUI PR 15298 reports H3's partial split-half RoPE creates **channel-wise magnitude outliers that corrupt INT8 quantization** — so 3-bit K-quant is well past the edge, and the artifact appearing at the DIT-TOKEN period (32 px = 1 token) is the signature of per-token weight error, not a layout bug. ★ This A/B cost ~28 min per arm ONLY because of the 16.6x attention work; at the original 574 s/forward it would have been 8 h per arm, which is why the quality question stayed open so long. **Q4_K_M (19.9 GB) is the documented default; Q3_K_M is known-bad for H3.** |
+| **★★★ IMAGENET PIXEL SPACE — the missing output stage, found by reading ComfyUI** | **This is why frames were dark and washed out.** The video VAE works in IMAGENET-NORMALIZED pixel space, and the conversions sit OUTSIDE `ViT3DDecoder` in upstream's wrapper: decode ends `dec*std + mean`, clamp [0,1], `*2-1` (comfy/ldm/minimax/vae.py:693) and encode begins `((x+1)/2 - mean)/std` (:659). We did NEITHER — the raw decoder output went straight to a writer expecting [-1,1]. Two compounding errors: the per-channel means differ (0.485/0.456/0.406) so it CAST COLOUR, and std ~0.22 meant the true dynamic range was compressed ~4.4x, which is exactly "dark and low-contrast" (the 864x480 render measured mean pixel **18/255**). Same shape of omission as `post_quant_conv`: outside the decoder, so the decoder's own **1.19e-07** gate could never have caught it. Also fixed on the ENCODE side, so keyframe/reference conditioning had been feeding the CNN [-1,1] where it wanted ImageNet space. Gated per channel, not just on a round trip — a shared mean/std would round-trip perfectly and still cast colour — plus the clamp ORDER (before the [-1,1] map, so out-of-gamut saturates at exactly +/-1 rather than overshooting) |
+| **★★★ VIDEO DECODE FIXED: temporal chunking AND spatial tiling COMPOSE** | **Resolved.** Neither alone is upstream's behaviour, and either alone is WORSE than neither. Measured on the same prompt/seed/steps at 512x512 (period-16 patch-grid score, control period-13 in brackets): untiled+unchunked 20st **2.64** [0.96], spatial-tiling only **2.80** [0.99], untiled+unchunked 50st **3.33** [1.00], **temporal-only 4.20** [1.00] — the WORST of any run — and **temporal+tiled 2.46** [0.98], versus **2.12** for the 256 single-tile reference where tiled and untiled coincide. The composition comes from upstream's own chunk loop: `clip_dec = self._adaptive_decode(clip_z)`, so each TEMPORAL chunk is ALSO spatially tiled when tiling is on. Running one without the other is a third thing upstream never does — which is exactly what the two previous attempts each tested. The 512 output is now near the single-tile reference and the residual is the inherent patch texture of a patch-based ViT decoder, not an artifact. Independent cross-check: our chunk arithmetic yields 39 frames (17+17 blended+5) and the frame planner's own `17n+5` alignment of a 33-frame request also lands on 39 — two unrelated derivations agreeing |
+| **★★ TEMPORAL CHUNKING — read out of upstream, after two wrong diagnoses** | The video decode was missing `decode_temporal` entirely. Found by reading the CHECKPOINT'S OWN `klvae.py` rather than inferring from output: `decode_base` routes video through **`decode_temporal`**, never a single pass, and the ViT is handed `tokens_chunk_size + token_overlap` temporal tokens at a time. Shipped config (clip_length 17, token_drop 3, vae_ratio_t 4) ⇒ chunk 5, overlap 2, pre-pad 3, frame-overlap 5, so a 12-token latent decodes as **2 chunks of 7 tokens — never 12**. Same mechanism as the spatial case: the ViT's RoPE is LENGTH-NORMALIZED over the grid handed to it, so the TEMPORAL extent is part of the input. **This also corrected an earlier wrong call of mine**: upstream does NOT spatially tile the ViT decode — `decode()` calls `self.decoder(z2)` directly, `_adaptive_decode` tiles only when `decoder_tiling` is set, it defaults FALSE, and the shipped `video_vae_config.json` carries no tiling key at all. Every reduced-dimension gate runs at latent_t 2, below one chunk, where chunked and unchunked coincide — the same blind spot that hid the tiling question |
+| **★★ VAE SPATIAL TILING — the cause of the "squared windows" artifact** | **FOUND BY A/B ON REAL OUTPUT, then fixed.** A 512x512 prompted run produced globally-correct frames (recognisable subject, correct scene layout) covered in a grid of small squares. It was NOT quantization: the discriminator is that `MiniMaxH3SplitTiles` plans 512 px as **3 tiles per axis** (starts 0/128/256) but plans 256 px as **exactly 1 tile**, so a 256x256 run is the one size where tiled and untiled are the SAME computation — and 256x256 came out **clean**. Root cause: `MiniMaxH3SplitTiles`/`MiniMaxH3BlendTiles` were implemented and gated but **nothing called them**, and tiling here is NOT a memory strategy — the ViT3D's RoPE coordinates are LENGTH-NORMALIZED (`2*((i+0.5)/n)-1`) over whatever grid it is handed, so the grid EXTENT is part of the input. Feeding a 32x32 latent to a decoder trained on 16x16 tiles gives every token a position the model never saw. Every reduced-dimension gate in the suite is smaller than one tile, which is exactly why none of them caught it. Now wired: `MiniMaxH3VideoVaeDecodeTiledDevice` slices the latent on the pixel plan, decodes each tile, and cross-fades the seams. Gated at both ends — a single-tile canvas is **bit-identical** to the untiled decode (max\|diff\| == 0), and on a 2x2-tile canvas each tile's un-blended interior equals a standalone decode of that tile's own latent slice **exactly** (max\|diff\| == 0), which is what pins down the slicing, placement and seam arithmetic; both failure modes still yield plausible finite frames |
+| **NVFP4 STREAMING loader** | pass — the NVFP4 arm was OOM-KILLED during load on Thor (kernel oom-kill, **anon-rss 125 GB**; the box survived, only the process died). Measured cause, not guessed: `LoadMiniMaxH3DitFromNvfp4` materializes every weight as host **f32**, ~132 GB for the 18.75 GB checkpoint, before any staging doubles it. The GGUF arm never hit this because it already streamed. `StreamMiniMaxH3Nvfp4ToDeviceBf16` is that function's twin — dequantize ONE tensor from its NVFP4 triple, upload, let the host buffer die — so peak is the device copy plus one tensor. Gated against the reference loader rather than on "it loads": values match **EXACTLY (max\|diff\| == 0** — NVFP4 lands on bf16 without rounding), geometry agrees, and `rope.inv_freq` is asserted HOST-resident (the forward reads it before any kernel). The real file verifies as expected: **1051 tensors**, 258 U8 + 258 F8_E4M3 + 258 F32 + 277 BF16, with real `adaln_proj` — i.e. the UNPRUNED variant our forward implements, not the timestep-LUT "pruned" one |
+| **★ DEVICE-RESIDENT video VAE decoder** | **pass — max abs diff 1.19e-07** vs the CHECKPOINT'S OWN remote code (not vs our portable decoder — two implementations agreeing on a wrong answer is a failure mode this tree has already hit), in the same class as the portable path's own 8.9e-8. Gated on CPU and on a real sm_110 GPU. This retires the LAST CPU-only stage in the video path: the portable ViT3D decoder is scalar triple loops with double accumulation, which is what made a 256x256 decode time out. **NO new kernels** — the whole 36-layer decoder maps onto the tuned shared ops given two EXACT load-time weight rearrangements: this checkpoint stores `to_qkv` PER-HEAD INTERLEAVED (`[head][q|k|v]`) where `vt::QkvSplit` wants `[q_all|k_all|v_all]`, so the weight ROWS are permuted once at stage time; and each branch's `h += scale * (x @ W^T + b)` has a learned PER-OUTPUT-CHANNEL scale, which folds into the preceding projection's rows and leaves a plain `vt::Add`. Both folds are silent-failure shaped (a wrong permutation still yields plausible finite frames), which is why the gate is against upstream |
+| **ENCODER keep-quant GGUF loader** (qwen3vl-32B Q4_K_M, 902 tensors) | pass — holds the 32B tower at ~14.6 GB instead of the ~128 GB an f32 materialization needs (which does not fit the test box). The q/k/v and gate/up fusions are done on the QUANTIZED bytes and gated BYTE-FOR-BYTE against `q ++ k ++ v` / `gate ++ up`: sound because ggml rows are independent block sequences and every K here is a multiple of the 256-element block, so no dequantize/requantize round trip is needed. Geometry recovered from the fused shapes; `norm.weight` correctly NOT bound (H3 reads the unnormalized truncated output) |
+| **ENCODER loaded from the REAL 14.58 GB file** (Thor) | pass — **13.24 GiB resident keep-quant**, loaded ALONGSIDE the keep-quant DiT, with geometry recovered from shapes alone: layers **50** (truncated from the file's 64 — H3's own min(num_hidden_layers, 50)), hidden 5120, heads 64, kv_heads 8, head_dim 128, ffn 25600 — i.e. Qwen3-32B with 8:1 GQA. Found on the real file that the K_M recipe stores `v_proj` as Q6_K while q/k are Q4_K, so that group is kept UNFUSED rather than dequantized |
+| **★ DEVICE keep-quant ENCODER forward** | **pass — max abs diff 3.76e-4** vs the gated host f32 reference on a scale of ~1.0 (0.04% relative), which is Q8_0 quantization error and nothing else: both paths run the SAME dequantized numbers, so the only difference is where quantization enters. The 32B tower runs from its ggml blocks — projections go through `vt::MatmulBT`, which dispatches `kMatmulBTQuant` — with NO dequantization on the path. All three H3 deltas preserved (layer truncation, UNNORMALIZED output, DeepStack left to the caller), and M-RoPE reuses `vt::RopeFromCache` because upstream's `cat(freqs, freqs)` makes cos/sin repeat across halves |
+| **Embedding gather from the block-quant table** | pass — decodes ONLY the requested rows and is **BIT-IDENTICAL** to slicing a full-table dequant (valid because ggml rows are independent block sequences). Matters because the table is [151936, 5120] (~1.5 GB quantized) while a prompt touches a few dozen rows. Out-of-range ids THROW rather than read past the table |
+| **post_quant_conv WIRED into the t2va pipeline** | pass — re-running the whole t2va path with the tensor present shifts the frames by **0.056** while leaving the waveform BIT-IDENTICAL (a video-side wrapper tensor must not touch audio). Without this the wiring would be a branch no test enters, which is how the step went missing originally |
+| **WHOLE t2va path composes** | frames + stereo waveform, correct shapes, finite, in [-1, 1] |
+| **GGUF load -> runnable DiT** | geometry from shapes; a real forward runs off the loaded weights |
+| **NVFP4 load -> runnable DiT** | compressed-tensors triple dequantized; a real forward runs |
+
+**Reproduce:** `cmake -S . -B build-cpu -DCMAKE_BUILD_TYPE=Release -DVLLM_CPP_CUDA=OFF`
+then `cmake --build build-cpu --target test_minimax_h3 -j16 && ./build-cpu/tests/test_minimax_h3`
+(34/34 cases, 9233 assertions). Regenerate goldens with
+`python3 scripts/gen-minimax-h3-goldens.py --vllm-omni <checkout> --out tests/vllm/models/minimax_h3_goldens.inc`;
+regenerate the GGUF manifest by range-fetching the first 4 MiB of the .gguf and running
+`scripts/gen-minimax-h3-gguf-manifest.py`.
+
+**Next gate:** download a quantized checkpoint and close the e2e loop (encoder -> VAEs -> pipeline), then W2b/W10 for speed. See
+[.agents/specs/minimax-h3.md](../.agents/specs/minimax-h3.md).
+
+
 ## Laguna-S-2.1-NVFP4 decode — router top-k KERNEL-EFFICIENCY (`VT_LAGUNA_TOPK_SHFL`), BYTE-EXACT, SigmoidTopK 1.67×, −0.57% decode-step GPU (2026-08-03, `CLAIM-LAGUNA-TOPK-SHFL`)
 
 With the residual-norm byte-exact floor reached (`CLAIM-LAGUNA-FAST-NORM` below), a fresh `nsys cuda_gpu_kern_sum --cuda-graph-trace=node` 2-length diff (20-vs-70) ranked the remaining small kernels; excluding the at-parity projection GEMVs (`gemvx`, ~69% of decode step — the IDENTICAL cuBLAS kernels vLLM uses) and the Marlin MoE (we win) / attention-compute kernels, the router `SigmoidTopKKernel` was the single largest still-optimizable small kernel (415 µs/step, 1.6%). Same box/model/ids/env as below (`~/laguna-xs-nvfp4`, ids `2,785,9626,377,15360,395`, `VT_LAGUNA_RESIDENT_DECODE=1 VT_LAGUNA_MARLIN_MOE=1 VT_LAGUNA_DECODE_GRAPH=1`), origin/main `e61b4de3`.
diff --git a/docs/ENVIRONMENT.md b/docs/ENVIRONMENT.md
index 0e00d92b7..10bfc7944 100644
--- a/docs/ENVIRONMENT.md
+++ b/docs/ENVIRONMENT.md
@@ -85,6 +85,7 @@ Read-only observability; none change output.
 | `VT_OP_PROVIDER_DISABLE` | (none) | Comma-separated provider names to disable, forcing fallback (diagnostic) |
 | `VT_GDN_VALIDATE` | off | Run the GDN validation/cross-check path (slower; for kernel debugging) |
 | `VT_FP4_AUTOTUNE_VERBOSE` | off | Log the NVFP4 GEMM autotuner's tactic selection |
+| `VT_H3_PROGRESS` | unset | Trace the MiniMax-H3 denoise loop's phases to stderr: which forward path was taken (device vs the CPU reference), how long the ONE-TIME device weight staging took, and per-step forward seconds with the sequence length. A real-checkpoint run spends its minutes in exactly one of those phases, and this says which without guessing — it was added after GPU-utilization counters proved unreliable on Tegra-class boards |
 | `VT_POOL_BYPASS` | off | `=1` makes every device-scratch pool allocation an exact-size driver `Alloc` and every release a real `Free`, so `compute-sanitizer` can see tensor boundaries and use-after-free that the caching, size-class-rounding pool hides. DEBUGGING ONLY: it reinstates the per-op `cudaMalloc`/`cudaFree` device-sync storm the pool exists to remove, so it is never a timing configuration |
 
 ## Kernel-internal knobs (deferred)
diff --git a/docs/STATUS.md b/docs/STATUS.md
index f2225a2b0..ecd74c3d5 100644
--- a/docs/STATUS.md
+++ b/docs/STATUS.md
@@ -63,6 +63,7 @@ token-for-token correctness against the pinned oracle.
 | OLMo-3 dense (dual rope, interleaved sliding window) | Implemented, oracle-blocked | Loads + runs in our engine (dual rope: plain sliding + YaRN full-attn, per-layer sliding window); no SACRED gate: vLLM 0.25.0 oracle cannot run OLMo-3-1025-7B (`KeyError: 'rope_theta'`; transformers 5.13.1 nests `rope_parameters` per layer-type, no flat `rope_theta`; run-verified W0 2026-07-26) |
 | Laguna-S-2.1 MoE (`LagunaForCausalLM`, 118B/8B) | **REAL vLLM BAR ESTABLISHED (2026-07-31, `CLAIM-LAGUNA-VLLM-NVFP4`): FIRST-EVER vLLM Laguna run** — prior numbers (incl. the correctness oracle) were all llama.cpp, never vLLM. vLLM on official `poolside/Laguna-S-2.1-NVFP4` (single GB10, greedy, eager, MARLIN backend forced via `VLLM_TEST_FORCE_FP8_MARLIN=1` because the auto-default `FLASHINFER_CUTLASS` needs an absent `nvcc`): **~18.8 tok/s** (64-tok steady) — a LOWER bound. Our GGUF-Q4_K engine = 7.7 tok/s (vLLM ~2.4×); llama.cpp GGUF = 27.8 (still fastest at batch-1). llama.cpp is now a labeled SECONDARY "beat best-in-class GGUF" note; vLLM-NVFP4 is the headline bar. TRUE apples-to-apple still owes OUR NVFP4 Laguna forward arm (same tensor-core path as 27B/35B) — bring-up W-plan SPEC'D in `.agents/specs/laguna-nvfp4-arm-2026-07-31.md` (~85% reuse of the 35B NVFP4 W4A4 MoE infra + a name-map; bf16 attn/dense + fp4 experts; N1-N5 bricks, DGX-gated). **N1-scaffold LANDED (2026-07-31):** additive `LagunaMoeWeights.experts_{gate,up,down}_fp4` + `shared_{gate,up,down}_fp4` (`Nvfp4Weight`, mirror qwen3_5), dead until the N1 loader; CPU build clean + `test_laguna_scaffold` 8/8·167 unchanged. **N1b loader IMPLEMENTED (2026-07-31, build-verified):** `LoadLagunaForCausalLMWeights` (`laguna_weights.cpp`) replaces the `VT_CHECK(false)` stub — resolver + per-layer `LoadBf16Direct` (attn/dense/norms/embed/lm_head/router/shared-expert) + F32 `e_score_correction_bias` + `LnLoadCtNvfp4Raw` W4A4 experts. Name-map + dtypes VERIFIED against the real `poolside/Laguna-S-2.1-NVFP4` index (router `mlp.gate` BF16, bias F32, experts W4A4, shared-expert BF16). **N1b RUN-VERIFIED (2026-07-31):** `test_laguna_nvfp4_loader` 2/2·29 — a synthetic 2-layer NVFP4 checkpoint (L0 dense, L1 MoE 2 W4A4 experts) round-trips byte-identically through the real loader (BF16 weights, expert packed/scale byte-identical + `scale2`/`alpha` math + per-expert indexing distinct, F32 bias, shared-expert BF16; RED-first missing-tensor throws); `test_laguna_scaffold` 8/8·167 unchanged. **N2 FORWARD-BRANCH LANDED + CPU-GATED (2026-07-31):** `LqGemmNvfp4Fp4` (per-expert TRUE-W4A4: `ScaledFp4Quant(input_global_scale_inv)`→`MatmulNvfp4Fp4(alpha)`, unified-memory pattern like `LqGemm`) + `LagunaFfnBlock` branches on `fp4=!experts_gate_fp4.empty()` (routed experts fp4; keep-quant grouped fast-path gated off `!fp4`; bf16 attn/dense/router/shared-expert/lm_head unchanged) + both `LagunaForwardGguf{,Cached}` guards relaxed to `has_gguf_weights||has_nvfp4_weights`. **CORRECTION:** routed experts are W4A4 ⇒ per-expert `MatmulNvfp4Fp4`, NOT the grouped W4A16 `MoeGroupedGemmNvfp4` (grouped W4A4 deferred to N5 speed). `test_laguna_nvfp4_loader` 3/3·61 (added a forward run-gate: fp4 MoE branch runs through the real `LagunaForwardGguf` → finite+deterministic logits + routed-experts-consumed); `test_laguna_scaffold` 8/8 unchanged (GGUF byte-identical). **N3 DRIVER LANDED + CPU-SMOKE-VERIFIED (2026-07-31):** `examples/laguna_gen` auto-detects a safetensors DIRECTORY (→ NVFP4: `LoadHfConfig(config.json)` + `LoadLagunaForCausalLMWeights` + `LagunaForwardGguf{,Cached}`) vs a `.gguf` FILE (→ keep-quant), sharing the greedy loop; `--token-ids` bypass the tokenizer for the id-vs-golden gate. Verified on a synthetic NVFP4 dir with a REAL config.json (exercises the `LoadHfConfig`→`ParseLagunaParams` seam the loader test bypassed) → `has_nvfp4=1`, KV-cache decode runs finite. **N4 RAN on GB10 (2026-08-01) — the arm works end-to-end; correctness coherent+near-tie, speed 120× off.** git-archived `84fab587` → clean CUDA build (`121a`) → `laguna-gen --gpu` on the real 67 GiB `ckpt` with vLLM's exact prompt ids injected (`2,785,9626,377,15360,395`, captured via the HF tokenizer). Two GB10 memory fixes landed to run: release the mmap'd shards after the loader's memcpy-copy (114→67 GiB RSS), and create the CUDA context BEFORE the load (the 67 GiB reclaimable page cache otherwise starves `cudaStreamCreate`). **Correctness:** ours `22345 83 350 71070 395 340 9626 372 1703 …` vs golden `22345 83 290 350 674 330 5541 966 340 9626 377 15360 …` — **first 2 tokens match vLLM exactly**, then near-tie divergence; coherent ("France is" = 9626/377/15360; shares golden vocab). EXPECTED: our TRUE-W4A4 (fp4 activations) vs the MARLIN golden's W4A16 (bf16 activations) — different precision, not a bug. **Speed: 6.34 s/tok (0.16 tok/s), prefill 17.3s — ~120× slower than vLLM 18.8.** ROOT CAUSE (source-confirmed): `LqGemmNvfp4Fp4` uses the generic `vt::MatmulNvfp4Fp4` = the hand-written EMULATION CUDA kernel, NOT the cutlass sm120a fp4 tensor-core path the 27B/35B W4A4 use (`MatmulNvfp4Fp4DirectD`); + per-expert loop + per-GEMM host sync + no device residency. **nsys (2026-08-01) trace-confirmed + refined:** only 2 GPU kernels — `MatmulNvfp4Fp4Naive` = 99.3% of GPU time + fp4-quant 0.7%; GPU busy only ~18% of wall. NO bf16 GEMM on the GPU ⇒ `LqGemm`'s bf16 branch runs the host `MatmulNK` reference on the CUDA queue (attention/dense/router/shared/lm_head are CPU-bound, ~4.8 s/tok) — a second lever the source scan missed. **N5 LEVER #2 LANDED (2026-08-01) — 16× decode.** Routed the bf16 tower (attention/dense/router/shared/lm_head) off the host `MatmulNK` onto the GPU (`LqGemm` bf16 branch: `vt::CastBf16` the small activation + `vt::MatmulBT` bf16×bf16→f32, weight stays bf16 — no per-token `ReadF32` of `lm_head [100352,H]`): **decode 6.34 → 0.39 s/tok (16.3×; 0.16 → 2.56 tok/s), prefill 17.3 → 2.24s**; coherence preserved (near-tie). CPU path unchanged (run-gate byte-identical). **N5 LEVER #1 LANDED (2026-08-01) — native fp4 tensor-core, another ~2×.** The engine's native sm120a fp4 tensor-core MMA (`MatmulNvfp4Fp4Native`, `mma.sync kind::mxf4nvf4`) reads the same linear scale layout `LqGemmNvfp4Fp4` produces — it was gated OFF behind `VT_NVFP4_FP4_NATIVE`; the Laguna driver now defaults it ON (scoped; 27B/35B untouched). **decode 0.39 → ~0.20-0.24 s/tok (~2×; ~4.2-5.0 tok/s)**; coherent (byte-identical ids to the emulation path — numerically equivalent), first token matches the golden. **Cumulative N5: 0.16 → ~4.5 tok/s (~28×), now ~4× from vLLM 18.8.** **Device-resident MoE block LANDED + MEASURED (2026-08-01, `LagunaMoeResidentFp4`, `VT_LAGUNA_RESIDENT_MOE` default-ON):** the whole token's routed experts as ONE async device chain (fp4-quant→GEMM gate/up, `MoeSiluMul`, →down stacked, ONE `MoeCombine`), draining once vs ~Pk×3 syncs. **Speed EAGER-NEUTRAL (0.20 s/tok)** — empirically confirms the ds4 precedent (per-op syncs overlap GPU compute; wall is GPU-serial-bound; the graph is the payoff). **CORRECTNESS WIN: golden-token match 2 → 13** (the device `MoeSiluMul`/`MoeCombine` mirror vLLM's fused MoE faithfully). Lands default-ON (better correctness, no speed cost, graph prerequisite). **CORRECTED CEILING (from the measured state): a perfect decode graph caps at ~5.9 tok/s** (GPU already ~87% busy at 0.20 s/tok), still 3.3× short of vLLM 18.8 — the graph is necessary but NOT sufficient; the remaining 3.3× is KERNEL EFFICIENCY (native fp4 MMA ~302µs/M=1 expert GEMM vs vLLM's tuned cutlass sm120a fp4 + fused norm/quant/silu). Parity = TWO campaigns: (A) device-resident+graph → ~5.9; (B) cutlass DirectD experts + fused ops + M=1-tuned GEMV → the rest. **CAMPAIGN-B FIRST BRICK LANDED (2026-08-01): coalesced M=1 fp4 GEMV** (`MatmulNvfp4Fp4Gemv`, one warp/column, coalesced weight-row reads, `VT_NVFP4_FP4_GEMV` default-ON) — same-binary A/B: **decode 0.20 → 0.15 s/tok (1.33×; → ~6.7 tok/s), prefill 1.14 → 0.86s**, coherent+near-tie. **Cumulative this session: 0.16 → ~6.7 tok/s (~42×), now ~2.8× from vLLM 18.8.** (ILP variant `kCpw=4` measured SLOWER — 0.21 s/tok, occupancy loss > activation-reuse gain — reverted to `kCpw=1`; kernel kept templated as a re-measurable knob.) **ncu of the GEMV (sudo): sm__throughput 35-71%, DRAM n/a — COMPUTE/LATENCY-bound, not BW-bound.** Corrects the earlier "~6× BW → ~16-17 tok/s" estimate: the next GEMV lever is HARDWARE fp4 dequant (`cvt.e2m1x2`), not more bandwidth. Parity (18.8) is a multi-brick campaign (decode graph + fused norm/quant + hardware-dequant GEMV), not one more kernel. **B0 hw-fp8 SCALE-decode: MEASURED NEGATIVE, reverted (2026-08-01, `ab7a1c1e`).** Replacing the GEMV's per-byte software fp8-e4m3 group-scale decode (`F8E4M3ToF32Dev`/`ldexpf`) with hardware `cvt.rn.f16.e4m3` (`__nv_fp8_e4m3`→float) is bit-exact (ids byte-identical on the real ckpt) but paging-immune ncu shows it NEUTRAL-to-slightly-WORSE (grid768 41.2 vs 41.9µs tie; mean 53.6 vs 49.4µs) — GPU `ldexpf` is a cheap exponent-bit add, not a libcall. NOTE this is the fp8 SCALE decode, NOT the fp4-e2m1 WEIGHT dequant (the `kE2M1` `__constant__` LUT); the LUT→arithmetic/`cvt.e2m1x2` weight-dequant is a SEPARATE still-open lever (spec brick B1). Also: end-to-end wall-clock is unusable for kernel A/B here (67 GiB unified reload swings TPOT 0.16↔1.08 s/tok run-to-run) — kernel-duration ncu is the only honest anchor. **★ B2 SCOPED + DE-RISKED (2026-08-01, zero-DGX) — the real 18.8 lever:** vLLM's 18.8 bar is MARLIN W4A16 (`VLLM_TEST_FORCE_FP8_MARLIN=1`), which is LOW-M-optimized (decode-correct, unlike a tensor-core W4A4 GEMM that wastes M=1 tile rows). The engine already ships the EXACT kernel `vt::MoeGroupedGemmNvfp4Marlin` (1:1 lift of vLLM `moe_wna16_marlin_gemm`) + shared `MarlinRepackExpertWeight`, and qwen3_5 (27B/35B) already routes its NVFP4 experts through it (default-ON `VT_NVFP4_MARLIN`, 16/16-vs-oracle, +22% gate/+80% decode) via `BuildMoeMarlinResident`. So B2 = mirror that for `LagunaMoeWeights.experts_*_fp4` (a `BuildLagunaMoeMarlinResident` reusing the shared repack + route `LagunaFfnBlock`'s fp4 branch to the Marlin grouped GEMM, GEMV kept as the `=0` escape hatch) — pure reuse, no new kernel, matches vLLM's exact W4A16 numerics. **B2 IMPLEMENTED (2026-08-01, `3c49ef37`) — COMPILES CLEAN on GB10 sm_121a, runtime bug pending.** `LagunaMoeResidentMarlin` + `BuildLagunaMoeMarlinResident` (laguna.cpp, `#ifdef VT_MARLIN_NVFP4`) reconstruct the MoE Marlin path over the SHARED `dense_nvfp4::Dev`/`DBuf`/`ResidentNvfp4` + shared `vt::cuda` Marlin repack/align ops + `vt::MoeGroupedGemmNvfp4Marlin`; SACRED 27B/35B path BYTE-UNTOUCHED; gated `VT_LAGUNA_MARLIN_MOE=1` **default-OFF** (zero regression to the default GEMV path). Compiles clean on the full CUDA build. RUN: loads OK (48 layers, 256 experts) but the FIRST FORWARD device-faults silently on the Marlin path — a layout/param bug (suspects: `MoeCombine` bf16-in/f32-out dtype, the down-GEMM reusing the gate/up align, or the fp4-original free omitted → mem ~doubles). NEXT: `compute-sanitizer` localize → fix → near-tie vs the vLLM-Marlin golden + kernel-duration ncu → flip default-ON. Default path unaffected. **UPDATE (`22d6e146`): added the qwen3_5-style fp4-original free after repack** (device transients + host bytes; peak was ~3× the expert tower → past the 119 GiB pool → null-alloc → silent fault the likely cause); compiles clean. The runtime gate stayed INCONCLUSIVE this session (contended/orphaned processes on the shared box, no captured ids) — rerun on a clean uncontended session, compute-sanitizer if it still faults. **★★ B2 VALIDATED on GB10 (2026-08-01, with the mem-free fix): RUN_EXIT=0, coherent, first 13 generated tokens MATCH the vLLM-Marlin golden EXACTLY** (`22345 83 290 350 674 330 5541 966 340 9626 377 15360 81` — the best Laguna-NVFP4 correctness yet, W4A16 matching vLLM's config). **Steady-state decode 0.10 s/tok = ~10 tok/s** (steps 10-17 all 0.10; the TPOT-0.56 average is warmup-polluted — the DevicePool warms over ~9 decode steps then reuses). vs the GEMV path's 6.7 tok/s = **~1.5× faster; the gap to vLLM 18.8 closes from ~3× to ~1.9×.** Memory flat (7.9 GiB host RSS — the fp4-original free worked; it also fixed the first-forward fault). Still `VT_LAGUNA_MARLIN_MOE=1` default-OFF. TO DONE: move the lazy Marlin-resident build (216s first-forward, 48L×256E repack) to model-LOAD time → clean warm A/B + ncu → flip default-ON → matrix/roadmap. Remaining ~1.9×: vLLM graphs its decode (ours still eager) — decode CUDA-graph is the next lever. **REPRODUCED 3× (reproduction gate MET): GB10 runs deterministic — first 18-20 tokens byte-identical, steady-state 0.10 s/tok confirmed each — so the ~10 tok/s + golden-match is gated, not a single sample.** **#234 item (1) — load-time resident-build LANDED (`LagunaBuildMarlinResidents`, called from the example after load; mirrors vLLM process_weights_after_loading): builds all 48L×256E Marlin residents at LOAD so the repack is not a first-token TTFT spike. Fixed an anon-namespace linkage bug (public fn was defined with internal linkage → moved outside the anon namespace); BUILD CLEAN + links on GB10 sm_121a, default-OFF. Runtime prewarm-fires-at-load timing UNVERIFIED this session (repeated ssh-drops ate the run capture); the forward's lazy build is the validated fallback so it cannot regress. Owed: one clean run to confirm the build moved to load + then flip default-ON.** **★★ DONE (2026-08-01): Marlin is now the UNCONDITIONAL DEFAULT (`LagunaMarlinMoeEnabled` default-ON; `=0` is a code-level A/B opt-out no user needs) — "it just works" with NO env. Confirmed in a no-env GB10 run captured via tmux: `MARLIN residents built at load in 238.4s`, prefill 14.78s (build moved OUT of first-forward), golden-matching ids, steady-state 0.10 s/tok = ~10 tok/s (4th reproduction), RSS ~5-8 GiB. So a default Laguna-NVFP4 load on GB10 gets vLLM's own W4A16 Marlin decode (~10 tok/s, ~1.9× from vLLM 18.8) with zero flags. The 238s load-time repack is a one-time cost (mirrors vLLM process_weights_after_loading); optimizing its 48×256 per-expert sync count is a follow-up. Residual to 18.8 = decode CUDA-graph (deferred; user refocusing on DeepSeek next).** Post-lever-1 nsys: the remaining ~4× is HOST-SYNC-bound — 22,115 `cudaStreamSynchronize` (78.6% of API time, ~2,760/token, the per-GEMM `DrainQueue`), GPU kernels fast. Remaining levers: grouped W4A4 MoE (design input: `vt::MoeGroupedGemmNvfp4` is W4A16, so true-W4A4 grouped needs a new fp4×fp4 op or the `use_a16` mode + expert-stacking — needs a spike), device-resident decode (RECOMMENDED — the current forward is host-style so every GEMM drains; keep activations on-device, drain once/step; reuse qwen3_5's `Dev`/`Nvfp4Dev`/`ResidentNvfp4`/device-SwiGLU machinery; kills the 22k syncs; converges with the pending GGUF #228 and lifts both quant paths), decode CUDA-graph. Binding number needs a clean 2-3× re-run. See `docs/BENCHMARKS.md` + the spec N5 plan. See `docs/BENCHMARKS.md` `CLAIM-LAGUNA-VLLM-NVFP4`. Prior **DECODE-SPEED ATTRIBUTED (W7 profile-only, 2026-07-31, `CLAIM-LAGUNA-W7-SPEED`): `nsys` of the W6 decode on the real UD-Q4_K_XL GGUF (GB10) shows the 0.66 s/tok (~1.5 tok/s, vs llama.cpp 27.8 tok/s on the identical bytes, ~15-18x) is HOST-ORCHESTRATION, not kernel compute: GPU active only 32.7% of the step, 67.3% host/idle; 22,115 `cudaStreamSynchronize` (~2,764/step, zero GPU overlap) from the ~1,795 per-GEMM `DrainQueue` sync in `LagunaForwardGgufCached` + scalar host glue; 39.4% of the GPU time is `QuantizeQ8K` activation-quant (re-quantized per GEMM), the weight GEMVs run un-grouped at ~22% of the 240 GB/s peak (llama.cpp ~76%). Ranked levers (all in-tree from ds4): device-resident decode (kill the syncs) 1.5->~5-7 tok/s, grouped-expert GEMM (`MatmulBTQuantGrouped`) +1.5-2x + dedupes the activation-quant, decode CUDA-graph, tuned MMVQ; + free host cleanups (`LagunaEmbed` copies the whole 1.23 GB embed table/token; per-token RoPE-cache rebuild). Honest reachable ~13-20 tok/s, 27.8 a stretch. NO code changed. See `.agents/specs/laguna-s21-w7-speed-2026-07-31.md`. Prior RUNNABLE + FAST DECODE (W6, 2026-07-31): a per-layer K/V cache + single-token incremental decode replaces W5's O(n²) STATELESS full-recompute — TOKEN-IDENTICAL (byte-equal ids, md5 match, == the W5 golden) and 5.05× faster per token: decode 3.33 → 0.66 s/tok on the real 3-shard UD-Q4_K_XL GGUF (GB10, `--gpu`, keep-quant), same "The capital of France is" → " Paris.\n\nThe user is seeking a detailed explanation of the concept of \"cultural capital\"…". `LagunaKvCache` (mirrors `DeepseekV4KvCache`, MLA-latent → GQA multi-head K/V) caches post-QK-RMSNorm/post-RoPE K + raw V at f32 (bit-exact by construction: RoPE/QK-norm are position-only and attention is causal). MIXED attention handled per-layer: 12 GLOBAL layers grow the cache unbounded (full causal); 36 SLIDING-WINDOW-512 layers EVICT the oldest rows beyond the 512 window (gemma2/3 `is_sliding`), capping their K/V. `LagunaForwardGgufCached` + shared `LagunaAttention`/`LagunaFfnBlock` helpers used by BOTH forwards (identical float ops — the recompute path's ids are unchanged after the refactor); `examples/laguna_gen --stateless` forces the W5 recompute for the A/B gate. No cache bug: bit-exact on the first run. Next speed: grouped-expert GEMM + device-resident decode (both in-tree from ds4). See `.agents/specs/laguna-s21-w6-2026-07-31.md`. Prior RUNNABLE (W5, 2026-07-31): our engine greedy-generates COHERENT text on the REAL 3-shard UD-Q4_K_XL GGUF (GB10, keep-quant). `laguna-gen` "The capital of France is" → " Paris.\n\nThe user is seeking a detailed explanation of the concept of \"cultural capital\" as developed by French soci…" — the FIRST token is "Paris.", matching the llama.cpp-Poolside reference on the identical bytes. Multi-shard GGUF reader (LagunaGgufCtx routes each of 814 tensors to its shard; shard-1 = header only) + keep-quant tower (attn/dense/shared/experts/lm_head stay Q8_0/Q4_K/Q5_K COMPRESSED, consumed via `vt::MatmulBT`; norms/router/bias/embed → f32) + `LagunaForwardGguf` (the f32 composition with the ~9 GEMM sites swapped to keep-quant Gemm/GemmRowSlice, ds4 precedent) + `examples/laguna_gen`. Real GGUF metadata verified: dual-RoPE freq_base 500000/10000, dims 64/128, YaRN factor 32, sigmoid ungrouped-noaux router (scale 2.5), per-layer Q-head [48 global/72 sliding], per-head softplus out-gate, QK-RMSNorm. Load 20.6s, peak 71 GiB (fits 119 pool). Prior W4 IN PROGRESS (2026-07-31): 73.4 GiB UD-Q4_K_XL GGUF FETCHED + read authoritatively (814 tensors); 3 CPU-verified fidelity corrections grounded in the real GGUF + llama.cpp — per-head QK-RMSNorm (`attn_q/k_norm`, the scope MISSED it), GGUF-authoritative dual-RoPE mscale (llama.cpp `yarn_attn_factor·(1+0.1·ln(factor))`, factor 32 not HF 128), separate `ffn_gate/up_exps`. Keep-quant tower materialization + `ForwardGguf` + the real-model greedy run vs llama.cpp-laguna same-quant oracle = W5 close. Prior: W3 REAL host-reference forward + 3 new ops (`laguna_ops.cpp`, CPU `-Werror` clean, `test_laguna_scaffold` unit-gated)** | Poolside Laguna: 48 layers (12 global + 36 sliding-window-512), 256 routed top-10 + 1 shared expert, per-head **softplus attention output gate**, sigmoid `noaux_tc` router, dual per-layer RoPE (YaRN full-attn / plain sliding), GQA 8 KV / 128 head-dim, 1M ctx. **W3 (2026-07-31):** the 3 genuinely-NEW small host ops landed in `laguna_ops.cpp` — per-head softplus attn out-gate (`LagunaSoftplusHeadGate`), ungrouped sigmoid-noaux router (`LagunaUngroupedRouterTopK`, ds3 noaux_tc MINUS the group step + tie-break razor), dual per-layer RoPE cos/sin builders (`BuildLaguna{FullYarn,Sliding}CosSin`, reusing the pinned YaRN inv_freq over the partial-64 dims); `LagunaModel::Forward` is now a REAL runnable host-reference composition (variable-Q-head GQA + dual RoPE + sliding-window mask + softplus gate + dense L0 / ungrouped-MoE L1..47 + untied lm_head) replacing the `VT_CHECK(false)` stub; `test_laguna_scaffold` **8/8·166** (softplus math, router selection+tie-break RED-first, dual-RoPE bit-match, variable-Q-head shapes, forward composition on synthetic weights), `test_model_registry` 24/24. **W2 (2026-07-30):** registered, `ParseLagunaParams`, GGUF `blk.N.*` name-map + UD-Q4_K_XL quant-mix (Q4_K/Q5_K/Q6_K/Q8_0 ALL already decoded → ZERO new kernel). **W1 oracle DECISION:** vLLM NATIVE `laguna.py` (in pin → config constructs); dual-oracle = vLLM-NVFP4/-FP8 (fits GB10 119 GiB; BF16 235 GiB does NOT) + llama.cpp-Q4_K token-exact. ~85–90% reuse (ds4-MoE + Gemma-sliding + OLMo-3-dual-rope + Q4_K keep-quant, ALREADY landed). DEFERRED (W4): GGUF keep-quant tower materialization + device/paged production forward (loaders still LOUDLY throw) + strict dual-oracle greedy gate on a fetched checkpoint + `poolside_v1` parser. See `.agents/specs/laguna-s21-w3-2026-07-31.md` (+ W1/W2 `laguna-s21-w1w2-2026-07-30.md`, W0 `laguna-s21-scope-2026-07-30.md`). **Decode attention-glue fusion LANDED (2026-08-02, `CLAIM-LAGUNA-GLUE-FUSED`, default-ON `VT_LAGUNA_GLUE_FUSED`, `=0` A/B):** BYTE-EXACT L1 (softplus out-gate → `DecodeAttnCombineKernel` store) + L4 (residual-Add+RMSNorm pairs → the shared `vt::FusedChain(kFusedAddRmsNormStd)` seam) on the resident decode-graph — same-binary A/B ids byte-identical (159/159 @160), paging-immune nsys steady decode **−4.2% GPU-busy (28.90→27.69 ms/step), −120 graph nodes/step (−10%)**, wall drop_caches-tied (no regression). C shared-into-MoeCombine SKIPPED (Laguna's bf16 `MoeCombine` → not byte-exact); L2 qk-norm+RoPE preamble DEFERRED (needs a device-position kernel variant). See BENCHMARKS.md `CLAIM-LAGUNA-GLUE-FUSED`. **On-device greedy sample LANDED (2026-08-02, `CLAIM-LAGUNA-ONDEV-SAMPLE`, default-ON `VT_LAGUNA_ONDEV_SAMPLE`, `=0` A/B):** the resident decode graph used to Synchronize, return the whole `[100352]` logits, and argmax on the HOST between replays (+ host embed-gather of the next token) — the off-framework "born-on-host" seam the decode-framework-routing audit flagged. Now BOTH run ON-DEVICE inside the captured graph: `vt::GreedyArgmax` (lowest-index tie = the exact host winner) → 1-elem device token buffer, + a new capture-safe `embed_gather` kernel gathers the next input embedding from it (the stock `vt::Embedding` is NOT capture-safe: per-call event-sync + D2H ring). BYTE-EXACT (160-id stream identical `=0`/`=1` on `~/laguna-xs-nvfp4`) + faster: paired drop_caches decode wall **+0.28% median** (8/8 reps ≥0; removes ~150 us/step host argmax) at GPU-busy parity (nsys 2-length 27.44→27.42 ms/step). Aligns Laguna decode with vLLM on-device sampling. **Lever 2 (lm_head GEMV DRAM eff) MEASURED, NOT landed:** `[M=1,100352,2048]` bf16 = **170 GB/s (2.41 ms)** = ~91% of the cuBLAS M=1×large-N reference (~187 GB/s / 2.2 ms) — at the M=1 practical floor (the 273 GB/s ceiling is streaming-only, unreachable for a once-read GEMV); ≤0.7%-of-step headroom needs a reduction reorder (near-tie re-gate) ⇒ not chased, per prior "lm_head optimal". See BENCHMARKS.md `CLAIM-LAGUNA-ONDEV-SAMPLE`. **MoE add_rms_norm fold LANDED (2026-08-02, `CLAIM-LAGUNA-MOE-ADDNORM`, default-ON `VT_LAGUNA_MOE_ADDNORM_FUSED`, `=0` A/B):** the glue-fused MoE tail ran its residual update as TWO graph nodes — `vt::Add(hidden,routed)` [`AddKernel`] + `FusedChain(kFusedAddRmsNormStd)` [shared-add+RMSNorm, `RmsNormRowKernel`] — now ONE `fused_add2_rmsnorm` device node/MoE-layer (`hidden=(hidden+routed)+shared; hn=rms_norm(hidden)*w`). BYTE-EXACT (IEEE add commutes + the identical 256-thread shared-tree norm reduction; 160-id stream byte-identical `=0`/`=1` on `~/laguna-xs-nvfp4`) + faster: **−39 `AddKernel` graph nodes/step** (2.63ms→0 over 69 steps), paging-immune nsys 2-length **~−46 us/tok GPU (27339→27293)**, nsys wall **+0.4% (34.00→34.14 tok/s @70-tok)**. Small (byte-exact node-count trim on the graph-captured, GPU-bound decode; the dominant ~72% cost is the bf16 projection GEMVs — see the Lever-B negative in BENCHMARKS.md). See BENCHMARKS.md `CLAIM-LAGUNA-MOE-ADDNORM`. **Shared expert kept fp4 LANDED (2026-08-03, `CLAIM-LAGUNA-SHARED-FP4`, default-ON `VT_LAGUNA_SHARED_FP4`, `=0` A/B):** the XS-NVFP4 shared expert was DEQUANTIZED to bf16 at load (`LnLoadSharedExpertBf16`) → the M=1 decode GEMV read 4× the DRAM bytes of vLLM (which keeps it fp4). Now kept fp4-resident and routed through the SAME Marlin W4A16 single-expert (num_experts=1) grouped GEMM the routed experts win on (`dense_nvfp4::GateUpFusedMarlinD`+`MatmulNvfp4MarlinD`); the decode GEMV drops to router-ONLY (`moe.router`), shared gate/up/down go fp4. ADDITIVE new `laguna_shared_fp4.cpp` re-reads the on-disk fp4 from the gen driver before shard release (does NOT touch SACRED `laguna_weights.cpp`); bf16 shared KEPT for the T>1 prefill. NEAR-TIE (fp4≠bf16): coherent, first-20 ids == documented golden, byte-identical to bf16 for ~85 tokens then diverges; **DISTRIBUTIONAL GATE PASS 40/40** (ours' first-40 ids ∈ vLLM's 8-run greedy candidate set; vLLM XS-greedy is bf16-non-det, 8 unique of 8). FASTER: paging-immune nsys 2-length **GPU 27.24→26.53 ms/step (−2.6%)**, wall drop_caches **35.8→36.3 tok/s (+1.4%, fp4 wins all 3 reps)**; shared-expert kernel bucket ~1.68→~0.90 ms/step (halved); vs vLLM ~43 tok/s 83.3%→84.4%; RSS 22.2→22.1 GiB (freed the decode-only fused router-shared projection). Modest by design — XS's shared expert is small (`shared_expert_intermediate_size==moe_intermediate_size==512`). Default-ON per parity (matches vLLM's fp4 shared). See BENCHMARKS.md `CLAIM-LAGUNA-SHARED-FP4`. **qk-norm+RoPE preamble fusion LANDED (2026-08-03, `CLAIM-LAGUNA-PREAMBLE-FUSED`, default-ON `VT_LAGUNA_PREAMBLE_FUSED`, `=0` A/B):** closes the `CLAIM-LAGUNA-GLUE-FUSED` L2 deferral — the decode graph ran the per-layer attention preamble as FOUR under-occupied M=1 nodes (`rms_norm_seq(q)`+`rms_norm_seq(k)`+`rope_from_cache_g(q)`+`rope_from_cache_g(k)`); now ONE capture-safe `fused_qk_norm_rope_g` node/layer (`FusedQkNormRopeGKernel`, one block/head, reads the decode position from DEVICE `*pos_buf`, handles the per-layer dual-RoPE 64/128 + `Hq` 48/64). BYTE-EXACT BY CONSTRUCTION: it replicates the composed path's f32 MEMORY round-trip (Phase A 256-thread Σx² == `RmsNormSeqKernel`; Phase B the same `(x*inv)*w` store; `__syncthreads`; Phase C the `RopeFromCacheGKernel` rope read back) — an earlier register-only recompute was numerically-equivalent but diverged at a token-110 near-tie via compiler fma-contraction; the memory boundary forces bit-identity. 160-id stream byte-identical `=0`/`=1` on `~/laguna-xs-nvfp4` (determinism verified `=0`×3/`=1`×3 each run-to-run identical). FASTER: preamble norm+rope kernels **160→40 launches/tok, 326→154 us/tok (−0.17 ms/step)**; all decode-scaling kernels 26.53→26.37 ms/step; wall drop_caches **36.42→36.64 tok/s (+0.6%, fused wins all 3 paired reps)**; vs vLLM ~43 84.7%→85.2%. Modest (preamble ~1.2% of the 26.5 ms/step decode; the dominant cost stays the bf16 projection GEMVs at cuBLAS parity) — a byte-exact graph-node/launch trim (the glue-fusion residual mechanism). Default-ON per parity. See BENCHMARKS.md `CLAIM-LAGUNA-PREAMBLE-FUSED`. **W7 two-front pass LANDED (2026-08-03, `CLAIM-LAGUNA-W7-DECODE`):** FRONT 1 — the example driver logged `[gen] step N …(RSS)` EVERY decode step, and the RSS arg calls `CurResidentGiB()` (a `/proc/self/status` read) + an unbuffered stderr write in the GPU-idle gap between replays; guarded behind `VT_LAGUNA_STEP_LOG` (default OFF) + added a `decode_wall` line (TRUE end-to-end throughput incl. per-step gaps) next to the gap-free `decode_hp`. Since the fprintf sat OUTSIDE the `s0→s1` timer, `decode_hp` was ALREADY honest; with the log off `decode_wall == decode_hp` (within 0.001 tok/s, every LOG_OFF rep) and the recovered host tax is only ~0.1% (drop_caches noise floor). CONCLUSION: the ~86% gap to vLLM 43 is genuine device compute, NOT a harness artifact. FRONT 2 — `VT_LAGUNA_MOE_ONECAST` (default ON): a MoE layer cast the same `hn[1,H]` f32→bf16 THREE times (router GEMV + routed Marlin + shared Marlin); now cast ONCE into a persistent buffer and reuse (`CastHnBf16`/`GemmBf16Pre` + optional pre-cast param on both `…Into` helpers). BYTE-EXACT (deterministic truncation; `=1` vs `=0` byte-identical 300-tok ids); `CastBf16` **200→122 nodes/step (−78 = 2×39 MoE layers)**, GPU-busy parity within nsys noise, decode_hp +0.29%. Combined (onecast on + log off) **36.97 tok/s = 86.0% of vLLM-NVFP4 43** (from 36.64/85.2%). See BENCHMARKS.md `CLAIM-LAGUNA-W7-DECODE`. **Tail-fold follow-up LANDED (2026-08-03, `CLAIM-LAGUNA-TAIL-FUSED`, default-ON `VT_LAGUNA_TAIL_FUSED`, `=0` A/B):** a fresh node-ranking of the baseline decode graph found the routed-MoE `CastF32` as the one clean byte-exact fold left; it folds into the trailing `fused_add2_rmsnorm` via a new bf16-x1 sibling kernel (`AddAdd2RmsNormStdBf16Kernel` — `MoeCombine` writes bf16 straight to a persistent buffer, widened in-kernel by `__bfloat162float`). BYTE-EXACT (`=1` vs `=0` byte-identical 160-tok ids), `CastF32` **78→39 nodes/step**, total graph nodes **919→880**, GPU-busy parity; decode_hp a WASH (median +0.14% / mean −0.04%, at the drop_caches noise floor). Lands on the deterministic node-count basis (like onecast/preamble/addnorm), NOT a wall win; combined headline UNCHANGED **36.97 tok/s = 86.0%**. The ranking confirms the byte-exact decode-tail fold tier is now essentially EXHAUSTED (residual tail = already-folded norms + attention compute + cuBLAS-adjacent router/topk + ported-Marlin `MoeAlign`/`SiluAndMul`/`MoeCombine`); the gap to vLLM 43 is genuine device compute at the practical ceiling. See BENCHMARKS.md `CLAIM-LAGUNA-TAIL-FUSED`. **KERNEL-EFFICIENCY tier (2026-08-03, `VT_LAGUNA_FAST_NORM` default ON + f32 ext of `VT_RMSNORM_DECODE_FAST`):** the fold tier was exhausted but the residual-stream norm KERNELS were still under-occupied — `ncu` on the shipped `<<<1,256>>>` `AddAdd2RmsNormStdBf16`/`RmsNormRow<f32>` decode norms: `launch__waves_per_multiprocessor≈0.00`, `sm__throughput≈0.06%` (one 256-thread block on 1 SM of ~100+, latency-bound). Porting the PROVEN bit-identical `RmsNormRowFastKernel` structure (1024-thread float4 memory passes; 256-strided-partial + tree reduction reproduced byte-for-byte) to the f32 kernels cut each **286→~155 µs/tok (1.85×)**, **byte-exact** (160-tok ids identical `=1`vs`=0`; the f32 fix vs the bf16 sibling: store `v` not `v²` and square in the reduction so nvcc emits shipped's `acc += v*v` **fma** — a pre-squared f32 `v²` is not exact and flipped an XS near-tie at tok 108). **−0.81% decode-step GPU time** (paging-immune 70-vs-20 2-length diff, 26192→25980 µs/step); wall-clock ON/OFF overlap (noise floor). Residual: the byte-exact 256-strided reduction can't reach vLLM's per-kernel norm floor (~2.4× vLLM) without breaking byte-exactness → that remainder is byte-exactness-BLOCKED. See BENCHMARKS.md `CLAIM-LAGUNA-FAST-NORM`. **Router top-k warp-shuffle LANDED (2026-08-03, `CLAIM-LAGUNA-TOPK-SHFL`, default-ON `VT_LAGUNA_TOPK_SHFL`, `=0` A/B): BYTE-EXACT** — an nsys 2-length rank of the remaining small kernels (past the at-parity `gemvx` projection GEMVs ~69% of step + Marlin MoE) put the router `SigmoidTopKKernel` top (415 µs/step); `ncu` showed it `<<<1,256>>>` at `waves≈0.000`/`sm≈0.2%` — pure latency (8 serially-dependent rounds × a ~10-sync `sh[256]` argmax tree). New `SigmoidTopKShflKernel` reduces each round by warp-shuffle argmax (2 syncs/round; argmax over the total order is associative ⇒ SAME winner) → **`SigmoidTopK` 414.6→248.8 µs/step (1.67×)**, decode-step GPU **−0.57%** (26.018→25.869 ms/step), 37.39→37.49 tok/s decode_hp (**87.2% of vLLM-NVFP4 43**); 160-id stream byte-identical `=1`vs`=0`. **NOT landed — norm warp-shuffle (`VT_LAGUNA_NORM_SHFL`):** a near-tie register-accumulate+shuffle reduce for the Laguna `AddAdd2RmsNormStd{,Bf16}Fast` norms PASSED the distributional gate (coherent, in-set 38/40 = baseline, one near-tie fork at pos 37) and was −19.3% per-kernel (`AddAdd2RmsNormStdBf16` 150.3→121.3 µs/step) BUT washed at whole-step (0.6% of step; +0.02% within noise) — a near-tie fork isn't justified by a below-noise gain, so it was dropped. The small-kernel norm tail is at its occupancy floor; the decode step is dominated by the at-parity projection GEMVs. See BENCHMARKS.md `CLAIM-LAGUNA-TOPK-SHFL`. |
 | InternLM2 dense (fused-`wqkv` interleaved split) | Correctness-complete, speed-pending | Token-exact 16/16 (internlm2-chat-1_8b): 12/16 strict + 4/16 bf16 near-tie (max gap 0.0 nats), 0 divergent; first InternLM model; ZERO new compute kernel (reuses the Llama dense forward; the only delta is a loader-side de-interleave of the fused `wqkv`, which packs q/k/v interleaved by KV-group) |
+| MiniMax-H3 (`MiniMaxH3DiTModel`, omni-modal video+audio DIFFUSION) | **Layout, scheduler, DiT forward (f32 + bf16), request planning and the GGUF shape/geometry arm correctness-complete; end-to-end pending the encoder/VAEs/pipeline** | The project's first DIFFUSION architecture (33.1B CFG-distilled joint video+audio DiT, 50-step flow-matching loop; no KV cache, no sampler, no logits, so it is not a causal-LM registry model). Gated against the UPSTREAM vLLM-Omni modules executed at reduced dimensions: packed fl2va + ref2va layouts (fp64 position grid BIT-EXACT), latent packing, scheduler, request planning and task dispatch all EXACT; DiT forward **max abs diff 1.6e-7** (f32) and **2.4e-3** on the bf16 production stream; 13/13 cases / 3907 assertions. The ComfyUI-GGUF arm resolves the REAL 535-tensor `MiniMax-H3-FL2VA-Q3_K_M.gguf` manifest onto our weight contract exactly (identity name map) and derives the shipped geometry from shapes alone. Reuses the shared `vt::DFlashBlockAttention(causal=false)` — no new kernel. **Hardware verdict CORRECTED 2026-08-03:** the bf16 release (~354 GB, 4x B300) does not fit, but the quantized arms do (GGUF DiT 15.6 GB + encoder 14.6 GB + VAEs ~11 GB ~= 41 GB; NVFP4 likewise), so e2e and a speed comparison are reachable. The **audio VAE decoder is DONE** — a DAC/BigVGAN vocoder REIMPLEMENTED from the checkpoint's remote code and gated against it at **4.2e-9**. The REAL NVFP4 checkpoint manifest (1051 tensors) is gated as textbook compressed-tensors NVFP4 — the same layout our tuned stack already consumes — and the video VAE manifest (560 tensors) shows its DECODER is a 36-block ViT, not a monolithic CNN. **BOTH VAE DECODERS ARE DONE**: audio (DAC/BigVGAN) at 4.2e-9 and the video VAE's full ViT3D decoder at **8.9e-8**, each against the checkpoint's own remote code. **BOTH ENCODER TOWERS' cores are done**: the text tower at **1.2e-7** (with all three H3 deltas — layer truncation, the UNNORMALIZED layer-49 output, DeepStack injection) and the FULL vision tower at **6.0e-8 / <=1e-4** (patch embed, bilinear pos-embed interpolation, 2D rotary, block stack with boundary isolation proven, DeepStack + final mergers, over a ragged two-image batch). **The encoder is complete apart from the MM processor.** **The WHOLE t2va path now composes end to end** (layout -> sigma schedules -> denoise loop -> unpatchify -> denormalize -> both VAE decoders -> frames + stereo waveform), gated structurally at reduced dimensions. Condition-noise augmentation for fl2va/ref2va anchors, the presentation TOKEN TAGS (the fl2va vision-span override the denoise loop requires) and the video-VAE tiling plan are all done (exact). Reference-video geometry + frame schedule are done too. **Every PORTABLE piece is now done**: the video VAE is complete (ViT3D decoder + 3D-CNN encoder + tiling), the encoder is complete (text tower + vision tower + MM processor, the last being reuse of our Qwen3-VL front end gated on H3's own config), and both quantized loaders work. Audio output serializes to WAV and video output to PPM frames plus an MP4 mux argv that was validated against real ffmpeg (valid h264/yuv420p + AAC MP4), all with no library dependency: the library builds artifacts and the command, and the example/server layer performs the invocation. **The `/v1/videos` serving surface is COMPLETE on CPU**: the request contract, the job store (lifecycle, status JSON, thread-safe) and the routes themselves -- `POST /v1/videos` (async, answered with a job id while a joinable worker generates, drained in `~ApiServer` so it can never outlive the store it writes into), `POST /v1/videos/sync` and `GET /v1/videos/{id}`. They register ONLY when a `VideoRunner` has been attached, so a server built without video support behaves exactly as before. A throwing runner fails the JOB, not the process. **The DEVICE-RESIDENT DiT forward is LANDED (f32) and VERIFIED ON A REAL GPU**: every activation stays in device memory across the whole block stack, gated against the same upstream goldens on the CPU backend and on a Thor sm_110 GPU at **video 1.49e-7 / audio 8.94e-8**, and the **bf16 PRODUCTION stream** runs there too (**2.41e-3 / 2.05e-3** vs the bf16 goldens — the CPU reference's own figures, so the cast points agree). The stream is now TRUE bf16 STORAGE — bf16 activations plus bf16-staged weights for the bf16-stored modules, with upstream's fp32 islands preserved — which halves activation bytes, lets the shared ops take their native bf16 paths, and is **~4x more accurate** (6.16e-4 vs 2.41e-3) because the golden itself used bf16 weights. A **KEEP-QUANT GGUF arm** now exists too: `LoadMiniMaxH3DitFromGguf(file, keep_quant=true)` leaves eligible 2-D projections in their ggml block encoding (3.77x smaller resident bytes), and `vt::MatmulBT` routes a block-typed weight to `kMatmulBTQuant` on its own, so no forward call site changed. This is the arm that runs at native speed on GPUs WITHOUT fp4 tensor cores. Verified on a real sm_110 GPU: the CPU and CUDA runs differ in the last digits, proving `kMatmulBTQuant`'s CUDA kernel actually ran — the only place the all-zeros staging trap is reachable. The AdaLN modulate kernels fold the dtype cast into their own store, and the refiner's add+RMSNorm now folds onto `vt::kFusedAddRmsNormStd` (byte-identical: a bf16 residual rounds the add on store). The refiner's add+RMSNorm is deliberately NOT folded onto `vt::kFusedAddRmsNormStd`: that recipe casts nothing between its two steps, which would drop a bf16 rounding the golden gates. Only three H3-specific kernels were needed, because the port reuses the tuned shared ops -- H3's 3-axis RoPE turns out to be plain NeoX rotate_half, so a per-row cos/sin cache feeds `vt::RopeFromCache` with no bespoke kernel. What remains is NOT porting: the ffmpeg boundary is SETTLED by the project owner (the library builds the artifacts and the argv, `examples/` performs the invocation, the runner enters the server as a callback), The **audio-VAE checkpoint loader** now exists — gated against the real 1087-tensor manifest, which caught that the shipped file uses torch's LEGACY `weight_g`/`weight_v` rather than the parametrization spelling the decoder reads. The audio-VAE loader accepts all THREE weight-norm spellings found in the wild — legacy `weight_g`/`weight_v` (the official checkpoint), the `parametrizations.weight.originalN` form the decoder reads, and a plain materialized `weight` (repackaged community bundles), the last reconstructed exactly at 1.49e-08 round-trip. The VIDEO VAE loader now exists too, and closed a genuinely MISSING step: `post_quant_conv`, a 1x1x1 channel mix that sits outside `ViT3DDecoder` and which nothing in the port applied — now implemented AND wired into `MiniMaxH3GenerateT2va`, with the pipeline test asserting the frames actually change when it is present. **The ENCODER loader now exists too, completing path 2's loaders — and `examples/minimax-h3-gen` now ASSEMBLES them: it opens the DiT (GGUF dequant or keep-quant), both VAEs and both real config.json files, plans the shape and writes frames+WAV+MP4. `examples/server` now WIRES `/v1/videos`: pass `--video-dit` (+ the VAEs and configs) and the routes register with a real runner that generates, writes frames+WAV and muxes an MP4 via ffmpeg; omit it and the routes stay unregistered exactly as before. **Text conditioning is NOT wired** — turning a prompt into conditioning needs the H3-Encoder, so the server warns at startup and every request uses the same supplied embeddings. **A PROMPT-CONDITIONED video has been generated end to end on real weights** (Thor): prompt -> tokenizer -> embedding gather -> 32B keep-quant encoder -> conditioning [5, 5120] -> DiT -> VAEs -> MP4. `minimax-h3-gen --prompt "..."` does REAL text conditioning end to end: the GGUF's own vocab tokenizes the prompt, the block-quant embedding table is gathered row-wise, and the device encoder produces the conditioning the DiT consumes. The H3-Encoder's DEVICE keep-quant forward RUNS, matching the gated host reference at 3.76e-4 (Q8_0 error) — the conditioning path that turns generated video from unconditioned into prompt-steered. It LOADS from the real 14.58 GB GGUF at **13.24 GiB resident**, alongside the keep-quant DiT, with its geometry (50 layers / 5120 / 64 heads / 8 kv) recovered from shapes. It has a KEEP-QUANT GGUF loader (32B held at ~14.6 GB, fusions done on quantized bytes), the first half of wiring real text conditioning. **END-TO-END VIDEO GENERATION WORKS ON REAL WEIGHTS, AND IS SERVED OVER HTTP** (Thor sm_110): `POST /v1/videos` on `examples/server` runs the real checkpoint and returns a job whose `output_path` ffprobe confirms is a playable h264+AAC MP4: the real 15.58 GB Q3_K_M checkpoint produces a playable MP4 (ffprobe: h264/yuv420p + AAC stereo 32 kHz) in 6m22s at latent 2x8x8 / 2 steps. First REAL-checkpoint run: the 15.58 GB Q3_K_M DiT loads (geometry recovered from shapes: 50 layers / 5376 hidden / 56 heads) and its forward runs on GPU at ~200 s/step (seq_len 576), with weights staged once in 32.8 s. keep-quant is REQUIRED — the dequant path OOMs at ~145 GB. No end-to-end video yet: the VIDEO VAE DECODE is still CPU-ONLY and is now the blocker. The denoise loop now runs DEVICE-RESIDENT (weights staged once, every step on device) rather than through the CPU reference forward — without which a real-checkpoint run is not a feasible workload at all. Loading and planning are verified over real file formats; a full generation on a REAL multi-GB checkpoint has NOT been run**: it fuses HF's separate `q/k/v_proj` and `gate/up_proj` into the `qkv_proj` / `gate_up_proj` the port consumes, across all 14 shards, and honours H3's deltas (layer truncation; no final norm; no lm_head). Remaining beyond that: the FP4 path -- and therefore any speed number, which needs sm_121a, since sm_110 resolves every fp4/cutlass feature DISABLED. **BOTH quantized loaders are DONE**: a ComfyUI GGUF and an NVFP4 compressed-tensors checkpoint each load into runnable DiT weights with the geometry recovered from shapes alone. What remains for speed is the DEVICE path (keep FP4 packed, route through the cutlass FP4 GEMM); a run on a real checkpoint still needs a GPU. **THE TWO STAGES THAT MADE A REAL-RESOLUTION RUN INFEASIBLE ARE BOTH CLOSED.** (1) ATTENTION: sm_110 has no FlashAttention-2, so H3 fell back to a kernel that runs one BLOCK per query row and walks keys ONE AT A TIME with ~11 `__syncthreads()` each -- quadratic in practice (14.61 s/step at seq 576, but **509.78 s/step at seq 3264**). A warp-per-query fast path (Q and the online-softmax accumulator in registers, warp-shuffle reductions, zero barriers) takes it to **18.68 s/step at seq 3218 -- ~27x** -- and the scaling is now near-linear in sequence rather than quadratic. Identical recurrence, so it is a scheduling change; gated by the four DFlash/attention suites (nearly 1M assertions) on the sm_110 board. (2) THE VIDEO VAE DECODE, previously the CPU-only blocker, is now **device-resident at 1.19e-07** against the checkpoint's own remote code, needing **no new kernels** -- two exact load-time weight rearrangements (a per-head-interleaved `to_qkv` row permutation, and folding each branch's learned per-channel scale into the preceding projection) make the whole 36-layer ViT3D expressible in the shared ops -- and the t2va pipeline now routes to it on a device. `--denoise-only` measures the DiT step loop without loading either VAE, which is also what keeps a measurement run off the unified-memory OOM cliff. **★ A REAL PROMPTED 512x512 VIDEO EXPOSED A STRUCTURAL GAP THE WHOLE GATE SUITE MISSED:** frames came out globally correct but covered in a grid of small squares. The tiling helpers were implemented and gated yet **never called**, and tiling is not optional here — the ViT3D's RoPE coordinates are LENGTH-NORMALIZED over the grid handed to it, so decoding a 3-tile canvas in one pass gives every token an unseen position. Confirmed by A/B rather than argued: 256x256 (the one size where `tile_size >= input`, so tiled and untiled coincide) is CLEAN, 512x512 untiled is not. Every reduced-dimension gate sits below one tile, which is precisely why none caught it. `MiniMaxH3VideoVaeDecodeTiledDevice` now slices on the pixel plan, decodes per tile and cross-fades seams — single-tile stays bit-identical, and each tile's interior matches a standalone decode exactly. **The NVFP4 arm now STREAMS**: it was OOM-killed during load (anon-rss 125 GB) because the reference loader materializes every weight as host f32 (~132 GB for an 18.75 GB checkpoint); `StreamMiniMaxH3Nvfp4ToDeviceBf16` mirrors the GGUF streamer and is gated to match the reference loader EXACTLY (max|diff| == 0). OPEN: the residual 16-px patch texture at 512 is NOT explained by tiling (present untiled too), NOT by step count (50 steps did not reduce it) and NOT by the blend (present with no blending); it is scale-dependent (256 scores 2.12 vs 2.6-3.3 at 512), and reading upstream's own `klvae.py` then found the actual gap: the video decode was missing **`decode_temporal`** — upstream chunks video in TIME (chunk 5, overlap 2 for the shipped clip_length 17 / token_drop 3 / vae_ratio_t 4), so a 12-token latent is 2 chunks of 7, never one 12-token pass, and the ViT's length-normalized RoPE makes that extent part of the input. The same reading CORRECTED an earlier wrong call: upstream does NOT spatially tile the ViT decode (`decoder_tiling` defaults false and the shipped config sets no tiling key). **★ USE Q4_K_M, NOT Q3_K_M**: a controlled A/B (same prompt/seed/code, only the DiT quant changed) turned a murky lattice-covered silhouette into a photoreal facial close-up; the p16 patch lattice collapses 1.18->1.07 against a 1.00 control. ComfyUI PR 15298 predicted it — H3's split-half RoPE creates channel-wise magnitude outliers that corrupt even INT8, so 3-bit is past the edge. **Q3_K_M is known-bad for this model.** **★ THE VAE WORKS IN IMAGENET PIXEL SPACE** and we were skipping both conversions (upstream wrapper, vae.py:659/693) — raw decoder output went to a writer expecting [-1,1], casting colour and compressing dynamic range ~4.4x, which is why renders were dark. Fixed on decode AND encode; outside ViT3DDecoder, so its 1.19e-07 gate never covered it. **RESOLVED: the two compose.** Temporal chunking ALONE measured worse than doing nothing (period-16 4.20 vs 2.64), which sent the search back to upstream's chunk loop -- `clip_dec = self._adaptive_decode(clip_z)` -- where each temporal chunk is ALSO spatially tiled. Together they give 2.46 at 512x512 against 2.12 for the 256 single-tile reference, and the frames are clean. Spatial tiling is defaulted ON because it falls through bit-identically below one tile. At the REAL default canvas (864x480/124f, seq_len 15424) a forward was **558.39 s** with attention **97%** of it (542.81 s carrying 341.1 TFLOP = **0.63 TFLOP/s**, against 30.0 TFLOP/s for our own cuBLASLt GEMMs on the same chip). **A chunked warp REDUCE-SCATTER attention kernel now takes that forward to 316.95 s -- 1.76x on the whole step, 1.80x on attention (0.63 -> 1.13 TFLOP/s), so a 50-step render drops from ~7.8 h to ~4.4 h.** **AND A bf16 TENSOR-CORE kernel then takes it to 32.71 s -- 9.82x on the whole step and 13.5x on attention (1.09 -> 14.75 TFLOP/s), so that render drops again from ~4.4 h to ~27 min.** `DFlashAttnMmaKernel` runs BOTH attention GEMMs on `mma.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32`, which was PROBED to assemble, launch and accumulate on sm_110 -- the `kind::mxf4nvf4` restriction recorded for this box is specific to the block-scaled FP4 MMA and does not reach standard bf16 MMA. One warp owns 16 query rows and the whole head_dim; S, P and the entire O accumulator stay in REGISTERS because the m16n8k16 C fragment IS the next MMA's A fragment, so only K and V are staged (17.4 KB/block at head_dim 128, half of what the round-1 shared-memory attempt spent when it measured 23% slower) and the online-softmax state reduces across a quad with two shuffles rather than a barrier. 168 registers, no spill, 25% occupancy -- the trade a tensor-core kernel makes. Same-binary A/B per FORWARD: 16.34 -> 3.25 s at seq 3264, 51.96 -> 7.11 s at 6074, 321.13 -> 32.71 s at 15421. The P*V GEMM rounds the probabilities to bf16 as FlashAttention does, so the tensor-core path is gated at a bf16 tolerance (5e-3) and **f32 inputs deliberately stay on the CUDA-core kernel at 2e-5** -- nothing was loosened. Every pre-existing CUDA case in the DFlash suite uploads f32, so this kernel would have shipped never-executed; 13 bf16 parity cases plus a bf16 mask-separation case were added with it, and the RED proof (perturbing the store) turns exactly those 2 cases red plus the CUDA bf16 DEVICE FORWARD in `test_minimax_h3`, proving it runs on the real production path. Keys are processed 32 at a time: partials stay in registers, ONE butterfly reduce-scatter (31 shuffles against 192) hands lane L the complete score for key L, and there is ONE online-softmax update per 32 keys instead of 32 -- while loads stay lane==element and coalesced. Verified by a RED proof (perturbing the store turns 7 of 12 cases red, 193,127 assertions) rather than by a green suite, and it added the first-ever head_dim 96 coverage, an instantiation that had shipped unexercised. THREE earlier attempts measured NEGATIVE and are recorded rather than deleted -- shared-memory K/V tiling, register Q-blocking, and one-key-per-lane (54% slower: a whole K row per lane makes every load 32-way scattered, which is exactly why the winning design keeps the coalescing and moves only the reduction). The first two shared one WRONG premise -- shared-memory K/V tiling (23% slower: 32 KB/block against a 48 KB limit collapsed occupancy) and register Q-blocking (-0.84% at the production canvas, +3.3% at the short one). : one head's K+V is 3.9 MB against Thor's 32 MB L2, so the re-read traffic was already L2-resident and removing it buys nothing. Memory was never the bound; the reduction and the serial online-softmax chain were. **fl2va REFERENCE CONDITIONING is now WIRED**: the primitives were gated but unreachable (no path from an image to the DiT); the video-VAE ENCODER half now loads, encodes to the distribution mean, and feeds pinned keyframe rows through the same pipeline as t2va (`--first-frame`/`--last-frame`). Gated on conditioning CHANGING the result, not merely being accepted. **ref2va IMAGE references are wired too** (`--ref-image`, repeatable), reusing the same image→latent path; an image reference moves the rows by 0.98. **SILENT VIDEO references are wired too** (`--ref-video DIR`, reading the frame_%06d.ppm this example writes, so runs chain), emitted as kVideoAudio with ref_audio_t 0 because kImage cannot carry a temporal extent; moves the rows by 0.83. **The AUDIO-VAE ENCODER is now ported, and with it the last two unwired conditioning modes: ref2va AUDIO and VIDEO+AUDIO references.** The shipped `DacAudioVAE` exposes only `decode`, so the encode path was composed the way vLLM-Omni composes it (vae.py:317-325) — preprocess right-pad → the DAC `Encoder` (Snake1d, three dilated ResidualUnits per block, the strided conv stack) → the `pre_block` `AttnProjection` (causal SDPA, mean over heads, adaptive-average-pool narrowing 2048→32, GeGLU MLP) → `mean_proj`, taking the distribution MEAN so a reference conditions identically every run. Gated STAGE BY STAGE against the checkpoint's own remote code at reduced dimensions: **conv stack 2.98e-8, AttnProjection 1.64e-7, whole encode 1.86e-8**. Its loader takes the half the decoder loader skips and is gated against the same real 1087-tensor manifest, which also confirms the shipped geometry from shapes alone. The wiring is gated on conditioning CHANGING the result, not on being accepted: an audio reference moves the audio rows by **0.51**, a video+audio reference moves them by **0.71** against the silent same-clip control, and a DIFFERENT reference waveform still moves them by 7.1e-4. An audio-bearing block with no encoded rows behind it still THROWS. Driver: `--ref-audio f.wav`, on a library `MiniMaxH3ReadWav` gated against the writer it inverts. NVFP4 remains inconclusive — the ref2va "experimental" file decodes to noise while our fp4 math, BF16 reads and all 20 parsed geometry fields verify correct ([spec](../.agents/specs/minimax-h3.md)) |
 | Command-R / Cohere dense (`CohereForCausalLM`) | Implemented, gate-blocked | ZERO-new-kernel port grounded in vLLM `commandr.py`: weight-only Cohere LayerNorm + GPT-J full-width RoPE + PARALLEL residual + `logit_scale` + tied embeddings, all reuse; compiles, links, self-registers. No SACRED gate yet (real checkpoints HF-gated, ungated ones tiny-random, GPU box disk-full); oracle run-verified at W0. See docs/BENCHMARKS.md |
 | Phi-1 / Phi-2 dense (`PhiForCausalLM`, parallel residual) | Correctness-complete, speed-pending | Token-exact 16/16 (microsoft/phi-2): 9/16 strict + 7/16 bf16 near-ties (max gap 0.25 nats), 0 forward-divergent; the OLDER Microsoft Phi arch, DISTINCT from Phi-3/Phi-4; ZERO new compute kernel (GPT-J parallel residual, LayerNorm-with-bias, biased qkv/dense, partial NeoX rope 32/80, non-gated NewGELU MLP reusing `vt::GeluTanh`, untied biased lm_head); F16 dtype-aware loader |
 | MiniCPM dense (`MiniCPMForCausalLM`, three scalars) | Correctness-complete, speed-pending | Token-exact 16/16 (openbmb/MiniCPM-2B-sft-bf16): 10/16 strict + 6/16 bf16 near-ties (max gap 0.0 nats), 0 forward-divergent; first OpenBMB MiniCPM model; ZERO new compute kernel (the Llama/Granite dense forward plus three scalars: scale_emb, scale_depth/sqrt(layers) residual, dim_model_base logit scaling), tied lm_head; `.bin`-only weights converted to safetensors via trusted torch |
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 707443050..3b3e81005 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -55,3 +55,17 @@ if(VLLM_CPP_SERVER)
       PASS_REGULAR_EXPRESSION "--max-num-seqs N.*--max-num-batched-tokens N.*--cuda-profile-graph-replays N.*--cuda-profile-graph-batch N.*--benchmark-shutdown-fifo F.*--enable-force-include-usage.*--\\[no-\\]enable-prefix-caching")
   endif()
 endif()
+
+# minimax-h3-mux: muxes MiniMax-H3 PPM frames + WAV into an MP4 by invoking
+# ffmpeg. This is the RATIFIED home of that process spawn (developer decision
+# 2026-08-03): the library builds the artifacts and the argv, examples/ runs it.
+add_executable(minimax-h3-mux minimax_h3_mux/main.cpp)
+target_link_libraries(minimax-h3-mux PRIVATE vllm::vllm)
+vllm_cpp_set_warnings(minimax-h3-mux)
+
+# minimax-h3-gen: the ASSEMBLY driver — opens the real checkpoints, runs the whole
+# t2va path and writes an MP4. Lives here because it invokes ffmpeg (the ratified
+# boundary) and because it is a driver, not library surface.
+add_executable(minimax-h3-gen minimax_h3_gen/main.cpp)
+target_link_libraries(minimax-h3-gen PRIVATE vllm::vllm)
+vllm_cpp_set_warnings(minimax-h3-gen)
diff --git a/examples/minimax_h3_gen/main.cpp b/examples/minimax_h3_gen/main.cpp
new file mode 100644
index 000000000..8050aaf26
--- /dev/null
+++ b/examples/minimax_h3_gen/main.cpp
@@ -0,0 +1,732 @@
+// minimax-h3-gen: the ASSEMBLY driver — open the real checkpoints, run the whole
+// t2va path, and write an MP4.
+//
+// Everything below this line was gated component by component (packed layout, DiT
+// forward, both VAE decoders, the encoder towers, the loaders). This is the piece
+// that puts them together over REAL files, which is the only way the remaining
+// integration questions — config plumbing, latent statistics, shard assembly —
+// actually get answered.
+//
+// It lives in examples/ for the same reason the muxer does: this is where the
+// ffmpeg invocation is allowed (developer-ratified 2026-08-03). src/vllm/ builds
+// artifacts and argv and spawns nothing.
+//
+// Usage:
+//   minimax-h3-gen --dit <dit.gguf|dit.safetensors>
+//                  --video-vae <video_vae.safetensors> --video-vae-config <config.json>
+//                  --audio-vae <audio_vae.safetensors> --audio-vae-config <config.json>
+//                  --prompt-embeds <f32.bin>   (rows of text_dim, little-endian f32)
+//                  --out <out.mp4>
+//                  [--keep-quant] [--steps N] [--frames N] [--height N] [--width N]
+//                  [--workdir DIR] [--ffmpeg PATH] [--dry-run]
+//
+// PROMPT EMBEDDINGS are taken as a file rather than computed here, deliberately:
+// the encoder tower needs a tokenizer + a 32B forward, which is its own driver.
+// This keeps the assembly question ("do the checkpoints compose into a video?")
+// separable from the encoding question.
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <optional>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "vllm/model_executor/model_loader/gguf_reader.h"
+#include "vllm/model_executor/model_loader/safetensors_reader.h"
+#include "vllm/model_executor/models/minimax_h3.h"
+#include "vllm/tokenizer/tokenizer.h"
+#include "vt/backend.h"
+
+namespace {
+
+int RunFfmpeg(const std::vector<std::string>& args) {
+  std::vector<char*> argv;
+  argv.reserve(args.size() + 1);
+  for (const std::string& a : args) argv.push_back(const_cast<char*>(a.c_str()));
+  argv.push_back(nullptr);
+  const pid_t pid = fork();
+  if (pid < 0) throw std::runtime_error("fork failed");
+  if (pid == 0) {
+    execvp(argv[0], argv.data());
+    _exit(127);
+  }
+  int status = 0;
+  if (waitpid(pid, &status, 0) < 0) throw std::runtime_error("waitpid failed");
+  if (WIFSIGNALED(status)) {
+    throw std::runtime_error("ffmpeg died on signal " + std::to_string(WTERMSIG(status)));
+  }
+  return WIFEXITED(status) ? WEXITSTATUS(status) : -1;
+}
+
+nlohmann::json ReadJson(const std::string& path) {
+  std::ifstream in(path);
+  if (!in) throw std::runtime_error("cannot open " + path);
+  nlohmann::json j;
+  in >> j;
+  return j;
+}
+
+// A binary PPM (P6) reader, so a reference frame can be handed in with no image
+// dependency -- the same format this example already WRITES for its own output,
+// so a frame from one run can condition the next. Returns [3, H, W] in [-1, 1],
+// which is the range the VAE encoder expects.
+std::vector<float> ReadPpmAsChw(const std::string& path, int64_t* out_h, int64_t* out_w) {
+  std::ifstream in(path, std::ios::binary);
+  if (!in) throw std::runtime_error("cannot open " + path);
+  std::string magic;
+  in >> magic;
+  if (magic != "P6") throw std::runtime_error(path + ": not a binary PPM (P6)");
+  auto next_int = [&]() {
+    int v = 0;
+    while (in >> std::ws, in.peek() == '#') { std::string skip; std::getline(in, skip); }
+    in >> v;
+    return v;
+  };
+  const int w = next_int(), h = next_int(), maxv = next_int();
+  if (w <= 0 || h <= 0 || maxv <= 0) throw std::runtime_error(path + ": bad PPM header");
+  in.get();  // the single whitespace byte before the payload
+  std::vector<unsigned char> rgb(static_cast<size_t>(w) * h * 3);
+  in.read(reinterpret_cast<char*>(rgb.data()), static_cast<std::streamsize>(rgb.size()));
+  if (!in) throw std::runtime_error(path + ": truncated PPM payload");
+  std::vector<float> chw(rgb.size());
+  const int64_t plane = static_cast<int64_t>(w) * h;
+  for (int64_t i = 0; i < plane; ++i) {
+    for (int64_t c = 0; c < 3; ++c) {
+      chw[static_cast<size_t>(c * plane + i)] =
+          static_cast<float>(rgb[static_cast<size_t>(i * 3 + c)]) / (maxv * 0.5f) - 1.0f;
+    }
+  }
+  if (out_h != nullptr) *out_h = h;
+  if (out_w != nullptr) *out_w = w;
+  return chw;
+}
+
+// The WAV reader lives in the LIBRARY (MiniMaxH3ReadWav), next to the writer and
+// unit-gated with it; this only opens the file. Returns CHANNEL-MAJOR samples in
+// [-1, 1], mono repeated up to kMiniMaxH3AudioChannels, and REFUSES a sample rate
+// the audio VAE was not trained at rather than silently mis-encoding it.
+std::vector<float> ReadWavRef(const std::string& path, int64_t* out_channels,
+                              int64_t* out_samples_per_channel) {
+  std::ifstream in(path, std::ios::binary);
+  if (!in) throw std::runtime_error("cannot open " + path);
+  const std::string bytes((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+  if (out_channels != nullptr) *out_channels = vllm::kMiniMaxH3AudioChannels;
+  return vllm::MiniMaxH3ReadWav(bytes, vllm::kMiniMaxH3AudioChannels,
+                                vllm::kMiniMaxH3AudioSampleRate, out_samples_per_channel);
+}
+
+std::vector<float> ReadF32(const std::string& path) {
+  std::ifstream in(path, std::ios::binary | std::ios::ate);
+  if (!in) throw std::runtime_error("cannot open " + path);
+  const std::streamsize bytes = in.tellg();
+  if (bytes % static_cast<std::streamsize>(sizeof(float)) != 0) {
+    throw std::runtime_error(path + ": size is not a whole number of f32 values");
+  }
+  in.seekg(0);
+  std::vector<float> out(static_cast<size_t>(bytes) / sizeof(float));
+  in.read(reinterpret_cast<char*>(out.data()), bytes);
+  return out;
+}
+
+void WriteFile(const std::string& path, const std::string& bytes) {
+  std::ofstream out(path, std::ios::binary);
+  if (!out) throw std::runtime_error("cannot write " + path);
+  out.write(bytes.data(), static_cast<std::streamsize>(bytes.size()));
+}
+
+bool EndsWith(const std::string& s, const std::string& suffix) {
+  return s.size() >= suffix.size() && s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+std::string Need(int argc, char** argv, int i, const std::string& flag) {
+  if (i >= argc) throw std::runtime_error("missing value for " + flag);
+  return argv[i];
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  std::string dit_path, video_vae_path, video_cfg_path, audio_vae_path, audio_cfg_path;
+  std::string embeds_path, out_path, workdir = "/tmp/minimax_h3_gen", ffmpeg = "ffmpeg";
+  bool keep_quant = false, dry_run = false, dequant_bf16 = false, denoise_only = false;
+  bool dump_params = false;
+  std::string device_name = "cpu";
+  std::string encoder_path, prompt, tokenizer_path, save_embeds_path;
+  std::string first_frame_path, last_frame_path;
+  std::vector<std::string> ref_image_paths;
+  std::string ref_video_prefix, ref_audio_path;
+  double imgvid_noise_aug = 1.0;
+  int64_t encoder_max_layers = 0;
+  int64_t steps = 0, frames = 0, height = 0, width = 0;
+
+  try {
+    for (int i = 1; i < argc; ++i) {
+      const std::string f = argv[i];
+      if (f == "--dit") dit_path = Need(argc, argv, ++i, f);
+      else if (f == "--video-vae") video_vae_path = Need(argc, argv, ++i, f);
+      else if (f == "--video-vae-config") video_cfg_path = Need(argc, argv, ++i, f);
+      else if (f == "--audio-vae") audio_vae_path = Need(argc, argv, ++i, f);
+      else if (f == "--audio-vae-config") audio_cfg_path = Need(argc, argv, ++i, f);
+      else if (f == "--prompt-embeds") embeds_path = Need(argc, argv, ++i, f);
+      else if (f == "--out") out_path = Need(argc, argv, ++i, f);
+      else if (f == "--workdir") workdir = Need(argc, argv, ++i, f);
+      else if (f == "--ffmpeg") ffmpeg = Need(argc, argv, ++i, f);
+      else if (f == "--keep-quant") keep_quant = true;
+      else if (f == "--dequant-bf16") dequant_bf16 = true;
+      else if (f == "--dry-run") dry_run = true;
+      else if (f == "--denoise-only") denoise_only = true;
+      else if (f == "--dump-params") dump_params = true;
+      else if (f == "--device") device_name = Need(argc, argv, ++i, f);
+      else if (f == "--encoder") encoder_path = Need(argc, argv, ++i, f);
+      else if (f == "--prompt") prompt = Need(argc, argv, ++i, f);
+      else if (f == "--tokenizer") tokenizer_path = Need(argc, argv, ++i, f);
+      else if (f == "--save-embeds") save_embeds_path = Need(argc, argv, ++i, f);
+      else if (f == "--first-frame") first_frame_path = Need(argc, argv, ++i, f);
+      else if (f == "--last-frame") last_frame_path = Need(argc, argv, ++i, f);
+      else if (f == "--ref-image") ref_image_paths.push_back(Need(argc, argv, ++i, f));
+      else if (f == "--ref-video") ref_video_prefix = Need(argc, argv, ++i, f);
+      else if (f == "--ref-audio") ref_audio_path = Need(argc, argv, ++i, f);
+      else if (f == "--noise-aug") imgvid_noise_aug = std::stod(Need(argc, argv, ++i, f));
+      else if (f == "--encoder-max-layers") encoder_max_layers = std::stoll(Need(argc, argv, ++i, f));
+      else if (f == "--steps") steps = std::stoll(Need(argc, argv, ++i, f));
+      else if (f == "--frames") frames = std::stoll(Need(argc, argv, ++i, f));
+      else if (f == "--height") height = std::stoll(Need(argc, argv, ++i, f));
+      else if (f == "--width") width = std::stoll(Need(argc, argv, ++i, f));
+      else throw std::runtime_error("unknown argument: " + f);
+    }
+    // --denoise-only stops after the DiT step loop, so it needs neither VAE nor an
+    // output path -- and, just as importantly, does not spend their memory. On a
+    // unified-memory box that headroom is the difference between a run and a reboot.
+    // --dump-params reads the manifest and exits, so it needs NOTHING but --dit:
+    // no VAEs, no conditioning, no output path. Requiring them would make the one
+    // tool that works on a checkpoint too large to load unusable on exactly that
+    // checkpoint.
+    const bool need_vaes = !denoise_only && !dump_params;
+    const bool need_cond = !dump_params;
+    if (dit_path.empty() || (need_vaes && (video_vae_path.empty() || audio_vae_path.empty())) ||
+        (need_vaes && out_path.empty()) ||
+        (need_cond && embeds_path.empty() && (encoder_path.empty() || prompt.empty()))) {
+      std::cerr << "usage: minimax-h3-gen --dit <f> --video-vae <f> --audio-vae <f> "
+                   "--prompt-embeds <f32.bin> --out <out.mp4> [--video-vae-config <j>] "
+                   "[--audio-vae-config <j>] [--keep-quant] [--steps N] [--frames N] "
+                   "[--height N] [--width N] [--device cpu|cuda] [--workdir DIR] [--ffmpeg PATH] "
+                   "[--dry-run] [--denoise-only] [--dump-params] "
+                   "[--first-frame f.ppm] [--last-frame f.ppm] [--noise-aug A] "
+                   "[--ref-image f.ppm ...] [--ref-video DIR] [--ref-audio f.wav]\n";
+      return 2;
+    }
+
+    // --dump-params reads the MANIFEST ONLY -- names and shapes, no payload -- and
+    // prints the geometry those shapes imply. That makes it safe on a checkpoint
+    // whose weights do not fit (the NVFP4 reference loader is ~132 GB of host f32),
+    // and it is the right tool for asking "do two checkpoints agree on geometry?"
+    // without running either.
+    if (dump_params) {
+      vllm::MiniMaxH3DitParams pr;
+      if (EndsWith(dit_path, ".gguf")) {
+        const vllm::GgufFile gf = vllm::GgufFile::Open(dit_path);
+        pr = vllm::ParseMiniMaxH3DitParamsFromGgufManifest(vllm::EnumerateMiniMaxH3GgufTensors(gf));
+      } else {
+        const vllm::SafetensorsFile sf = vllm::SafetensorsFile::Open(dit_path);
+        std::vector<vllm::MiniMaxH3TensorSpec> manifest;
+        for (const std::string& name : sf.Names()) {
+          if ((name.size() > 12 && name.compare(name.size() - 12, 12, "weight_scale") == 0) ||
+              (name.size() > 14 && name.compare(name.size() - 14, 14, "weight_scale_2") == 0)) {
+            continue;
+          }
+          const vllm::StTensor& st = sf.Get(name);
+          vllm::MiniMaxH3TensorSpec spec;
+          spec.name = name;
+          spec.shape = st.shape;
+          if (st.dtype == "U8") spec.shape = {st.shape[0], st.shape[1] * 2};
+          manifest.push_back(std::move(spec));
+        }
+        pr = vllm::ParseMiniMaxH3DitParamsFromGgufManifest(manifest);
+      }
+      std::cout << "num_layers=" << pr.num_layers
+                << "\ntoken_refiner_num_layers=" << pr.token_refiner_num_layers
+                << "\nhidden_size=" << pr.hidden_size
+                << "\nnum_attention_heads=" << pr.num_attention_heads
+                << "\nattention_head_dim=" << pr.attention_head_dim
+                << "\nffn_hidden_size=" << pr.ffn_hidden_size
+                << "\nlatents_dim=" << pr.latents_dim
+                << "\naudio_latents_dim=" << pr.audio_latents_dim
+                << "\npatch_size_t=" << pr.patch_size_t
+                << "\npatch_size_h=" << pr.patch_size_h
+                << "\npatch_size_w=" << pr.patch_size_w
+                << "\ntext_dim=" << pr.text_dim
+                << "\ntimestep_input_dim=" << pr.timestep_input_dim
+                << "\ntime_embed_hidden_size=" << pr.time_embed_hidden_size
+                << "\ntime_embed_dim=" << pr.time_embed_dim
+                << "\nadaln_out_features=" << pr.adaln_out_features
+                << "\nfinal_adaln_out_features=" << pr.final_adaln_out_features
+                << "\nrope_inv_freq_len=" << pr.rope_inv_freq_len
+                << "\nvideo_row_width=" << pr.video_row_width()
+                << "\nrope_rot_dim=" << pr.rope_rot_dim() << "\n";
+      return 0;
+    }
+
+    // --- 1. DiT ---
+    std::cerr << "loading DiT " << dit_path << (keep_quant ? " (keep-quant)" : "") << "\n";
+    vllm::MiniMaxH3GgufDit dit;
+    vllm::MiniMaxH3DitDeviceWeights streamed;
+    bool have_streamed = false;
+    if (EndsWith(dit_path, ".gguf")) {
+      const vllm::GgufFile f = vllm::GgufFile::Open(dit_path);
+      // --dequant-bf16 loads STRAIGHT to bf16 (~33 GB). Keeping blocks would leave
+      // the AdaLN projections ineligible (K=2688 is not a whole number of 256-element
+      // Q3_K blocks) and dequantize them to ~52 GB of f32 — which is what does not fit.
+      if (dequant_bf16 && device_name == "cuda") {
+        // STREAM straight onto the device: dequantize + upload one tensor at a time
+        // so the host copy never accumulates. Peak is what kills a unified-memory
+        // box, and load-then-stage holds ~33 GB twice.
+        vt::Queue sq = vt::GetBackend(vt::DeviceType::kCUDA).CreateQueue();
+        const auto t0 = std::chrono::steady_clock::now();
+        streamed = vllm::StreamMiniMaxH3DitToDeviceBf16(sq, f, &dit.params);
+        have_streamed = true;
+        std::cerr << "  streamed DiT -> device (bf16) in "
+                  << std::chrono::duration<double>(std::chrono::steady_clock::now() - t0).count()
+                  << " s\n";
+      } else {
+        dit = dequant_bf16 ? vllm::LoadMiniMaxH3DitFromGgufBf16(f)
+                           : vllm::LoadMiniMaxH3DitFromGguf(f, keep_quant);
+      }
+    } else {
+      const vllm::SafetensorsFile f = vllm::SafetensorsFile::Open(dit_path);
+      if (device_name == "cuda") {
+        // Stream NVFP4 straight to the device. The host-f32 reference loader is
+        // ~132 GB for this checkpoint and gets OOM-killed during load on a
+        // unified-memory box; streaming keeps peak at the device copy plus one
+        // tensor.
+        vt::Queue sq = vt::GetBackend(vt::DeviceType::kCUDA).CreateQueue();
+        const auto t0 = std::chrono::steady_clock::now();
+        streamed = vllm::StreamMiniMaxH3Nvfp4ToDeviceBf16(sq, f, &dit.params);
+        have_streamed = true;
+        std::cerr << "  streamed NVFP4 DiT -> device (bf16) in "
+                  << std::chrono::duration<double>(std::chrono::steady_clock::now() - t0).count()
+                  << " s\n";
+      } else {
+        dit = vllm::LoadMiniMaxH3DitFromNvfp4(f);
+      }
+    }
+    std::cerr << "  layers=" << dit.params.num_layers << " hidden=" << dit.params.hidden_size
+              << " heads=" << dit.params.num_attention_heads << "\n";
+
+    // --- 1b. optional encoder probe. Loading the 32B tower keep-quant is the
+    // precondition for real text conditioning; this reports the geometry it
+    // recovered so the loader can be validated against the REAL file. ---
+    std::vector<float> encoded_prompt;
+    if (!encoder_path.empty()) {
+      std::cerr << "loading encoder " << encoder_path << " (keep-quant)\n";
+      const vllm::GgufFile ef = vllm::GgufFile::Open(encoder_path);
+      const vllm::MiniMaxH3EncoderQuantWeights enc =
+          vllm::LoadMiniMaxH3EncoderFromGguf(ef, encoder_max_layers);
+      vllm::MiniMaxH3EncoderConfig ec = enc.config;
+      std::cerr << "  encoder layers=" << ec.num_hidden_layers << " hidden=" << ec.hidden_size
+                << " heads=" << ec.num_attention_heads << " kv_heads=" << ec.num_key_value_heads
+                << " head_dim=" << ec.head_dim << " ffn=" << ec.intermediate_size << "\n";
+      size_t quant_bytes = 0;
+      for (const auto& kv : enc.quant_storage) quant_bytes += kv.second.size();
+      std::cerr << "  encoder resident (keep-quant) = " << (quant_bytes / (1024.0 * 1024.0 * 1024.0))
+                << " GiB\n";
+
+      if (!prompt.empty()) {
+        // The ComfyUI-style encoder GGUF is WEIGHTS ONLY — it carries no
+        // `tokenizer.ggml.*` metadata, unlike a llama.cpp export — so the vocab
+        // comes from the checkpoint's own tokenizer.json. `--tokenizer` is
+        // therefore required with `--prompt` unless the GGUF happens to embed one.
+        const vllm::tok::Tokenizer tokenizer =
+            tokenizer_path.empty() ? vllm::tok::Tokenizer::FromGguf(ef)
+                                   : vllm::tok::Tokenizer::FromHfJson(tokenizer_path);
+        const std::vector<int32_t> ids = tokenizer.Encode(prompt);
+        VT_CHECK(!ids.empty(), "minimax-h3-gen: the prompt tokenized to nothing");
+        std::cerr << "  prompt tokens = " << ids.size() << "\n";
+        const std::vector<float> embeds = vllm::MiniMaxH3EncoderEmbedTokens(enc, ids);
+        // Text-only: all three M-RoPE axes are the token index.
+        const int64_t seq = static_cast<int64_t>(ids.size());
+        std::vector<int64_t> pos(static_cast<size_t>(3 * seq));
+        for (int64_t a = 0; a < 3; ++a) {
+          for (int64_t s = 0; s < seq; ++s) pos[static_cast<size_t>(a * seq + s)] = s;
+        }
+        vt::Device enc_dev{};
+        if (device_name == "cuda") {
+          enc_dev = vt::GetBackend(vt::DeviceType::kCUDA).CreateQueue().device;
+        }
+        vt::Queue eq{enc_dev, nullptr};
+        vt::Backend& eb = vt::GetBackend(enc_dev.type);
+        if (enc_dev.type != vt::DeviceType::kCPU) eq = eb.CreateQueue();
+        const vllm::MiniMaxH3EncoderDeviceWeights staged =
+            vllm::StageMiniMaxH3EncoderWeights(eq, enc);
+        std::cerr << "  encoding prompt...\n";
+        encoded_prompt =
+            vllm::MiniMaxH3EncoderTextForwardDevice(eq, ec, staged, embeds, pos.data(), seq);
+        std::cerr << "  conditioning = [" << seq << ", " << ec.hidden_size << "]\n";
+        // Persisting the conditioning makes a checkpoint A/B CONTROLLED: two DiTs
+        // can then be compared on byte-identical text conditioning instead of two
+        // separate encoder runs. It also lets the second run skip the 13 GB tower
+        // entirely, which is the difference between fitting and not on a
+        // unified-memory box.
+        if (!save_embeds_path.empty()) {
+          std::ofstream out(save_embeds_path, std::ios::binary);
+          if (!out) throw std::runtime_error("cannot write " + save_embeds_path);
+          out.write(reinterpret_cast<const char*>(encoded_prompt.data()),
+                    static_cast<std::streamsize>(encoded_prompt.size() * sizeof(float)));
+          std::cerr << "  saved conditioning -> " << save_embeds_path << "\n";
+        }
+      }
+    }
+
+    // --- 2. VAEs + their configs (the configs carry the latent statistics) ---
+    vllm::MiniMaxH3VideoVaeDecoderConfig video_cfg;
+    vllm::MiniMaxH3LatentStats video_stats;
+    if (!video_cfg_path.empty()) {
+      video_cfg = vllm::ParseMiniMaxH3VideoVaeDecoderConfig(ReadJson(video_cfg_path), &video_stats);
+    }
+    vllm::MiniMaxH3AudioVaeConfig audio_cfg;
+    vllm::MiniMaxH3LatentStats audio_stats;
+    if (!audio_cfg_path.empty()) {
+      audio_cfg = vllm::ParseMiniMaxH3AudioVaeConfig(ReadJson(audio_cfg_path), &audio_stats);
+    }
+    // The files stay in scope alongside the weights: the loaders read through the
+    // mapping, so releasing it early would leave the weights pointing at nothing.
+    std::optional<vllm::SafetensorsFile> video_file, audio_file;
+    vllm::MiniMaxH3AudioVaeWeights video_weights, audio_weights;
+    if (need_vaes) {
+      std::cerr << "loading video VAE " << video_vae_path << "\n";
+      video_file = vllm::SafetensorsFile::Open(video_vae_path);
+      video_weights = vllm::LoadMiniMaxH3VideoVaeDecoderWeights(*video_file);
+      std::cerr << "loading audio VAE " << audio_vae_path << "\n";
+      audio_file = vllm::SafetensorsFile::Open(audio_vae_path);
+      audio_weights = vllm::LoadMiniMaxH3AudioVaeWeights(*audio_file);
+    }
+
+    // --- 3. request shape ---
+    vllm::MiniMaxH3T2vaRequest request;
+    request.text_len = 0;  // set from the embeddings below
+    if (steps > 0) request.num_steps = steps;
+    // `_resolve_shape` decides frames/canvas/latent_t/audio_t; the latent GRID is
+    // that canvas divided by the VAE's spatial ratio (prod(space_down) = 16).
+    const vllm::MiniMaxH3ShapePlan plan = vllm::MiniMaxH3ResolveShape(
+        "t2va", /*duration_seconds=*/0.0, frames, height, width,
+        /*image_width=*/0, /*image_height=*/0);
+    request.latent_t = plan.latent_t;
+    request.num_frames = plan.num_frames;
+    request.latent_h = plan.height / vllm::kMiniMaxH3VaeRatio;
+    request.latent_w = plan.width / vllm::kMiniMaxH3VaeRatio;
+    request.audio_t = plan.audio_t;
+    request.audio_channel = vllm::kMiniMaxH3AudioChannels;
+    request.video_latents_mean = video_stats.mean;
+    request.video_latents_std = video_stats.std_dev;
+    request.audio_latents_mean = audio_stats.mean;
+    request.audio_latents_std = audio_stats.std_dev;
+
+    // --- ref2va VIDEO reference: a CLIP prepended to the sequence. Reads
+    // DIR/frame_%06d.ppm, which is exactly what this example WRITES, so a previous
+    // run's workdir can be handed straight back in as a reference.
+    if (!ref_video_prefix.empty()) {
+      VT_CHECK(ref_image_paths.empty() && first_frame_path.empty() && last_frame_path.empty(),
+               "minimax-h3-gen: --ref-video is exclusive with --ref-image and --first/--last-frame");
+      VT_CHECK(!video_vae_path.empty(), "minimax-h3-gen: --ref-video needs --video-vae");
+      const vllm::SafetensorsFile vf = vllm::SafetensorsFile::Open(video_vae_path);
+      const vllm::MiniMaxH3AudioVaeWeights enc_w = vllm::LoadMiniMaxH3VideoVaeEncoderWeights(vf);
+      vllm::MiniMaxH3EncoderFcn3dConfig enc_cfg;
+      enc_cfg.z_channels = 2 * dit.params.latents_dim;
+
+      std::vector<float> clip;
+      int64_t ft = 0, fh = 0, fw = 0;
+      for (int64_t k = 0;; ++k) {
+        char nm[512];
+        std::snprintf(nm, sizeof(nm), "%s/frame_%06lld.ppm", ref_video_prefix.c_str(),
+                      static_cast<long long>(k));
+        std::ifstream probe(nm, std::ios::binary);
+        if (!probe) break;
+        probe.close();
+        int64_t h2 = 0, w2 = 0;
+        const std::vector<float> f = ReadPpmAsChw(nm, &h2, &w2);
+        if (ft == 0) { fh = h2; fw = w2; }
+        VT_CHECK(h2 == fh && w2 == fw,
+                 "minimax-h3-gen: every --ref-video frame must have the same size");
+        // [C,H,W] per frame -> [C,T,H,W]: append per channel, so build channel-major.
+        clip.insert(clip.end(), f.begin(), f.end());
+        ++ft;
+      }
+      VT_CHECK(ft > 0, "minimax-h3-gen: --ref-video found no frame_%06d.ppm files");
+      // Re-lay the per-frame [C,H,W] stack into [C,T,H,W].
+      std::vector<float> chw(clip.size());
+      const int64_t plane = fh * fw;
+      for (int64_t c = 0; c < 3; ++c) {
+        for (int64_t k = 0; k < ft; ++k) {
+          for (int64_t e = 0; e < plane; ++e) {
+            chw[static_cast<size_t>((c * ft + k) * plane + e)] =
+                clip[static_cast<size_t>(k * 3 * plane + c * plane + e)];
+          }
+        }
+      }
+      vllm::MiniMaxH3RefBlock vb{};
+      request.keyframe_cond_rows = vllm::MiniMaxH3EncodeReferenceVideo(
+          enc_cfg, enc_w, dit.params, chw, ft, fh, fw, &vb);
+      request.ref_blocks = {vb};
+      std::cerr << "  ref2va: reference VIDEO " << ft << " frames at " << fw << "x" << fh
+                << " (silent)\n";
+    }
+
+    // --- ref2va REFERENCES: whole reference images prepended to the sequence,
+    // as opposed to fl2va which pins frames OF THE OUTPUT. Mutually exclusive.
+    if (!ref_image_paths.empty()) {
+      VT_CHECK(first_frame_path.empty() && last_frame_path.empty(),
+               "minimax-h3-gen: --ref-image (ref2va) and --first/--last-frame (fl2va) are exclusive");
+      VT_CHECK(!video_vae_path.empty(), "minimax-h3-gen: --ref-image needs --video-vae");
+      const vllm::SafetensorsFile vf = vllm::SafetensorsFile::Open(video_vae_path);
+      const vllm::MiniMaxH3AudioVaeWeights enc_w = vllm::LoadMiniMaxH3VideoVaeEncoderWeights(vf);
+      vllm::MiniMaxH3EncoderFcn3dConfig enc_cfg;
+      enc_cfg.z_channels = 2 * dit.params.latents_dim;
+
+      std::vector<std::vector<float>> imgs;
+      int64_t ih = 0, iw = 0;
+      for (const std::string& rp : ref_image_paths) {
+        int64_t h2 = 0, w2 = 0;
+        std::cerr << "loading reference image " << rp << "\n";
+        imgs.push_back(ReadPpmAsChw(rp, &h2, &w2));
+        if (ih == 0) { ih = h2; iw = w2; }
+        VT_CHECK(h2 == ih && w2 == iw,
+                 "minimax-h3-gen: every --ref-image must have the same size");
+      }
+      std::vector<vllm::MiniMaxH3RefBlock> blocks;
+      request.keyframe_cond_rows = vllm::MiniMaxH3EncodeReferenceImages(
+          enc_cfg, enc_w, dit.params, imgs, ih, iw, &blocks);
+      request.ref_blocks = blocks;
+      std::cerr << "  ref2va: " << blocks.size() << " reference image(s) at " << iw << "x" << ih
+                << "\n";
+    }
+
+    // --- ref2va REFERENCE AUDIO: a waveform prepended to the sequence, through
+    // the audio VAE's ENCODER half. It ATTACHES to a video reference when there is
+    // one (one kVideoAudio block carrying both, which is the layout
+    // packed_sequence.py builds), and otherwise stands alone as a kAudio block.
+    if (!ref_audio_path.empty()) {
+      VT_CHECK(first_frame_path.empty() && last_frame_path.empty(),
+               "minimax-h3-gen: --ref-audio (ref2va) and --first/--last-frame (fl2va) are "
+               "exclusive");
+      VT_CHECK(!audio_vae_path.empty(),
+               "minimax-h3-gen: --ref-audio needs --audio-vae (the ENCODER half)");
+      VT_CHECK(!audio_cfg_path.empty(),
+               "minimax-h3-gen: --ref-audio needs --audio-vae-config (it carries the latent "
+               "statistics the reference rows are normalized by)");
+      std::cerr << "loading reference audio " << ref_audio_path << "\n";
+      int64_t wav_channels = 0, wav_samples = 0;
+      const std::vector<float> wave = ReadWavRef(ref_audio_path, &wav_channels, &wav_samples);
+
+      // The audio VAE file is opened again for its ENCODER half; the decoder
+      // loader deliberately skips it, so the two halves are separate weight sets.
+      const vllm::SafetensorsFile af = vllm::SafetensorsFile::Open(audio_vae_path);
+      const vllm::MiniMaxH3AudioVaeWeights aenc = vllm::LoadMiniMaxH3AudioVaeEncoderWeights(af);
+      vllm::MiniMaxH3AudioVaeEncoderConfig aenc_cfg;  // the shipped geometry
+      aenc_cfg.vae_latent_channels = dit.params.audio_latents_dim;
+
+      vllm::MiniMaxH3RefBlock ab{};
+      const std::vector<float> arows = vllm::MiniMaxH3EncodeReferenceAudio(
+          aenc_cfg, aenc, wave, wav_channels, wav_samples, audio_stats.mean, audio_stats.std_dev,
+          /*noise_aug=*/1.0, {}, &ab);
+      request.audio_ref_rows = arows;
+      if (request.ref_blocks.size() == 1 &&
+          request.ref_blocks[0].kind == vllm::MiniMaxH3RefBlock::Kind::kVideoAudio) {
+        // A video reference that now has SOUND: same block, non-zero ref_audio_t.
+        request.ref_blocks[0].ref_audio_t = ab.ref_audio_t;
+        std::cerr << "  ref2va: reference video now carries audio, " << ab.ref_audio_t
+                  << " latent frames\n";
+      } else {
+        request.ref_blocks.push_back(ab);
+        std::cerr << "  ref2va: reference AUDIO " << wav_samples << " samples/channel -> "
+                  << ab.ref_audio_t << " latent frames\n";
+      }
+    }
+
+    // --- fl2va KEYFRAMES: encode the supplied frame(s) into pinned conditioning.
+    // Upstream allows exactly {0}, {-1} or {0, -1}: first, last, or both.
+    if (!first_frame_path.empty() || !last_frame_path.empty()) {
+      VT_CHECK(!video_vae_path.empty(),
+               "minimax-h3-gen: --first-frame/--last-frame need --video-vae (the ENCODER half)");
+      const vllm::SafetensorsFile vf = vllm::SafetensorsFile::Open(video_vae_path);
+      const vllm::MiniMaxH3AudioVaeWeights enc_w = vllm::LoadMiniMaxH3VideoVaeEncoderWeights(vf);
+      vllm::MiniMaxH3EncoderFcn3dConfig enc_cfg;
+      enc_cfg.z_channels = 2 * dit.params.latents_dim;  // moments: mean | logvar
+
+      std::vector<std::vector<float>> imgs;
+      std::vector<int64_t> idx;
+      int64_t ih = 0, iw = 0;
+      if (!first_frame_path.empty()) {
+        std::cerr << "loading first frame " << first_frame_path << "\n";
+        imgs.push_back(ReadPpmAsChw(first_frame_path, &ih, &iw));
+        idx.push_back(0);
+      }
+      if (!last_frame_path.empty()) {
+        int64_t h2 = 0, w2 = 0;
+        std::cerr << "loading last frame " << last_frame_path << "\n";
+        imgs.push_back(ReadPpmAsChw(last_frame_path, &h2, &w2));
+        if (ih == 0) { ih = h2; iw = w2; }
+        VT_CHECK(h2 == ih && w2 == iw,
+                 "minimax-h3-gen: the first and last frames must have the same size");
+        idx.push_back(-1);
+      }
+      request.keyframe_frame_indices = idx;
+      request.imgvid_noise_aug = imgvid_noise_aug;
+      request.keyframe_cond_rows = vllm::MiniMaxH3EncodeKeyframeCondRows(
+          enc_cfg, enc_w, dit.params, imgs, ih, iw, request.latent_t, imgvid_noise_aug, {});
+      std::cerr << "  keyframe conditioning: " << imgs.size() << " frame(s) at " << iw << "x" << ih
+                << " -> " << request.keyframe_cond_rows.size() << " floats\n";
+    }
+
+    // Real conditioning when a prompt was encoded; otherwise the supplied file.
+    const std::vector<float> prompt_embeds =
+        !encoded_prompt.empty() ? encoded_prompt : ReadF32(embeds_path);
+    if (dit.params.text_dim <= 0 || prompt_embeds.size() % static_cast<size_t>(dit.params.text_dim) != 0) {
+      throw std::runtime_error("--prompt-embeds size is not a multiple of text_dim");
+    }
+    request.text_len = static_cast<int64_t>(prompt_embeds.size()) / dit.params.text_dim;
+    std::cerr << "  text_len=" << request.text_len << " latent=" << request.latent_t << "x"
+              << request.latent_h << "x" << request.latent_w << " steps=" << request.num_steps
+              << "\n";
+
+    if (dry_run) {
+      std::cerr << "--dry-run: everything LOADED and planned; stopping before generation\n";
+      return 0;
+    }
+
+    // --- 4. generate ---
+    // NOISE IS AN INPUT (upstream seeds a torch CPU generator, and reproducing its
+    // RNG bit-exactly decides WHICH sample you get, not whether the pipeline is
+    // right), so it is drawn here from the shared deterministic stream.
+    const int64_t frame_rows = (request.latent_h / dit.params.patch_size_h) *
+                               (request.latent_w / dit.params.patch_size_w);
+    const int64_t video_rows = request.latent_t * frame_rows;
+    const int64_t audio_rows = request.audio_t * request.audio_channel;
+    // A splitmix64 stream, seeded so a run is REPRODUCIBLE. This deliberately does
+    // NOT reproduce torch's RNG: matching it bit-for-bit decides WHICH sample you
+    // get, not whether the pipeline is correct, and pretending otherwise would
+    // invite comparing our sample against upstream's as if they should match.
+    auto fill = [](std::vector<float>& out, uint64_t seed) {
+      uint64_t x = seed;
+      for (float& v : out) {
+        x += 0x9E3779B97F4A7C15ULL;
+        uint64_t z = x;
+        z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+        z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+        z ^= z >> 31;
+        v = static_cast<float>((z >> 11) * 0x1.0p-53 * 2.0 - 1.0);
+      }
+    };
+    std::vector<float> noise_video(
+        static_cast<size_t>(video_rows * dit.params.video_row_width()));
+    std::vector<float> noise_audio(
+        static_cast<size_t>(audio_rows * dit.params.audio_latents_dim));
+    fill(noise_video, 0x5EED1234ULL);
+    fill(noise_audio, 0x5EED5678ULL);
+
+    std::cerr << "generating (" << request.num_steps << " steps)...\n";
+    // On a device, the denoise loop stages the DiT weights ONCE and runs every step
+    // device-resident. On CPU it uses the portable reference forward, which is a
+    // correctness path, not a throughput one.
+    vt::Device device{};
+    if (device_name == "cuda") {
+      device = vt::GetBackend(vt::DeviceType::kCUDA).CreateQueue().device;
+    } else if (device_name != "cpu") {
+      throw std::runtime_error("--device must be cpu or cuda");
+    }
+    // Stage ONCE here rather than inside the denoise loop. --dequant-bf16 trades
+    // memory (DiT ~33 GB bf16 vs 15.6 GB kept-quant) for GEMM throughput: the
+    // keep-quant path measured ~103 GFLOP/s, which is what makes a full-quality
+    // render a multi-day job.
+    vllm::MiniMaxH3DitDeviceWeights staged;
+    const vllm::MiniMaxH3DitDeviceWeights* prestaged = nullptr;
+    if (have_streamed) {
+      prestaged = &streamed;
+    } else if (device.type != vt::DeviceType::kCPU) {
+      vt::Queue sq = vt::GetBackend(device.type).CreateQueue();
+      const auto t0 = std::chrono::steady_clock::now();
+      staged = vllm::StageMiniMaxH3DitWeights(sq, dit.params, dit.weights, vt::DType::kBF16);
+      std::cerr << "  staged DiT (" << (dequant_bf16 ? "dequant-bf16" : "keep-quant") << ") in "
+                << std::chrono::duration<double>(std::chrono::steady_clock::now() - t0).count()
+                << " s\n";
+      prestaged = &staged;
+    }
+    if (denoise_only) {
+      // Time the DiT step loop by itself. Reported as an AVERAGE over the requested
+      // steps rather than a single step: the first step pays one-off costs (RoPE
+      // caches, allocator warm-up) that do not recur, so a one-step run overstates
+      // the steady-state cost.
+      const auto t0 = std::chrono::steady_clock::now();
+      const vllm::MiniMaxH3DenoiseResult denoised = vllm::MiniMaxH3DenoiseT2va(
+          device, request, dit.params, dit.weights, prompt_embeds, noise_video, noise_audio,
+          vt::DType::kBF16, prestaged);
+      const double elapsed =
+          std::chrono::duration<double>(std::chrono::steady_clock::now() - t0).count();
+      const int64_t seq = static_cast<int64_t>(request.text_len) + video_rows + audio_rows;
+      // A flow-matching schedule of N sigmas runs N-1 DiT FORWARDS (each step maps
+      // sigma[i] -> sigma[i+1]), which is exactly what the `[h3] step i/N-1` trace
+      // prints. Dividing the elapsed time by `num_steps` therefore UNDER-reports the
+      // per-forward cost by N/(N-1) -- 1.5x at the 3-step setting used for kernel
+      // A/Bs, which is large enough to make two measurements look like a regression.
+      // Report the per-FORWARD cost, which is what the trace and any kernel
+      // comparison are denominated in.
+      const int64_t forwards = request.num_steps > 1 ? request.num_steps - 1 : 1;
+      std::cout << "denoise-only: seq=" << seq << " steps=" << request.num_steps
+                << " forwards=" << forwards << " total=" << elapsed
+                << " s  per_forward=" << (elapsed / double(forwards)) << " s\n";
+      // Touch the result so the loop cannot be optimized away, and so an all-NaN
+      // forward shows up here instead of passing as a fast run.
+      double checksum = 0.0;
+      for (const float v : denoised.video_rows) checksum += v;
+      std::cout << "  video_rows=" << denoised.video_rows.size() << " checksum=" << checksum
+                << "\n";
+      return 0;
+    }
+
+    const vllm::MiniMaxH3T2vaResult result = vllm::MiniMaxH3GenerateT2va(
+        device, request, dit.params, dit.weights, video_cfg, video_weights, audio_cfg,
+        audio_weights, prompt_embeds, noise_video, noise_audio, vt::DType::kBF16, prestaged);
+
+    // --- 5. artifacts (the LIBRARY builds these; nothing spawns) ---
+    std::string mkdir_cmd = "mkdir -p '" + workdir + "'";
+    if (std::system(mkdir_cmd.c_str()) != 0) throw std::runtime_error("cannot create " + workdir);
+    for (int64_t f = 0; f < result.frame_shape.t; ++f) {
+      char name[512];
+      std::snprintf(name, sizeof(name), "%s/frame_%06lld.ppm", workdir.c_str(),
+                    static_cast<long long>(f));
+      WriteFile(name, vllm::MiniMaxH3WritePpmFrame(result.frames, result.frame_shape, f));
+    }
+    const std::string wav_path = workdir + "/audio.wav";
+    WriteFile(wav_path, vllm::MiniMaxH3WriteWav(result.waveform, result.audio_channels,
+                                                result.audio_samples_per_channel,
+                                                result.sample_rate));
+    std::cerr << "  wrote " << result.frame_shape.t << " frames + " << wav_path << "\n";
+
+    // --- 6. mux (the ONE process spawn, and it is in examples/ by decision) ---
+    vllm::MiniMaxH3MuxRequest mux;
+    mux.frame_pattern = workdir + "/frame_%06d.ppm";
+    mux.audio_path = wav_path;
+    mux.output_path = out_path;
+    std::vector<std::string> args = vllm::MiniMaxH3BuildMp4MuxArgs(mux);
+    if (!args.empty()) args[0] = ffmpeg;
+    const int status = RunFfmpeg(args);
+    if (status != 0) {
+      std::cerr << "ffmpeg exited " << status << "\n";
+      return status;
+    }
+    std::cout << "wrote " << out_path << "\n";
+    return 0;
+  } catch (const std::exception& e) {
+    std::cerr << "error: " << e.what() << "\n";
+    return 1;
+  }
+}
diff --git a/examples/minimax_h3_mux/main.cpp b/examples/minimax_h3_mux/main.cpp
new file mode 100644
index 000000000..081feeb98
--- /dev/null
+++ b/examples/minimax_h3_mux/main.cpp
@@ -0,0 +1,135 @@
+// minimax-h3-mux: muxes a MiniMax-H3 clip (PPM frames + WAV) into an MP4 by
+// INVOKING ffmpeg.
+//
+// THIS FILE IS THE RATIFIED HOME OF THE PROCESS SPAWN. The developer's decision
+// (2026-08-03): "re: ffmpeg invocation, correct - let's keep in the examples
+// only". So the split is deliberate and load-bearing:
+//
+//   src/vllm/  builds the ARTIFACTS (MiniMaxH3WritePpmFrame, MiniMaxH3WriteWav)
+//              and the ARGV (MiniMaxH3BuildMp4MuxArgs) -- and spawns NOTHING.
+//   examples/  (here) performs the invocation.
+//
+// That is also why `/v1/videos` takes a caller-supplied `VideoRunner` callback
+// rather than muxing itself: RunFfmpeg below is precisely the piece a server
+// embedder plugs into ApiServer::set_video_runner, and it lives outside the
+// library on purpose. Keep it that way -- do not move fork/exec into src/vllm/.
+//
+// Usage:
+//   minimax-h3-mux --frames <pattern> --out <out.mp4> [--audio <in.wav>]
+//                  [--fps N] [--crf N] [--ffmpeg <path>] [--print-only]
+//
+//   --frames  printf-style pattern the library's PPM writer filled in,
+//             e.g. /tmp/h3/frame_%06d.ppm
+//   --audio   omitted => a silent clip
+//   --print-only  print the argv and exit WITHOUT spawning (lets the argv be
+//                 inspected, diffed or run by hand on a box with no ffmpeg).
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <cstdint>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "vllm/model_executor/models/minimax_h3.h"
+
+namespace {
+
+// Run argv to completion and return its exit status. The ONLY process spawn in
+// the MiniMax-H3 path, and it is in examples/ by project decision.
+int RunFfmpeg(const std::vector<std::string>& args) {
+  std::vector<char*> c_args;
+  c_args.reserve(args.size() + 1);
+  for (const std::string& arg : args) {
+    c_args.push_back(const_cast<char*>(arg.c_str()));
+  }
+  c_args.push_back(nullptr);
+
+  const pid_t pid = fork();
+  if (pid < 0) throw std::runtime_error("fork failed");
+  if (pid == 0) {
+    execvp(c_args[0], c_args.data());
+    // Only reached if exec failed; _exit (not exit) so the child never runs the
+    // parent's atexit handlers or flushes its buffers a second time.
+    _exit(127);
+  }
+  int status = 0;
+  if (waitpid(pid, &status, 0) < 0) throw std::runtime_error("waitpid failed");
+  if (WIFSIGNALED(status)) {
+    throw std::runtime_error("ffmpeg died on signal " +
+                             std::to_string(WTERMSIG(status)));
+  }
+  return WIFEXITED(status) ? WEXITSTATUS(status) : -1;
+}
+
+std::string Need(int argc, char** argv, int i, const std::string& flag) {
+  if (i >= argc) throw std::runtime_error("missing value for " + flag);
+  return argv[i];
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  vllm::MiniMaxH3MuxRequest request;
+  std::string ffmpeg = "ffmpeg";
+  bool print_only = false;
+
+  try {
+    for (int i = 1; i < argc; ++i) {
+      const std::string flag = argv[i];
+      if (flag == "--frames") {
+        request.frame_pattern = Need(argc, argv, ++i, flag);
+      } else if (flag == "--audio") {
+        request.audio_path = Need(argc, argv, ++i, flag);
+      } else if (flag == "--out") {
+        request.output_path = Need(argc, argv, ++i, flag);
+      } else if (flag == "--fps") {
+        request.fps = std::stoll(Need(argc, argv, ++i, flag));
+      } else if (flag == "--crf") {
+        request.crf = std::stoll(Need(argc, argv, ++i, flag));
+      } else if (flag == "--ffmpeg") {
+        ffmpeg = Need(argc, argv, ++i, flag);
+      } else if (flag == "--print-only") {
+        print_only = true;
+      } else {
+        throw std::runtime_error("unknown argument: " + flag);
+      }
+    }
+    if (request.frame_pattern.empty() || request.output_path.empty()) {
+      std::cerr << "usage: minimax-h3-mux --frames <pattern> --out <out.mp4> "
+                   "[--audio <in.wav>] [--fps N] [--crf N] [--ffmpeg <path>] "
+                   "[--print-only]\n";
+      return 2;
+    }
+
+    // The LIBRARY decides the encoding contract (h264/yuv420p + AAC, -shortest,
+    // +faststart); this file only runs it.
+    std::vector<std::string> args = vllm::MiniMaxH3BuildMp4MuxArgs(request);
+    if (!args.empty()) args[0] = ffmpeg;
+
+    for (size_t i = 0; i < args.size(); ++i) {
+      std::cout << (i == 0 ? "" : " ") << args[i];
+    }
+    std::cout << "\n";
+    if (print_only) return 0;
+
+    const int status = RunFfmpeg(args);
+    if (status == 127) {
+      std::cerr << "failed to exec '" << ffmpeg
+                << "' — is ffmpeg installed and on PATH?\n";
+      return 127;
+    }
+    if (status != 0) {
+      std::cerr << "ffmpeg exited " << status << "\n";
+      return status;
+    }
+    std::cout << "wrote " << request.output_path << "\n";
+    return 0;
+  } catch (const std::exception& e) {
+    std::cerr << "error: " << e.what() << "\n";
+    return 1;
+  }
+}
diff --git a/examples/server/main.cpp b/examples/server/main.cpp
index 46594bb7f..409d80448 100644
--- a/examples/server/main.cpp
+++ b/examples/server/main.cpp
@@ -52,6 +52,9 @@
 #include "vllm/config/scheduler.h"
 #include "vllm/entrypoints/chat_template.h"
 #include "vllm/entrypoints/model_loader.h"
+#include "vllm/model_executor/models/minimax_h3.h"
+#include "vllm/model_executor/model_loader/gguf_reader.h"
+#include <fstream>
 #include "vllm/entrypoints/openai/api_server.h"
 #include "vllm/entrypoints/openai/chat_mm.h"
 #include "vllm/entrypoints/openai/serving_chat.h"
@@ -98,6 +101,14 @@ struct Args {
   int max_model_len = 0;  // 0 => config.max_position_embeddings
   int max_num_seqs = 8;
   int max_num_batched_tokens = 0;  // 0 => per-architecture default.
+  // --- MiniMax-H3 video generation (opt-in; absent => /v1/videos is unregistered
+  // and the server behaves exactly as before). ---
+  std::string video_dit, video_vae, video_vae_config, audio_vae, audio_vae_config;
+  std::string video_prompt_embeds, video_workdir = "/tmp/vllm_h3_videos";
+  std::string video_encoder, video_tokenizer;
+  int video_encoder_max_layers = 50;
+  std::string video_ffmpeg = "ffmpeg", video_device = "cuda";
+  bool video_keep_quant = false;
   int cuda_profile_graph_replays = 0;  // trace-only diagnostic build seam.
   int cuda_profile_graph_batch = 0;  // 0 => accepted c16 trace contract.
   std::string benchmark_shutdown_fifo;  // paired trace-only control path.
@@ -209,6 +220,32 @@ Args ParseArgs(int argc, char** argv) {
       a.enable_force_include_usage = true;
     } else if (flag == "--enable-tokenizer-info-endpoint") {
       a.enable_tokenizer_info_endpoint = true;
+    } else if (flag == "--video-dit") {
+      a.video_dit = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-vae") {
+      a.video_vae = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-vae-config") {
+      a.video_vae_config = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--audio-vae") {
+      a.audio_vae = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--audio-vae-config") {
+      a.audio_vae_config = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-encoder") {
+      a.video_encoder = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-tokenizer") {
+      a.video_tokenizer = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-encoder-max-layers") {
+      a.video_encoder_max_layers = std::atoi(NextArg(argc, argv, i, argv[0]).c_str());
+    } else if (flag == "--video-prompt-embeds") {
+      a.video_prompt_embeds = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-workdir") {
+      a.video_workdir = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-ffmpeg") {
+      a.video_ffmpeg = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-device") {
+      a.video_device = NextArg(argc, argv, i, argv[0]);
+    } else if (flag == "--video-keep-quant") {
+      a.video_keep_quant = true;
     } else if (flag == "--enable-server-dev-mode") {
       a.enable_server_dev_mode = true;
     } else if (flag == "--enable-prefix-caching" ||
@@ -547,6 +584,216 @@ int main(int argc, char** argv) {
     // mirroring vLLM 0.26's per-endpoint default gating. /metrics and
     // /reset_prefix_cache stay unwired (no live backing on the AsyncLLM path) —
     // see ConfigureUtilityEndpoints + specs/{utility,admin}-endpoints.md. ────────
+    // ── MiniMax-H3 video generation. OPT-IN: with no --video-dit the routes are
+    // never registered and the server is byte-identical to before. The runner is a
+    // CALLBACK because src/vllm/ must not spawn processes — the ffmpeg invocation
+    // is allowed here, in examples/, by the developer's ratified decision. ───────
+    struct VideoState {
+      vllm::MiniMaxH3GgufDit dit;
+      vllm::MiniMaxH3VideoVaeDecoderConfig video_cfg;
+      vllm::MiniMaxH3AudioVaeConfig audio_cfg;
+      vllm::MiniMaxH3LatentStats video_stats, audio_stats;
+      vllm::MiniMaxH3AudioVaeWeights video_weights, audio_weights;
+      std::vector<float> prompt_embeds;   // fallback when no encoder is configured
+      // Encoder staged ONCE: staging the 32B tower costs ~162 s, so per-request
+      // staging would dominate every generation.
+      bool has_encoder = false;
+      vllm::MiniMaxH3EncoderConfig enc_config;
+      vllm::MiniMaxH3EncoderQuantWeights enc_host;
+      vllm::MiniMaxH3EncoderDeviceWeights enc_staged;
+      std::unique_ptr<vllm::tok::Tokenizer> tokenizer;
+      vt::Queue enc_queue{};
+      std::string workdir, ffmpeg;
+      vt::Device device;
+      std::atomic<int64_t> counter{0};
+    };
+    std::shared_ptr<VideoState> video;
+    if (!args.video_dit.empty()) {
+      video = std::make_shared<VideoState>();
+      std::cerr << "server: loading MiniMax-H3 video checkpoints...\n";
+      if (args.video_dit.size() > 5 &&
+          args.video_dit.compare(args.video_dit.size() - 5, 5, ".gguf") == 0) {
+        const vllm::GgufFile f = vllm::GgufFile::Open(args.video_dit);
+        video->dit = vllm::LoadMiniMaxH3DitFromGguf(f, args.video_keep_quant);
+      } else {
+        const vllm::SafetensorsFile f = vllm::SafetensorsFile::Open(args.video_dit);
+        video->dit = vllm::LoadMiniMaxH3DitFromNvfp4(f);
+      }
+      if (!args.video_vae_config.empty()) {
+        std::ifstream in(args.video_vae_config);
+        nlohmann::json j;
+        in >> j;
+        video->video_cfg = vllm::ParseMiniMaxH3VideoVaeDecoderConfig(j, &video->video_stats);
+      }
+      if (!args.audio_vae_config.empty()) {
+        std::ifstream in(args.audio_vae_config);
+        nlohmann::json j;
+        in >> j;
+        video->audio_cfg = vllm::ParseMiniMaxH3AudioVaeConfig(j, &video->audio_stats);
+      }
+      {
+        const vllm::SafetensorsFile f = vllm::SafetensorsFile::Open(args.video_vae);
+        video->video_weights = vllm::LoadMiniMaxH3VideoVaeDecoderWeights(f);
+      }
+      {
+        const vllm::SafetensorsFile f = vllm::SafetensorsFile::Open(args.audio_vae);
+        video->audio_weights = vllm::LoadMiniMaxH3AudioVaeWeights(f);
+      }
+      if (!args.video_prompt_embeds.empty()) {
+        std::ifstream in(args.video_prompt_embeds, std::ios::binary | std::ios::ate);
+        const std::streamsize n = in.tellg();
+        in.seekg(0);
+        video->prompt_embeds.resize(static_cast<size_t>(n) / sizeof(float));
+        in.read(reinterpret_cast<char*>(video->prompt_embeds.data()), n);
+      }
+      if (!args.video_encoder.empty()) {
+        std::cerr << "server: loading MiniMax-H3 encoder (keep-quant)...\n";
+        const vllm::GgufFile ef = vllm::GgufFile::Open(args.video_encoder);
+        video->enc_host = vllm::LoadMiniMaxH3EncoderFromGguf(ef, args.video_encoder_max_layers);
+        video->enc_config = video->enc_host.config;
+        // The ComfyUI-style encoder export is WEIGHTS ONLY, so the vocab comes from
+        // the checkpoint tokenizer.json unless the GGUF happens to embed one.
+        video->tokenizer = std::make_unique<vllm::tok::Tokenizer>(
+            args.video_tokenizer.empty()
+                ? vllm::tok::Tokenizer::FromGguf(ef)
+                : vllm::tok::Tokenizer::FromHfJson(args.video_tokenizer));
+        video->enc_queue = vt::Queue{video->device, nullptr};
+        if (video->device.type != vt::DeviceType::kCPU) {
+          video->enc_queue = vt::GetBackend(video->device.type).CreateQueue();
+        }
+        std::cerr << "server: staging encoder to device (once)...\n";
+        video->enc_staged = vllm::StageMiniMaxH3EncoderWeights(video->enc_queue, video->enc_host);
+        video->has_encoder = true;
+        std::cerr << "server: encoder ready (layers=" << video->enc_config.num_hidden_layers
+                  << ", hidden=" << video->enc_config.hidden_size << ")\n";
+      }
+      video->workdir = args.video_workdir;
+      video->ffmpeg = args.video_ffmpeg;
+      if (args.video_device == "cuda") {
+        video->device = vt::GetBackend(vt::DeviceType::kCUDA).CreateQueue().device;
+      }
+      std::cerr << "server: /v1/videos on (dit layers=" << video->dit.params.num_layers
+                << ", device=" << args.video_device
+                << (args.video_keep_quant ? ", keep-quant" : "") << ")\n";
+      // HONEST LIMIT, stated at startup rather than buried: turning a PROMPT into
+      // conditioning needs the H3-Encoder (a 32B tower + tokenizer), which is not
+      // wired here. Until it is, every request is conditioned on the SAME supplied
+      // embeddings, so the prompt text does NOT steer the output.
+      if (video->has_encoder) {
+        std::cerr << "server: /v1/videos conditions on the request PROMPT\n";
+      } else if (video->prompt_embeds.empty()) {
+        std::cerr << "server: WARNING /v1/videos has neither --video-encoder nor "
+                     "--video-prompt-embeds; requests will be REJECTED\n";
+      } else {
+        std::cerr << "server: WARNING /v1/videos ignores the request PROMPT — pass "
+                     "--video-encoder to condition on it\n";
+      }
+
+      server.set_video_runner([video](const vllm::openai::VideoRequest& req) -> std::string {
+        // REAL text conditioning when an encoder is configured: tokenize the
+        // request prompt, gather its rows from the block-quant table, and run the
+        // already-staged tower.
+        std::vector<float> conditioning;
+        if (video->has_encoder) {
+          const std::vector<int32_t> ids = video->tokenizer->Encode(req.prompt);
+          if (ids.empty()) throw std::runtime_error("the prompt tokenized to nothing");
+          const std::vector<float> embeds =
+              vllm::MiniMaxH3EncoderEmbedTokens(video->enc_host, ids);
+          const int64_t eseq = static_cast<int64_t>(ids.size());
+          std::vector<int64_t> epos(static_cast<size_t>(3 * eseq));
+          for (int64_t a = 0; a < 3; ++a) {
+            for (int64_t s = 0; s < eseq; ++s) epos[static_cast<size_t>(a * eseq + s)] = s;
+          }
+          vllm::MiniMaxH3EncoderConfig ec = video->enc_config;
+          conditioning = vllm::MiniMaxH3EncoderTextForwardDevice(
+              video->enc_queue, ec, video->enc_staged, embeds, epos.data(), eseq);
+        } else if (!video->prompt_embeds.empty()) {
+          conditioning = video->prompt_embeds;
+        } else {
+          throw std::runtime_error(
+              "video generation needs conditioning: start the server with "
+              "--video-encoder (to condition on the prompt) or --video-prompt-embeds");
+        }
+        const vllm::MiniMaxH3DitParams& p = video->dit.params;
+        vllm::MiniMaxH3T2vaRequest r;
+        const vllm::MiniMaxH3ShapePlan plan = vllm::MiniMaxH3ResolveShape(
+            req.task.empty() ? "t2va" : req.task, req.duration_seconds, req.num_frames,
+            req.height, req.width, 0, 0);
+        r.latent_t = plan.latent_t;
+        r.num_frames = plan.num_frames;
+        r.latent_h = plan.height / vllm::kMiniMaxH3VaeRatio;
+        r.latent_w = plan.width / vllm::kMiniMaxH3VaeRatio;
+        r.audio_t = plan.audio_t;
+        r.audio_channel = vllm::kMiniMaxH3AudioChannels;
+        r.num_steps = req.num_inference_steps;
+        r.video_shift = req.flow_shift;
+        r.audio_shift = req.audio_flow_shift;
+        r.video_latents_mean = video->video_stats.mean;
+        r.video_latents_std = video->video_stats.std_dev;
+        r.audio_latents_mean = video->audio_stats.mean;
+        r.audio_latents_std = video->audio_stats.std_dev;
+        r.text_len = static_cast<int64_t>(conditioning.size()) / p.text_dim;
+
+        const int64_t frame_rows =
+            (r.latent_h / p.patch_size_h) * (r.latent_w / p.patch_size_w);
+        std::vector<float> nv(static_cast<size_t>(r.latent_t * frame_rows *
+                                                  p.video_row_width()));
+        std::vector<float> na(static_cast<size_t>(r.audio_t * r.audio_channel *
+                                                  p.audio_latents_dim));
+        uint64_t x = req.has_seed ? static_cast<uint64_t>(req.seed) : 0x5EED1234ULL;
+        auto fill = [&x](std::vector<float>& o) {
+          for (float& value : o) {
+            x += 0x9E3779B97F4A7C15ULL;
+            uint64_t z = x;
+            z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+            z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+            z ^= z >> 31;
+            value = static_cast<float>((z >> 11) * 0x1.0p-53 * 2.0 - 1.0);
+          }
+        };
+        fill(nv);
+        fill(na);
+
+        const vllm::MiniMaxH3T2vaResult out = vllm::MiniMaxH3GenerateT2va(
+            video->device, r, p, video->dit.weights, video->video_cfg, video->video_weights,
+            video->audio_cfg, video->audio_weights, conditioning, nv, na,
+            vt::DType::kBF16);
+
+        const int64_t id = video->counter.fetch_add(1);
+        const std::string dir = video->workdir + "/job" + std::to_string(id);
+        if (std::system(("mkdir -p '" + dir + "'").c_str()) != 0) {
+          throw std::runtime_error("cannot create " + dir);
+        }
+        for (int64_t f = 0; f < out.frame_shape.t; ++f) {
+          char name[512];
+          std::snprintf(name, sizeof(name), "%s/frame_%06lld.ppm", dir.c_str(),
+                        static_cast<long long>(f));
+          std::ofstream fo(name, std::ios::binary);
+          const std::string bytes =
+              vllm::MiniMaxH3WritePpmFrame(out.frames, out.frame_shape, f);
+          fo.write(bytes.data(), static_cast<std::streamsize>(bytes.size()));
+        }
+        const std::string wav = dir + "/audio.wav";
+        {
+          std::ofstream fo(wav, std::ios::binary);
+          const std::string bytes = vllm::MiniMaxH3WriteWav(
+              out.waveform, out.audio_channels, out.audio_samples_per_channel,
+              out.sample_rate);
+          fo.write(bytes.data(), static_cast<std::streamsize>(bytes.size()));
+        }
+        vllm::MiniMaxH3MuxRequest mux;
+        mux.frame_pattern = dir + "/frame_%06d.ppm";
+        mux.audio_path = wav;
+        mux.output_path = dir + "/video.mp4";
+        std::vector<std::string> argv_mux = vllm::MiniMaxH3BuildMp4MuxArgs(mux);
+        if (!argv_mux.empty()) argv_mux[0] = video->ffmpeg;
+        std::string cmd;
+        for (const std::string& a : argv_mux) cmd += "'" + a + "' ";
+        if (std::system(cmd.c_str()) != 0) throw std::runtime_error("ffmpeg failed");
+        return mux.output_path;
+      });
+    }
+
     oai::UtilityEndpointOptions endpoint_opts;
     endpoint_opts.enable_tokenizer_info_endpoint =
         args.enable_tokenizer_info_endpoint;
diff --git a/include/vllm/entrypoints/openai/api_server.h b/include/vllm/entrypoints/openai/api_server.h
index 0f58fe85b..52f362561 100644
--- a/include/vllm/entrypoints/openai/api_server.h
+++ b/include/vllm/entrypoints/openai/api_server.h
@@ -26,12 +26,15 @@
 #include <cstddef>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <string>
+#include <thread>
 #include <vector>
 
 #include "vllm/entrypoints/openai/serving_chat.h"
 #include "vllm/entrypoints/openai/serving_completion.h"
 #include "vllm/entrypoints/openai/serving_models.h"
+#include "vllm/entrypoints/openai/video_api.h"
 
 namespace vllm::tok {
 class Tokenizer;
@@ -105,6 +108,13 @@ class ApiServer {
   // (serve/instrumentator/metrics.py). Registered only when a metrics logger is
   // attached. Returns 404 (route absent) otherwise; the handler itself returns
   // the exposition with the prometheus content type.
+  // POST /v1/videos       -> enqueue, return {id, status} immediately
+  // POST /v1/videos/sync  -> run to completion, return the .mp4 path
+  // GET  /v1/videos/{id}  -> job status
+  DispatchResult handle_videos(const std::string& request_body);
+  DispatchResult handle_videos_sync(const std::string& request_body);
+  DispatchResult handle_video_status(const std::string& job_id) const;
+
   DispatchResult handle_metrics() const;
   // POST /tokenize, POST /detokenize (serve/tokenize/api_router.py). Registered
   // only when a tokenizer is attached. /tokenize accepts BOTH forms of the
@@ -140,6 +150,19 @@ class ApiServer {
   void set_metrics_logger(const v1::metrics::PrometheusStatLogger* logger) {
     metrics_ = logger;
   }
+  // Attach the video generation+mux runner backing POST /v1/videos and
+  // POST /v1/videos/sync (MiniMax-H3). ADDITIVE and OPT-IN like the routes
+  // above: absent runner => routes unregistered => 404, byte-identical to a
+  // server built without video support.
+  //
+  // The runner performs generation AND muxing and returns the .mp4 path, or
+  // throws to fail the job. The LIBRARY NEVER SPAWNS A PROCESS -- the ffmpeg
+  // invocation lives in examples/ (developer-ratified 2026-08-03), which is
+  // precisely why this enters as a callback rather than a built-in.
+  void set_video_runner(::vllm::openai::VideoRunner runner) {
+    video_runner_ = std::move(runner);
+  }
+
   // Attach the tokenizer + max_model_len backing /tokenize and /detokenize
   // (non-owning; must outlive the server).
   void set_tokenizer(const vllm::tok::Tokenizer* tokenizer,
@@ -197,6 +220,13 @@ class ApiServer {
 
   // Opt-in C8 backings (all nullptr/empty by default → routes not registered).
   const v1::metrics::PrometheusStatLogger* metrics_ = nullptr;
+  ::vllm::openai::VideoRunner video_runner_;
+  mutable ::vllm::openai::VideoJobStore video_jobs_;
+  // Background workers for the ASYNC endpoint. Joined in ~ApiServer, which is
+  // why they are joinable threads and not detached: a detached worker would
+  // outlive `this` and write into a destroyed job store.
+  std::vector<std::thread> video_workers_;
+  std::mutex video_workers_mutex_;
   const vllm::tok::Tokenizer* tokenizer_ = nullptr;
   int64_t max_model_len_ = 0;
   bool tokenizer_info_enabled_ = false;
diff --git a/include/vllm/entrypoints/openai/video_api.h b/include/vllm/entrypoints/openai/video_api.h
new file mode 100644
index 000000000..4bc7c3bb3
--- /dev/null
+++ b/include/vllm/entrypoints/openai/video_api.h
@@ -0,0 +1,82 @@
+// MiniMax-H3 `/v1/videos` serving surface — request parsing and the job store.
+//
+// Mirrors vLLM-Omni's two endpoints:
+//   POST /v1/videos       -> enqueue, return a job id immediately (async)
+//   POST /v1/videos/sync  -> run to completion, return the MP4 in the body
+//
+// THE PROCESS BOUNDARY (developer-ratified 2026-08-03): the library never spawns
+// a process. Generation and muxing are supplied by the caller as a `VideoRunner`
+// callback; `examples/` provides one that invokes ffmpeg with the argv built by
+// MiniMaxH3BuildMp4MuxArgs. So this header owns the REQUEST CONTRACT and the JOB
+// LIFECYCLE, both pure and unit-testable, and nothing else.
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace vllm::openai {
+
+// One parsed /v1/videos request. Mirrors the fields vLLM-Omni accepts; anything
+// absent falls back to H3's documented defaults via the shape planner.
+struct VideoRequest {
+  std::string prompt;
+  std::string task;            // "" => resolved from the partition + inputs
+  double duration_seconds = 0.0;  // <= 0 => per-task default
+  int64_t num_frames = 0;         // <= 1 => per-task default
+  int64_t height = 0, width = 0;  // <= 0 => aspect-derived default
+  int64_t num_inference_steps = 50;
+  double flow_shift = 12.0;        // video
+  double audio_flow_shift = 3.0;   // audio
+  int64_t seed = 0;
+  bool has_seed = false;
+};
+
+// Parse + validate a request body. Throws (VT_CHECK) with a specific message on
+// malformed input rather than silently defaulting, so a bad request is a 400 with
+// a reason instead of a surprising generation.
+VideoRequest ParseVideoRequest(const std::string& body);
+
+enum class VideoJobStatus { kQueued, kRunning, kSucceeded, kFailed };
+
+const char* VideoJobStatusName(VideoJobStatus status);
+
+struct VideoJob {
+  std::string id;
+  VideoJobStatus status = VideoJobStatus::kQueued;
+  std::string output_path;  // set on success
+  std::string error;        // set on failure
+};
+
+// A minimal job registry for the async endpoint. Thread-safe: the HTTP worker
+// pool touches it from several threads.
+class VideoJobStore {
+ public:
+  // Creates a job in `kQueued` and returns its id.
+  std::string Create();
+  // Legal transitions only: queued -> running -> {succeeded, failed}. An illegal
+  // transition throws rather than corrupting the record.
+  void MarkRunning(const std::string& id);
+  void MarkSucceeded(const std::string& id, const std::string& output_path);
+  void MarkFailed(const std::string& id, const std::string& error);
+  // False when the id is unknown (a 404 rather than an empty 200).
+  bool Get(const std::string& id, VideoJob* out) const;
+  int64_t Size() const;
+
+ private:
+  mutable std::mutex mutex_;
+  std::map<std::string, VideoJob> jobs_;
+  int64_t next_ = 0;
+};
+
+// The caller-supplied generation+mux step. Returns the produced .mp4 path, or
+// throws to fail the job. `examples/` implements this with ffmpeg.
+using VideoRunner = std::function<std::string(const VideoRequest&)>;
+
+// The JSON body for a job-status query (`GET /v1/videos/{id}`).
+std::string VideoJobStatusJson(const VideoJob& job);
+
+}  // namespace vllm::openai
diff --git a/include/vllm/model_executor/models/minimax_h3.h b/include/vllm/model_executor/models/minimax_h3.h
new file mode 100644
index 000000000..87e9dbc5f
--- /dev/null
+++ b/include/vllm/model_executor/models/minimax_h3.h
@@ -0,0 +1,1511 @@
+// MiniMax-H3 (`MiniMaxAI/MiniMax-H3`) — the omni-modal video+audio DIFFUSION
+// transformer, ported from vLLM-Omni (vllm-project/vllm-omni). This is the
+// project's FIRST diffusion architecture: H3 is not an autoregressive decoder, so
+// it has no KV cache, no sampler, and no logits. One request runs a fixed 50-step
+// flow-matching denoise loop in which the DiT is forwarded ONCE per step over the
+// WHOLE packed sequence, and the resulting latents are decoded to frames + a
+// stereo waveform by two VAEs.
+//
+// ─── HONESTY (up front) ──────────────────────────────────────────────────────
+// The real checkpoint is ~354 GB (33.1B DiT + a Qwen3-VL-32B-derived encoder + a
+// video VAE + an audio VAE) and its validated serving config is 4x NVIDIA B300 at
+// ~133 GB peak per rank. That does not fit this project's hardware (one GB10, 119
+// GiB UNIFIED), so there is NO end-to-end token/frame gate for H3 on this box and
+// none is claimed. What IS gated here is exact: the layout math, the scheduler,
+// and the DiT forward are compared against the UPSTREAM vLLM-Omni modules
+// executed at reduced dimensions (scripts/gen-minimax-h3-goldens.py). Structure
+// and math are proven; end-to-end generation is hardware-blocked. Full lifecycle,
+// component inventory, and the remaining bricks: .agents/specs/minimax-h3.md.
+//
+// ─── WHAT THIS IS A PORT OF (file:line on BOTH sides) ────────────────────────
+// Upstream root: vllm-project/vllm-omni, vllm_omni/diffusion/models/minimax_h3/
+//   OURS                                  <-  UPSTREAM
+//   MiniMaxH3DitParams                    <-  minimax_h3_transformer.py:47-78
+//                                             (MiniMaxH3DiTArchConfig.from_mapping)
+//   MiniMaxH3PatchifyVideoLatent          <-  packed_tokens.py:23-41
+//   MiniMaxH3UnpatchifyVideoTokens        <-  packed_tokens.py:44-70
+//   MiniMaxH3PackAudioLatent              <-  packed_tokens.py:73-85
+//   MiniMaxH3UnpackAudioTokens            <-  packed_tokens.py:88-106
+//   BuildMiniMaxH3PackedSequence          <-  packed_sequence.py:116-239
+//   BuildMiniMaxH3PackedSequenceRef2va    <-  packed_sequence.py:290-557
+//   MiniMaxH3RfVToX0                      <-  scheduling_...euler_ancestral.py:49-69
+//   MiniMaxH3EulerEta0Step                <-  scheduling_...euler_ancestral.py:72-102
+//   MiniMaxH3DitForward                   <-  minimax_h3_transformer.py:986-1102
+//   EnumerateMiniMaxH3DitTensors          <-  minimax_h3_transformer.py:906-922
+//   MiniMaxH3ReorderGroupedQkv            <-  minimax_h3_transformer.py:139-168
+//   MiniMaxH3DenoiseLoop                  <-  denoise_loop.py:129-239
+//   MiniMaxH3TimeShiftSigmas / shape plan <-  time_request.py:5-61,
+//                                            pipeline_minimax_h3.py:121-122,
+//                                            207-222, 374-434
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "vt/device.h"
+#include "vt/tensor.h"
+
+namespace vllm {
+
+// ---------------------------------------------------------------------------
+// Architecture
+// ---------------------------------------------------------------------------
+
+// MiniMaxH3DiTArchConfig (minimax_h3_transformer.py:47-78). Defaults are the
+// SHIPPED MiniMax-H3 geometry; `ParseMiniMaxH3DitParams` overrides any key the
+// checkpoint's transformer config actually carries, exactly like `from_mapping`.
+struct MiniMaxH3DitParams {
+  int64_t num_layers = 50;
+  int64_t token_refiner_num_layers = 2;
+  int64_t hidden_size = 5376;
+  int64_t num_attention_heads = 56;  // MHA: num_kv_heads == num_attention_heads
+  int64_t attention_head_dim = 128;
+  int64_t ffn_hidden_size = 14336;
+  int64_t latents_dim = 24;        // video VAE latent channels
+  int64_t audio_latents_dim = 32;  // audio VAE latent channels
+  int64_t patch_size_t = 1;
+  int64_t patch_size_h = 2;
+  int64_t patch_size_w = 2;
+  int64_t text_dim = 5120;  // H3-Encoder hidden width (Qwen3-VL layer 50)
+  int64_t timestep_input_dim = 256;
+  int64_t time_embed_hidden_size = 5376;
+  int64_t time_embed_dim = 2688;
+  int64_t adaln_out_features = 18 * 5376;      // 6 vectors x 3 modalities x H
+  int64_t final_adaln_out_features = 2 * 5376;  // 2 vectors x 1 modality x H
+  int64_t rope_inv_freq_len = 16;
+  double norm_eps = 1e-5;
+  double qk_norm_eps = 1e-5;
+  double final_norm_eps = 1e-5;
+
+  // Derived. video_row_width is the packed video token width
+  // (latents_dim * patch volume; 24*1*2*2 = 96 at shipped scale).
+  int64_t video_row_width() const {
+    return latents_dim * patch_size_t * patch_size_h * patch_size_w;
+  }
+  // 3D RoPE rotates 6*rope_inv_freq_len of attention_head_dim dims
+  // (minimax_h3_transformer.py:207-230; 96 of 128 at shipped scale).
+  int64_t rope_rot_dim() const { return 6 * rope_inv_freq_len; }
+};
+
+// AdaLN modality count: token tags are -1 padding and 0/1/2 for video/text/audio
+// (minimax_h3_transformer.py:103-106).
+inline constexpr int64_t kMiniMaxH3AdalnModalityNum = 3;
+
+// Packed-sequence token tags (packed_sequence.py:218-221).
+inline constexpr int64_t kMiniMaxH3TagPadding = -1;
+inline constexpr int64_t kMiniMaxH3TagVideo = 0;
+inline constexpr int64_t kMiniMaxH3TagText = 1;
+inline constexpr int64_t kMiniMaxH3TagAudio = 2;
+
+// Packed-sequence placeholder input ids (packed_sequence.py:27-35).
+inline constexpr int64_t kMiniMaxH3TextId = -5;
+inline constexpr int64_t kMiniMaxH3ImgVidCondId = -11;
+inline constexpr int64_t kMiniMaxH3AudioRefCondId = -17;
+inline constexpr int64_t kMiniMaxH3AudioFirstId = -15;
+inline constexpr int64_t kMiniMaxH3AudioId = -14;
+inline constexpr int64_t kMiniMaxH3VideoFirstId = -3;
+inline constexpr int64_t kMiniMaxH3VideoId = -2;
+inline constexpr int64_t kMiniMaxH3VideoLastId = -4;
+inline constexpr int64_t kMiniMaxH3PadId = -1;
+
+// Condition anchor timesteps (denoise_loop.py:22-24).
+inline constexpr double kMiniMaxH3ImgVidCondTimestep = 0.999;
+inline constexpr double kMiniMaxH3AudioRefCondTimestep = 1.0;
+
+// Parse the checkpoint transformer config. Mirrors `from_mapping`: unknown keys
+// are ignored, present keys override, and `patch_size` must carry three values.
+MiniMaxH3DitParams ParseMiniMaxH3DitParams(const nlohmann::json& config);
+
+// ---------------------------------------------------------------------------
+// Latent <-> packed-token conversion (packed_tokens.py). Host-side layout math on
+// f32 rows; these move bytes, they do not compute, so they stay off the device.
+// ---------------------------------------------------------------------------
+
+// [B,C,T,H,W] -> [B*t*h*w, C*pt*ph*pw] (packed_tokens.py:23-41).
+std::vector<float> MiniMaxH3PatchifyVideoLatent(const std::vector<float>& latent, int64_t batch,
+                                                int64_t channels, int64_t full_t, int64_t full_h,
+                                                int64_t full_w, int64_t patch_t, int64_t patch_h,
+                                                int64_t patch_w);
+
+// Inverse of the above (packed_tokens.py:44-70). `rows` is [N, C*pt*ph*pw].
+std::vector<float> MiniMaxH3UnpatchifyVideoTokens(const std::vector<float>& rows, int64_t t,
+                                                  int64_t h, int64_t w, int64_t channels,
+                                                  int64_t patch_t, int64_t patch_h, int64_t patch_w);
+
+// [audio_channel, latent_dim, T] -> [audio_channel*T, latent_dim]
+// (packed_tokens.py:73-85).
+std::vector<float> MiniMaxH3PackAudioLatent(const std::vector<float>& latent, int64_t audio_channel,
+                                            int64_t latent_dim, int64_t steps);
+
+// Inverse (packed_tokens.py:88-106). `rows` is [audio_t, latent_dim].
+std::vector<float> MiniMaxH3UnpackAudioTokens(const std::vector<float>& rows, int64_t audio_t,
+                                              int64_t audio_channel, int64_t latent_dim);
+
+// ---------------------------------------------------------------------------
+// Packed sequence (packed_sequence.py)
+// ---------------------------------------------------------------------------
+
+// The structural fields of one CFG branch's packed sequence. Layout:
+//   [text L | imgvid_cond C | audio A | video_target V | pad P]
+// The used length is padded up to a multiple of 64 and the padding becomes a
+// SECOND attention document, so attention never crosses into it.
+struct MiniMaxH3PackedSequence {
+  int64_t seq_len = 0;
+  std::vector<int64_t> input_ids;    // [seq_len] placeholder ids
+  std::vector<uint8_t> image_mask;   // [seq_len]
+  std::vector<uint8_t> audio_mask;   // [seq_len]
+  std::vector<int64_t> img_pos;      // cond rows then target rows
+  std::vector<int64_t> audio_pos;    // reference rows then target rows
+  std::vector<int64_t> text_pos;     // [0, text_len)
+  std::vector<uint8_t> update_mask;  // per img_pos row: is it a denoise target?
+  std::vector<uint8_t> audio_update_mask;  // per audio_pos row (ref2va only)
+  // [seq_len, 3] (t, h, w) grid in FP64. Kept as double on purpose: the grid is
+  // built by fp64 accumulations whose last ulp feeds RoPE, and upstream keeps two
+  // deliberately DIFFERENT summation orders for it (see packed_sequence.py:101-113).
+  std::vector<double> img_position_ids;
+  std::vector<int64_t> token_tags;   // [seq_len]
+  std::vector<int32_t> cu_seqlens;   // {0, used, seq_len}
+  std::vector<int32_t> document_id;  // [seq_len]; 1 on the padding document
+};
+
+// fl2va / t2va layout (packed_sequence.py:116-239). `keyframe_frame_indices` must
+// be one of {}, {0}, {-1}, {0,-1} and requires `frame_count` when non-empty.
+MiniMaxH3PackedSequence BuildMiniMaxH3PackedSequence(int64_t text_len, int64_t latent_t,
+                                                     int64_t latent_h, int64_t latent_w,
+                                                     int64_t audio_t, int64_t audio_channel,
+                                                     bool include_keyframe_cond,
+                                                     const std::vector<int64_t>& keyframe_frame_indices,
+                                                     int64_t frame_count);
+
+// One ref2va reference block (packed_sequence.py:290-313).
+struct MiniMaxH3RefBlock {
+  enum class Kind { kImage, kAudio, kVideoAudio };
+  Kind kind = Kind::kImage;
+  int64_t ref_audio_t = 0;
+  int64_t latent_t = 0;
+  int64_t latent_h = 0;
+  int64_t latent_w = 0;
+};
+
+// General ref2va-family layout (packed_sequence.py:290-557).
+MiniMaxH3PackedSequence BuildMiniMaxH3PackedSequenceRef2va(
+    int64_t text_len, int64_t latent_t, int64_t latent_h, int64_t latent_w, int64_t audio_t,
+    const std::vector<MiniMaxH3RefBlock>& ref_blocks, int64_t audio_channel);
+
+// ---------------------------------------------------------------------------
+// Request planning (time_request.py + pipeline_minimax_h3.py shape resolution)
+// ---------------------------------------------------------------------------
+
+// Output frame rate is FIXED (pipeline_minimax_h3.py:83).
+inline constexpr int64_t kMiniMaxH3Fps = 24;
+// Reference-image rescale target (pipeline_minimax_h3.py:87-88).
+inline constexpr int64_t kMiniMaxH3ReferenceImageShortEdge = 2048;
+inline constexpr int64_t kMiniMaxH3ReferenceImageMultiple = 32;
+// Default frame counts when the request names neither duration nor num_frames
+// (pipeline_minimax_h3.py:405).
+inline constexpr int64_t kMiniMaxH3DefaultFramesT2va = 209;
+inline constexpr int64_t kMiniMaxH3DefaultFramesRef2va = 124;
+// Default sigma shift scales (pipeline_minimax_h3.py:283-285).
+inline constexpr double kMiniMaxH3DefaultVideoShift = 12.0;
+inline constexpr double kMiniMaxH3DefaultAudioShift = 3.0;
+inline constexpr int64_t kMiniMaxH3DefaultSteps = 50;
+
+// Snap up to the 17n+5 frame boundary (time_request.py:5-12).
+int64_t MiniMaxH3AlignFrameCount(int64_t frame_count);
+// frame_count -> video latent T (time_request.py:15-18).
+int64_t MiniMaxH3VideoLatentT(int64_t frame_count);
+// Inverse; T must be 1 or match 5n+2 (time_request.py:21-26).
+int64_t MiniMaxH3FrameCountFromVideoLatentT(int64_t out_t);
+// Audio latents run at 40 Hz (time_request.py:29-31).
+int64_t MiniMaxH3AudioLatentT(double duration_seconds);
+// `max(multiple, round(value/multiple)*multiple)` (pipeline_minimax_h3.py:121-122).
+int64_t MiniMaxH3AlignMultiple(double value, int64_t multiple);
+// Reference image rescale to a 2048 short edge on a 32 grid
+// (pipeline_minimax_h3.py:207-222). Returns {width, height}.
+std::pair<int64_t, int64_t> MiniMaxH3ReferenceImageShape(int64_t width, int64_t height);
+
+// The rectified-flow time-shifted sigma schedule (time_request.py:34-61):
+// base = linspace(1, 0, num_steps); sigma = s*base / (1 + (s-1)*base); duplicate
+// consecutive values are collapsed and a terminal 0 is appended when needed.
+std::vector<double> MiniMaxH3TimeShiftSigmas(int64_t num_steps, double shift_scale);
+
+// --- reference-video input geometry (reference_video.py) ---
+// Only the PURE-MATH half is ported; probe/transcode/decode shell out to ffmpeg
+// and share the MP4-muxing dependency decision (spec section 5.2).
+inline constexpr int64_t kMiniMaxH3RefVideoShortEdge = 768;
+inline constexpr int64_t kMiniMaxH3RefVideoMaxPixels = 768 * 1344;
+inline constexpr int64_t kMiniMaxH3RefVideoCanvasMultiple = 32;
+inline constexpr int64_t kMiniMaxH3QwenVideoSampleFps = 2;
+inline constexpr int64_t kMiniMaxH3QwenTemporalPatch = 2;
+
+// Reference-video canvas: aspect clamp -> 768 short edge -> max-pixel rescale ->
+// nearest multiple of 32. Returns {width, height}.
+std::pair<int64_t, int64_t> MiniMaxH3ReferenceVideoShape(int64_t width, int64_t height);
+
+struct MiniMaxH3ReferenceVideoSchedule {
+  std::vector<int64_t> indices;          // source frame indices to extract
+  std::vector<double> block_timestamps;  // one per temporal patch
+};
+
+// 24 FPS resampled to the 2 FPS Qwen video rate (duplicate indices dropped), then
+// timestamps averaged per temporal patch with the tail padded by REPEATING the last.
+MiniMaxH3ReferenceVideoSchedule MiniMaxH3ReferenceVideoFrameSchedule(int64_t frame_count);
+
+// The resolved generation plan for one request.
+struct MiniMaxH3ShapePlan {
+  int64_t height = 0;
+  int64_t width = 0;
+  int64_t num_frames = 0;
+  int64_t latent_t = 0;
+  int64_t audio_t = 0;
+};
+
+// `_resolve_shape` (pipeline_minimax_h3.py:393-434). Pass `duration_seconds <= 0`
+// and `requested_frames <= 1` to take the per-task default; pass
+// `height`/`width` <= 0 to take the aspect-derived default (which needs the
+// keyframe aspect for fl2va, hence `image_width`/`image_height`).
+MiniMaxH3ShapePlan MiniMaxH3ResolveShape(const std::string& task, double duration_seconds,
+                                         int64_t requested_frames, int64_t height, int64_t width,
+                                         int64_t image_width, int64_t image_height);
+
+// `_resolve_task` (pipeline_minimax_h3.py:374-391). `requested` may be empty.
+std::string MiniMaxH3ResolveTask(const std::string& requested, const std::string& partition,
+                                 bool has_image, const std::vector<std::string>& supported_tasks);
+
+// ---------------------------------------------------------------------------
+// Flow-matching scheduler (scheduling_minimax_h3_euler_ancestral.py)
+// ---------------------------------------------------------------------------
+
+// x0 = xt + (1 - t) * v (scheduling:49-69). Rectified-flow velocity -> clean sample.
+std::vector<float> MiniMaxH3RfVToX0(const std::vector<float>& xt, const std::vector<float>& v,
+                                    double timestep);
+
+// ---------------------------------------------------------------------------
+// Presentation token tags (presentation.py) — the fl2va vision-span override
+//
+// The denoise loop requires `token_tags` to already carry the presentation's
+// vision spans. A vision block is `<|vision_start|> + pad*count + <|vision_end|>`
+// and the WHOLE block — markers included — is tagged VIDEO; tagging only the pads
+// shifts every AdaLN modulation index after it. Tokenization stays with the caller.
+// ---------------------------------------------------------------------------
+
+struct MiniMaxH3PresentationSpan {
+  enum class Kind { kText, kVision };
+  Kind kind = Kind::kText;
+  int64_t length = 0;  // token count of this span
+};
+
+// Token length of a vision block carrying `pad_count` image/video pads.
+int64_t MiniMaxH3VisionBlockTokenLength(int64_t pad_count);
+
+// AdaLN token tags aligned with a presentation's span layout.
+std::vector<int64_t> MiniMaxH3BuildPresentationTokenTags(
+    const std::vector<MiniMaxH3PresentationSpan>& spans);
+
+// ---------------------------------------------------------------------------
+// Condition-noise augmentation (condition_noise.py) — fl2va / ref2va
+// ---------------------------------------------------------------------------
+
+// Packed row widths (denoise_loop.py:26-28).
+inline constexpr int64_t kMiniMaxH3VideoRowWidth = 96;
+inline constexpr int64_t kMiniMaxH3AudioRowWidth = 32;
+// Channel-major packed audio condition rows are always stereo.
+inline constexpr int64_t kMiniMaxH3AudioCondChannels = 2;
+
+// out = noise_aug*clean + (1 - noise_aug)*noise, over packed condition rows.
+// `condition_shapes` is a flat list of (latent_t, latent_h, latent_w) triples in
+// packed visual-condition order. NOISE IS AN INPUT (see the .cpp for why).
+std::vector<float> MiniMaxH3ImgvidCondNoiseAug(const std::vector<float>& clean_rows,
+                                               const std::vector<int64_t>& condition_shapes,
+                                               int64_t target_latent_t,
+                                               int64_t imgvid_cond_num_frames, double noise_aug,
+                                               const std::vector<float>& noise_rows);
+
+// The audio-side equivalent; `condition_audio_t` is the latent T of each
+// audio-bearing condition in request order.
+std::vector<float> MiniMaxH3AudioCondNoiseAug(const std::vector<float>& clean_rows,
+                                              const std::vector<int64_t>& condition_audio_t,
+                                              double noise_aug,
+                                              const std::vector<float>& noise_rows);
+
+// Ancestral Euler with eta = 0 (scheduling:72-102):
+//   out = r * state + (1 - r) * denoised,  r = sigma_next / sigma_curr.
+// sigma_curr == 0 is the terminal step and returns `state` unchanged.
+std::vector<float> MiniMaxH3EulerEta0Step(const std::vector<float>& state,
+                                          const std::vector<float>& denoised, double sigma_curr,
+                                          double sigma_next);
+
+// ---------------------------------------------------------------------------
+// DiT weights + forward
+// ---------------------------------------------------------------------------
+
+// Checkpoint tensor names in load order, with their expected shapes. The H3 DiT
+// loads by EXACT checkpoint name (minimax_h3_transformer.py:906-922), so this
+// enumeration IS the weight contract and is gated structurally without the
+// checkpoint.
+struct MiniMaxH3TensorSpec {
+  std::string name;
+  std::vector<int64_t> shape;
+  // The 12 latent/timestep/output params and the RoPE buffer stay FP32 after load
+  // (minimax_h3_transformer.py:85-101, 898-904); everything else is BF16.
+  bool fp32 = false;
+};
+
+std::vector<MiniMaxH3TensorSpec> EnumerateMiniMaxH3DitTensors(const MiniMaxH3DitParams& params);
+
+// --- GGUF arm (minimax_h3_gguf.cpp) ---
+// The ComfyUI-format H3 GGUFs keep the checkpoint's own parameter names, so the
+// name map is the IDENTITY against the contract above; only the SHAPES need
+// resolving. GGUF `ne` is reversed relative to torch, EXCEPT where ComfyUI had to
+// reshape a tensor for quant-block alignment, in which case the true torch shape
+// is recorded in `comfy.gguf.orig_shape.<name>` and is used verbatim.
+std::vector<int64_t> MiniMaxH3GgufLogicalShape(const std::vector<int64_t>& gguf_dims,
+                                               const std::vector<int64_t>& orig_shape);
+
+// A ComfyUI GGUF carries no transformer config, so the SHAPES are the config.
+MiniMaxH3DitParams ParseMiniMaxH3DitParamsFromGgufManifest(
+    const std::vector<MiniMaxH3TensorSpec>& manifest);
+
+class GgufFile;
+// Names + logical shapes + fp32-island flags read out of a GGUF.
+std::vector<MiniMaxH3TensorSpec> EnumerateMiniMaxH3GgufTensors(const GgufFile& file);
+
+// ---------------------------------------------------------------------------
+// Audio VAE decoder (minimax_h3_audio_vae.cpp)
+//
+// H3's two VAEs are checkpoint REMOTE CODE loaded under `trust_remote_code`
+// (vae.py:41-53); vLLM-Omni only ADAPTS them, so a no-Python engine must
+// REIMPLEMENT them. This is the audio side: a DAC-lineage BigVGAN vocoder at
+// 32 kHz / 2 channels, gated against the checkpoint's own modules by
+// scripts/gen-minimax-h3-audio-vae-goldens.py.
+// ---------------------------------------------------------------------------
+
+inline constexpr int64_t kMiniMaxH3AudioSampleRate = 32000;
+inline constexpr int64_t kMiniMaxH3AudioChannels = 2;
+
+struct MiniMaxH3AudioVaeConfig {
+  int64_t num_mels = 2048;                 // == DacAudioVAE latent_dim
+  int64_t upsample_initial_channel = 1024;  // decoder_dim
+  std::vector<int64_t> upsample_rates = {5, 5, 2, 2, 2, 2, 2};
+  std::vector<int64_t> upsample_kernel_sizes = {9, 9, 4, 4, 4, 4, 4};
+  std::vector<int64_t> resblock_kernel_sizes = {3, 7, 11};
+  std::vector<std::vector<int64_t>> resblock_dilation_sizes = {{1, 3, 5}, {1, 3, 5}, {1, 3, 5}};
+  bool use_tanh_at_final = false;  // H3 CLAMPS instead
+  bool use_bias_at_final = false;
+  bool snake_logscale = true;
+};
+
+// Parameters keyed by their torch state_dict name, so the checkpoint's own
+// naming IS the contract (`conv_pre.parametrizations.weight.original0`, ...).
+struct MiniMaxH3AudioVaeWeights {
+  std::map<std::string, std::vector<float>> tensors;
+
+  const std::vector<float>& Get(const std::string& name) const;
+  bool Has(const std::string& name) const { return tensors.count(name) != 0; }
+};
+
+// kaiser_sinc_filter1d (dac_alias_free_filter.py:26-60) — built at load time, never
+// read from the checkpoint.
+std::vector<float> MiniMaxH3KaiserSincFilter1d(double cutoff, double half_width,
+                                               int64_t kernel_size);
+
+// torch weight_norm: w = g * v / ||v||, norm over every dim except dim 0. Every
+// conv in this decoder is weight-normalized, so the checkpoint stores (g, v).
+std::vector<float> MiniMaxH3MaterializeWeightNorm(const std::vector<float>& g,
+                                                  const std::vector<float>& v,
+                                                  int64_t out_channels);
+
+struct StTensor;
+class SafetensorsFile;
+
+// Read an unquantized safetensors tensor into f32, whatever its storage dtype
+// (F32 / BF16 / F16). Shared by every MiniMax-H3 checkpoint loader.
+std::vector<float> MiniMaxH3ReadSafetensorF32(const StTensor& tensor);
+
+// Materialize the audio VAE decoder's weights from the SHIPPED checkpoint
+// (FL2VA/audio_vae/model.safetensors).
+//
+// The file does NOT use the names the decoder reads, and the two mismatches are
+// exactly the kind that fail silently, so both are gated against the REAL
+// 1087-tensor manifest:
+//
+//  1. WEIGHT-NORM SPELLING. The checkpoint stores torch's LEGACY weight_norm pair
+//     `weight_g` / `weight_v`. The decoder (and the generator that produced its
+//     goldens, running a modern torch) reads the PARAMETRIZATION spelling
+//     `parametrizations.weight.original0` / `original1`. Same tensors, different
+//     era of torch; the loader renames them.
+//  2. PREFIX. Every BigVGAN tensor is under `decoder.`, but `dec_in_proj.*` — the
+//     Conv1d that runs BEFORE BigVGAN — is at the top level.
+//
+// The anti-aliasing `.filter` tensors are SKIPPED: those kaiser-sinc filters are
+// COMPUTED at load (MiniMaxH3KaiserSincFilter1d), never read from the checkpoint.
+// The file also carries the audio ENCODER (`encoder.*`), which generation does not
+// need; it is ignored rather than loaded.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3AudioVaeWeights(const SafetensorsFile& file);
+
+// Decode one channel of audio latents to a waveform in [-1, 1]. When the weights
+// carry `dec_in_proj` (the checkpoint's Conv1d k=1 from vae_latent_channels to
+// num_mels, applied before BigVGAN — dac_audio_vae.py:218-231) the input is
+// [vae_latent_channels, frames]; otherwise it is already [num_mels, frames].
+std::vector<float> MiniMaxH3AudioVaeDecode(const MiniMaxH3AudioVaeConfig& config,
+                                           const MiniMaxH3AudioVaeWeights& weights,
+                                           const std::vector<float>& latent, int64_t frames,
+                                           int64_t* out_samples);
+
+// ---------------------------------------------------------------------------
+// Audio VAE ENCODER (minimax_h3_audio_vae.cpp)
+//
+// The ANALYSIS half of the same DAC-lineage VAE, and the piece a REFERENCE AUDIO
+// needs: ref2va conditions on rows produced from a supplied waveform, so without
+// it a `kAudio` block (or a `kVideoAudio` block with `ref_audio_t > 0`) can only
+// be refused.
+//
+// The encode path is not a method on the shipped module — `DacAudioVAE` exposes
+// only `decode` (dac_audio_vae.py:211-225). vLLM-Omni composes it by hand
+// (vae.py:317-325), and this mirrors that composition exactly:
+//
+//   preprocess  right-pad to a multiple of hop_length   (dac_audio_vae.py:201-209)
+//     -> Encoder     strided conv stack                 (dac_audio_vae.py:90-117)
+//     -> pre_block   AttnProjection, when attn_proj     (dac_attn_proj.py:69-88)
+//     -> mean_proj   Conv1d(attn_proj_dim -> latent, 1) (dac_audio_vae.py:157)
+//
+// `mean_proj` and never `logs_proj`: conditioning takes the distribution MEAN, so
+// the same reference always produces the same rows — the same rule the video side
+// follows in MiniMaxH3VideoVaeEncodeToLatent.
+// ---------------------------------------------------------------------------
+
+struct MiniMaxH3AudioVaeEncoderConfig {
+  // The SHIPPED geometry (FL2VA/audio_vae/metadata.json + config.yaml), confirmed
+  // by the real 1087-tensor manifest.
+  int64_t encoder_dim = 64;                            // d_model of the first conv
+  std::vector<int64_t> encoder_rates = {2, 4, 4, 5, 5};  // hop_length = 800
+  int64_t latent_dim = 2048;                           // d_latent, the last conv's width
+  int64_t vae_latent_channels = 32;                    // mean_proj's output width
+  bool attn_proj = true;
+  int64_t attn_proj_heads = 8;
+  double layer_norm_eps = 1e-5;  // torch nn.LayerNorm default
+
+  // np.prod(encoder_rates) (dac_audio_vae.py:148).
+  int64_t hop_length() const;
+  // dac_audio_vae.py:151-155 — vae_latent_channels when it divides latent_dim,
+  // else the next power of two.
+  int64_t attn_proj_dim() const;
+};
+
+// Encoder.forward (dac_audio_vae.py:116-117) over a MONO waveform, INCLUDING the
+// `preprocess` right-pad. Returns [latent_dim, frames]; `frames` is
+// padded_samples / hop_length.
+std::vector<float> MiniMaxH3AudioVaeEncoderForward(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& samples,
+                                                   int64_t sample_count, int64_t* out_frames);
+
+// AttnProjection.forward (dac_attn_proj.py:85-88) over [tokens, latent_dim] rows,
+// returning [tokens, attn_proj_dim]. The narrowing branch it takes is the one the
+// checkpoint ships (in_dim > out_dim): causal attention, MEAN over heads, then an
+// adaptive average pool down to out_dim.
+std::vector<float> MiniMaxH3AudioVaeAttnProjection(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& tokens,
+                                                   int64_t token_count);
+
+// The whole encode of ONE channel: preprocess -> Encoder -> pre_block -> mean_proj.
+// Returns the latent MEAN as [vae_latent_channels, frames].
+std::vector<float> MiniMaxH3AudioVaeEncodeToLatent(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& samples,
+                                                   int64_t sample_count, int64_t* out_frames);
+
+// vae.py:293-340 end to end: a multi-channel waveform (channel-major, mono is
+// REPEATED up to `kMiniMaxH3AudioChannels`) becomes NORMALIZED packed condition
+// rows [channels * frames, vae_latent_channels], channel-major — the layout
+// BuildMiniMaxH3PackedSequenceRef2va gives an audio-bearing block. `out_audio_t`
+// receives `frames`, which is the block's `ref_audio_t`.
+//
+// `latents_mean` / `latents_std` come from audio_vae/config.json; passing both
+// empty skips the normalization (useful in unit tests).
+std::vector<float> MiniMaxH3AudioVaeEncodeToRows(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                 const MiniMaxH3AudioVaeWeights& weights,
+                                                 const std::vector<float>& waveform,
+                                                 int64_t channels, int64_t samples_per_channel,
+                                                 const std::vector<float>& latents_mean,
+                                                 const std::vector<float>& latents_std,
+                                                 int64_t* out_audio_t);
+
+// The ENCODER half of FL2VA/audio_vae/model.safetensors — the half
+// LoadMiniMaxH3AudioVaeWeights deliberately skips. `encoder.` is stripped (so the
+// forward reads bare `block.N...`), while `pre_block.*` and `mean_proj.*` are kept
+// verbatim because they sit at the top level of the file. `logs_proj.*` is NOT
+// loaded: conditioning uses the mean, never a sample. The same three weight-norm
+// spellings the decoder loader accepts are accepted here.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3AudioVaeEncoderWeights(const SafetensorsFile& file);
+
+// ---------------------------------------------------------------------------
+// Video VAE decoder (minimax_h3_video_vae.cpp)
+//
+// The real 560-tensor manifest splits the video VAE cleanly: the ENCODER is the
+// 3D CNN, but the DECODER — the half generation needs — is a 36-block TRANSFORMER.
+// This is that block, the repeated unit.
+// ---------------------------------------------------------------------------
+
+struct MiniMaxH3VideoVaeBlockConfig {
+  int64_t dim = 0;       // embed_dim
+  int64_t heads = 0;
+  int64_t dim_head = 0;
+  int64_t ff_inner = 0;  // w1 emits 2 * ff_inner ([gate | up])
+  double eps = 1e-5;
+};
+
+// One decoder TransformerBlock (base_module.py:200-281), fp32:
+//   h += scale1 * Attention(RMSNorm(h));  h += scale2 * GatedSiLU_FF(RMSNorm(h))
+// `scale1`/`scale2` are learned PER-CHANNEL vectors. NOTE the qkv layout is
+// PER-HEAD INTERLEAVED ([head][q|k|v]), unlike the DiT's [q_all|k_all|v_all].
+// Parameters are looked up by their torch state_dict names under `prefix`.
+// `rope_cos`/`rope_sin` are per-TOKEN [seq, rot_dim] (shared across heads) and may
+// be null for the no-RoPE path.
+std::vector<float> MiniMaxH3VideoVaeBlockForward(const MiniMaxH3VideoVaeBlockConfig& config,
+                                                 const MiniMaxH3AudioVaeWeights& weights,
+                                                 const std::string& prefix,
+                                                 const std::vector<float>& hidden, int64_t seq,
+                                                 const float* rope_cos = nullptr,
+                                                 const float* rope_sin = nullptr,
+                                                 int64_t rot_dim = 0);
+
+// The whole ViT3D decoder (vae_vit.py:216-365). Real hyperparameters from the
+// checkpoint's `vit_decoder_kwargs`: 36 layers, 32 heads x 64, RMS norms, qk RMS
+// norm WITHOUT affine, gated SiLU, rope_theta 100.0, rope_dim_ratio 0.75.
+struct MiniMaxH3VideoVaeDecoderConfig {
+  MiniMaxH3VideoVaeBlockConfig block;
+  int64_t num_layers = 36;
+  int64_t in_channels = 24;   // video latent channels
+  int64_t out_channels = 3;   // RGB
+  int64_t patch_size = 16;
+  int64_t patch_size_t = 4;
+  int64_t num_register_tokens = 4;
+  int64_t rope_apply_dim = 48;  // int(dim_head * rope_dim_ratio)
+  double rope_theta = 100.0;
+
+  // TEMPORAL CHUNKING (klvae.py decode_temporal). The video decode is NOT one
+  // pass over the whole latent: upstream feeds the ViT `tokens_chunk_size +
+  // token_overlap` temporal tokens at a time. Since the decoder's RoPE is
+  // LENGTH-NORMALIZED over the grid it is handed, the temporal extent is part of
+  // the input -- a 12-token pass gives every token a position the model never saw.
+  // Spatial tiling is a RUNTIME choice, not a checkpoint property: the wrapper
+  // reads `vae_decoder_tiling` from caller-supplied config, and neither the VAE
+  // config.json nor the source config.json carries a tiling key. Upstream's chunk
+  // loop calls `_adaptive_decode`, so tiling composes WITH temporal chunking
+  // rather than replacing it. Default ON because it is a no-op below one tile
+  // (the tiled path falls through bit-identically) and measurably better above.
+  bool decoder_tiling = true;
+  int64_t clip_length = 17;   // config `clip_length`
+  int64_t token_drop = 3;     // config `token_drop`
+  int64_t vae_ratio_t = 4;    // prod(temporal_downsample_factors)
+
+  int64_t tokens_chunk_size() const {
+    return (clip_length + vae_ratio_t - 1) / vae_ratio_t;  // ceil
+  }
+  int64_t frame_pre_padding() const {
+    return ((-clip_length) % vae_ratio_t + vae_ratio_t) % vae_ratio_t;
+  }
+  int64_t token_overlap() const {
+    const int64_t c = tokens_chunk_size();
+    return c == 0 ? 0 : ((-token_drop) % c + c) % c;
+  }
+  int64_t frame_overlap() const {
+    return std::max<int64_t>(token_overlap() * vae_ratio_t - frame_pre_padding(), 0);
+  }
+};
+
+// The per-channel latent statistics both VAEs ship in their config.json. The
+// pipeline DENORMALIZES with these before decoding; getting them from the config
+// (rather than a caller's hardcoded table) is what makes a real run reproducible.
+struct MiniMaxH3LatentStats {
+  std::vector<float> mean, std_dev;
+};
+
+// Parse `audio_vae/config.json` (AutoencoderKLMiniMaxH3Audio) and `vae/config.json`
+// (AutoencoderKLMiniMaxH3) into the configs the decoders take, plus their latent
+// statistics. Absent keys keep the SHIPPED defaults, matching
+// ParseMiniMaxH3DitParams' contract.
+MiniMaxH3AudioVaeConfig ParseMiniMaxH3AudioVaeConfig(const nlohmann::json& config,
+                                                     MiniMaxH3LatentStats* stats = nullptr);
+MiniMaxH3VideoVaeDecoderConfig ParseMiniMaxH3VideoVaeDecoderConfig(
+    const nlohmann::json& config, MiniMaxH3LatentStats* stats = nullptr);
+
+struct MiniMaxH3VideoFrameShape {
+  int64_t channels = 0, t = 0, h = 0, w = 0;
+};
+
+// 3D RoPE tables for one latent grid (RotaryEmbeddingND + create_token_ids).
+void MiniMaxH3VideoVaeRope(int64_t latent_t, int64_t latent_h, int64_t latent_w,
+                           int64_t num_suffix, int64_t rope_apply_dim, double rope_theta,
+                           std::vector<float>* cos_out, std::vector<float>* sin_out);
+
+// --- video-VAE 3D-CNN ENCODER primitives (conv.py, norm.py, vae_cnn.py) ---
+// The decoder is a ViT; the ENCODER is this 3D CNN, needed for image/video
+// CONDITIONING (fl2va keyframes, ref2va references), not for output frames.
+
+struct MiniMaxH3Conv3dSpec {
+  int64_t in_channels = 0, out_channels = 0;
+  int64_t t = 0, h = 0, w = 0;
+  int64_t kernel_t = 3, kernel_h = 3, kernel_w = 3;
+  int64_t pad_t = 1, pad_h = 1, pad_w = 1;
+  int64_t stride_t = 1, stride_h = 1, stride_w = 1;
+  bool causal = true;  // all temporal padding on the LEFT
+};
+
+struct MiniMaxH3Downsample3dConfig {
+  int64_t in_channels = 0, out_channels = 0;
+  int64_t t = 0, h = 0, w = 0;
+  int64_t time_stride = 1;
+  int64_t space_stride = 2;
+};
+
+// Downsample3D: an ASYMMETRIC one-pixel pad on the right/bottom when the spatial
+// stride is 2, then a strided causal conv with padding (1, 0, 0).
+std::vector<float> MiniMaxH3Downsample3d(const std::vector<float>& x,
+                                         const MiniMaxH3Downsample3dConfig& config,
+                                         const std::vector<float>& weight,
+                                         const std::vector<float>& bias);
+
+// Causal Conv3d with `reflect` spatial padding; [C,T,H,W] in and out.
+std::vector<float> MiniMaxH3CausalConv3d(const std::vector<float>& in,
+                                         const MiniMaxH3Conv3dSpec& spec,
+                                         const std::vector<float>& weight,
+                                         const std::vector<float>* bias);
+
+// GroupNorm whose statistics span the group's channels AND all of time/space.
+void MiniMaxH3GroupNorm3d(std::vector<float>& x, int64_t channels, int64_t spatial,
+                          int64_t num_groups, const std::vector<float>& weight,
+                          const std::vector<float>& bias, double eps);
+
+struct MiniMaxH3ResnetBlock3dConfig {
+  int64_t in_channels = 0, out_channels = 0;
+  int64_t t = 0, h = 0, w = 0;
+  int64_t num_groups = 32;
+  double eps = 1e-6;
+};
+
+// norm -> SiLU -> conv -> norm -> SiLU -> conv (+ 1x1x1 shortcut when C changes).
+std::vector<float> MiniMaxH3ResnetBlock3dForward(const MiniMaxH3ResnetBlock3dConfig& config,
+                                                 const MiniMaxH3AudioVaeWeights& weights,
+                                                 const std::string& prefix,
+                                                 const std::vector<float>& x);
+
+struct MiniMaxH3EncoderFcn3dConfig {
+  int64_t ch = 128;
+  std::vector<int64_t> ch_mult = {1, 2, 2, 4, 4, 8};
+  std::vector<int64_t> space_down = {2, 2, 2, 2, 1, 1};
+  std::vector<int64_t> time_down = {1, 2, 2, 1, 1, 1};
+  int64_t num_res_blocks = 2;
+  int64_t in_channels = 3;
+  int64_t z_channels = 24;
+  int64_t t = 0, h = 0, w = 0;
+  int64_t num_groups = 32;
+  double eps = 1e-6;
+};
+
+// The whole 3D-CNN encoder level loop. Conditioning-only: a t2va generation path
+// never calls it.
+std::vector<float> MiniMaxH3EncoderFcn3dForward(const MiniMaxH3EncoderFcn3dConfig& config,
+                                                const MiniMaxH3AudioVaeWeights& weights,
+                                                const std::vector<float>& x,
+                                                MiniMaxH3VideoFrameShape* out_shape);
+
+// Materialize the VIDEO VAE decoder's weights from the shipped checkpoint
+// (FL2VA/video_vae/model.safetensors, the gated 560-tensor manifest).
+//
+// Simpler than the audio VAE: no weight-norm spelling change. The only mapping is
+// the `decoder.` prefix, which the ViT3D decoder's own names do not carry. The
+// `encoder.*` half (the 3D CNN, conditioning-only) is ignored, and `quant_conv.*`
+// belongs to the ENCODER side.
+//
+// `post_quant_conv.*` IS kept, under its own name, because it is a real step this
+// port had not needed before: see MiniMaxH3VideoVaePostQuantConv.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3VideoVaeDecoderWeights(const SafetensorsFile& file);
+
+// The ENCODER half of the same file, for CONDITIONING (fl2va keyframes, ref2va
+// references). Strips `encoder.` and KEEPS `quant_conv.*`, which is the encoder's
+// output stage rather than the decoder's.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3VideoVaeEncoderWeights(const SafetensorsFile& file);
+
+// Encode frames [in_channels, T, H, W] in [-1, 1] to the conditioning latent
+// [z_channels, T', H', W']. Takes the distribution MEAN, not a sample: a sample
+// would make one reference image condition differently on every run.
+std::vector<float> MiniMaxH3VideoVaeEncodeToLatent(const MiniMaxH3EncoderFcn3dConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& frames,
+                                                   MiniMaxH3VideoFrameShape* out_shape);
+
+// The AutoencoderKL wrapper's `post_quant_conv` — a Conv3d(latent_ch -> latent_ch,
+// kernel 1x1x1), i.e. a per-position channel MIX plus bias, applied to the latent
+// BEFORE the decoder proper.
+//
+// It sits OUTSIDE ViT3DDecoder, which is why the decoder gate (8.9e-8 vs the
+// checkpoint's own ViT3DDecoder, whose first op is x_embedder) never covered it and
+// nothing in this port applied it. Loading the tensor without applying it would
+// have been the worst outcome: a decode that runs, looks reasonable, and is wrong.
+//
+// `latent` is [channels, t, h, w] contiguous; the result has the same shape.
+std::vector<float> MiniMaxH3VideoVaePostQuantConv(const MiniMaxH3AudioVaeWeights& weights,
+                                                  const std::vector<float>& latent,
+                                                  int64_t channels, int64_t elems_per_channel);
+
+// --- spatial tiling (klvae.py:192-250) ---
+// Shipped config: tile_size 256, tile_overlap_min 64, vae_ratio 16.
+inline constexpr int64_t kMiniMaxH3VaeTileSize = 256;
+inline constexpr int64_t kMiniMaxH3VaeTileOverlapMin = 64;
+inline constexpr int64_t kMiniMaxH3VaeRatio = 16;   // prod(space_down)
+inline constexpr int64_t kMiniMaxH3VaeRatioT = 4;   // prod(time_down)
+
+struct MiniMaxH3TilePlan {
+  std::vector<int64_t> starts;
+  std::vector<int64_t> lengths;
+  std::vector<int64_t> overlaps;  // one per seam; empty for a single tile
+};
+
+// The tile plan along one axis: smallest tile count whose minimum overlaps still
+// cover the input, with the leftover slack distributed in whole `vae_ratio` units
+// ROUND-ROBIN across the seams.
+MiniMaxH3TilePlan MiniMaxH3SplitTiles(int64_t input_len, int64_t tile_size,
+                                      int64_t tile_overlap_min, int64_t vae_ratio);
+
+// Linear cross-fade of the last `blend_extent` elements of `a` into the first
+// `blend_extent` of `b`, followed by the remainder of `b`.
+std::vector<float> MiniMaxH3BlendTiles(const std::vector<float>& a, const std::vector<float>& b,
+                                       int64_t blend_extent);
+
+// The video VAE works in IMAGENET-NORMALIZED pixel space, NOT in [-1, 1].
+//
+// Upstream's wrapper de-normalizes on the way out (`dec*std + mean`, clamp to
+// [0,1], then map to [-1,1] -- comfy/ldm/minimax/vae.py:693) and normalizes on the
+// way in (`(x+1)/2 - mean) / std` -- vae.py:659). Both sit OUTSIDE ViT3DDecoder,
+// which is why the decoder's own 1.19e-07 gate never covered them, exactly like
+// post_quant_conv before them.
+//
+// Skipping the output step feeds ImageNet-normalized values to a writer expecting
+// [-1, 1]: the per-channel means differ (0.485/0.456/0.406) so it casts colour, and
+// the std of ~0.22 means the true dynamic range is compressed ~4.4x, which reads as
+// dark and low-contrast.
+inline constexpr float kMiniMaxH3ImagenetMean[3] = {0.485F, 0.456F, 0.406F};
+inline constexpr float kMiniMaxH3ImagenetStd[3] = {0.229F, 0.224F, 0.225F};
+
+// Decoder output (ImageNet-normalized, [C,T,H,W]) -> [-1, 1] pixels, in place.
+void MiniMaxH3VideoDenormalizePixels(std::vector<float>& frames, int64_t channels,
+                                     int64_t per_channel);
+
+// Pixels in [-1, 1] ([C,T,H,W]) -> the ImageNet-normalized space the VAE ENCODER
+// expects, in place. The inverse of the above, for reference/keyframe conditioning.
+void MiniMaxH3VideoNormalizePixels(std::vector<float>& frames, int64_t channels,
+                                   int64_t per_channel);
+
+// Decode a video latent [in_channels, T, H, W] to frames [out_channels, T*pt, H*ps, W*ps].
+std::vector<float> MiniMaxH3VideoVaeDecode(const MiniMaxH3VideoVaeDecoderConfig& config,
+                                           const MiniMaxH3AudioVaeWeights& weights,
+                                           const std::vector<float>& latent, int64_t latent_t,
+                                           int64_t latent_h, int64_t latent_w,
+                                           MiniMaxH3VideoFrameShape* out_shape);
+
+// --- the DEVICE-RESIDENT video VAE decoder (minimax_h3_video_vae_device.cpp) ---
+//
+// Same graph as MiniMaxH3VideoVaeDecode, routed to the tuned shared ops with every
+// activation on the device. The portable one is a scalar reference; on a 36-layer
+// ViT3D it is what made a 256x256 decode time out.
+//
+// Staging performs two EXACT weight rearrangements (a per-head-interleaved to_qkv
+// row permutation, and a fold of each branch's learned per-channel scale into the
+// preceding projection) so the whole decoder needs NO new kernels. Held to the
+// decoder's tolerance gate rather than bit-equality with the reference: the shared
+// ops accumulate in f32 where the reference accumulates in double, and the scale
+// fold reassociates that branch's rounding.
+struct MiniMaxH3VideoVaeDeviceBlock {
+  vt::Tensor norm1, norm2;
+  vt::Tensor qkv_weight, qkv_bias;  // rows reordered to [q_all | k_all | v_all]
+  vt::Tensor out_weight, out_bias;  // scale1 folded in
+  vt::Tensor w1_weight, w1_bias;
+  vt::Tensor w2_weight, w2_bias;  // scale2 folded in
+};
+
+struct MiniMaxH3VideoVaeDeviceWeights {
+  std::vector<std::shared_ptr<void>> storage;  // owns the device allocations
+  std::vector<MiniMaxH3VideoVaeDeviceBlock> blocks;  // views into `storage`
+  vt::Tensor x_embedder_weight, x_embedder_bias;
+  vt::Tensor register_tokens;
+  vt::Tensor norm_out_weight, norm_out_bias;
+  bool has_norm_out_bias = false;
+  vt::Tensor proj_out_weight, proj_out_bias;
+  vt::Tensor qk_norm_ones;  // the qk RMSNorm is elementwise_affine=False
+};
+
+// Stage the decoder onto `queue`'s device. Every weight must be host-resident f32.
+MiniMaxH3VideoVaeDeviceWeights StageMiniMaxH3VideoVaeWeights(
+    vt::Queue& queue, const MiniMaxH3VideoVaeDecoderConfig& config,
+    const MiniMaxH3AudioVaeWeights& weights);
+
+std::vector<float> MiniMaxH3VideoVaeDecodeDevice(vt::Device device,
+                                                 const MiniMaxH3VideoVaeDecoderConfig& config,
+                                                 const MiniMaxH3VideoVaeDeviceWeights& staged,
+                                                 const std::vector<float>& latent, int64_t latent_t,
+                                                 int64_t latent_h, int64_t latent_w,
+                                                 MiniMaxH3VideoFrameShape* out_shape);
+
+// The same decode UNDER UPSTREAM'S TILE PLAN, which is what a real canvas needs.
+//
+// Tiling is not an optional memory strategy here: the ViT3D's RoPE coordinates are
+// LENGTH-NORMALIZED over the grid it is handed, so the grid extent is part of the
+// input. Upstream always decodes 256-pixel tiles (16 latent units). Decoding a
+// larger canvas in one pass gives every token a position the model never saw, and
+// shows up as a grid of small squares over otherwise correct frames.
+//
+// Falls through to the untiled decode, bit for bit, when the plan is a single tile
+// (canvas <= tile_size), which is why the reduced-dimension gates never saw this.
+// The video decode as upstream actually performs it: TEMPORAL CHUNKS.
+//
+// `decode_base` routes video through `decode_temporal`, never a single pass. The
+// ViT sees `tokens_chunk_size + token_overlap` temporal tokens at a time (7 for
+// the shipped config), and since its RoPE is LENGTH-NORMALIZED over the grid it is
+// handed, that extent is part of the input -- a whole-latent pass gives every
+// token a temporal position the model never saw.
+//
+// `target_frames` is the request's frame count; upstream center-crops to it
+// (trim_output). Pass 0 to keep every decoded frame.
+std::vector<float> MiniMaxH3VideoVaeDecodeTemporalDevice(
+    vt::Device device, const MiniMaxH3VideoVaeDecoderConfig& config,
+    const MiniMaxH3VideoVaeDeviceWeights& staged, const std::vector<float>& latent,
+    int64_t latent_t, int64_t latent_h, int64_t latent_w, int64_t target_frames,
+    MiniMaxH3VideoFrameShape* out_shape);
+
+std::vector<float> MiniMaxH3VideoVaeDecodeTiledDevice(
+    vt::Device device, const MiniMaxH3VideoVaeDecoderConfig& config,
+    const MiniMaxH3VideoVaeDeviceWeights& staged, const std::vector<float>& latent,
+    int64_t latent_t, int64_t latent_h, int64_t latent_w, MiniMaxH3VideoFrameShape* out_shape);
+
+// ---------------------------------------------------------------------------
+// H3-Encoder text tower (minimax_h3_encoder.cpp)
+//
+// A Qwen3-VL text model with three H3-specific deltas: only the first
+// `selected_layer` (50) decoder layers run, the output is UNNORMALIZED (no final
+// RMSNorm), and DeepStack visual features are added at the visual token positions
+// after each of the first `deepstack.size()` layers.
+// ---------------------------------------------------------------------------
+
+inline constexpr int64_t kMiniMaxH3EncoderSelectedLayer = 50;
+inline constexpr int64_t kMiniMaxH3EncoderHiddenDim = 5120;
+
+struct MiniMaxH3EncoderConfig {
+  int64_t hidden_size = kMiniMaxH3EncoderHiddenDim;
+  int64_t num_hidden_layers = 64;
+  int64_t selected_layer = kMiniMaxH3EncoderSelectedLayer;
+  int64_t num_attention_heads = 40;
+  int64_t num_key_value_heads = 8;
+  int64_t head_dim = 128;
+  int64_t intermediate_size = 17408;
+  double rms_norm_eps = 1e-6;
+  double rope_theta = 5000000.0;
+  std::vector<int64_t> mrope_section = {24, 20, 20};
+};
+
+// num_layers = min(config.num_hidden_layers, selected_layer).
+int64_t MiniMaxH3EncoderNumLayers(int64_t config_num_hidden_layers, int64_t selected_layer);
+
+// Interleaved M-RoPE cos/sin ([seq, head_dim]) from [3, seq] (t, h, w) positions.
+void MiniMaxH3EncoderMrope(const int64_t* positions, int64_t seq, int64_t head_dim,
+                           double rope_theta, const std::vector<int64_t>& mrope_section,
+                           std::vector<float>* cos_out, std::vector<float>* sin_out);
+
+// The truncated, UNNORMALIZED text tower. `deepstack[i]` is [num_visual, hidden]
+// and may be empty; `visual_pos_mask` is [seq] and is required when it is not.
+std::vector<float> MiniMaxH3EncoderTextForward(const MiniMaxH3EncoderConfig& config,
+                                               const MiniMaxH3AudioVaeWeights& weights,
+                                               const std::vector<float>& inputs_embeds,
+                                               const int64_t* positions, int64_t seq,
+                                               const uint8_t* visual_pos_mask,
+                                               const std::vector<std::vector<float>>& deepstack);
+
+// The H3-Encoder in KEEP-QUANT form, materialized from a ComfyUI-format GGUF
+// (qwen3vl-32B-MiniMax-H3-Q4_K_M.gguf, 902 tensors, all Q4_K).
+//
+// This exists because the encoder is 32B: the safetensors loader materializes f32,
+// which is ~128 GB and does not fit the box we test on. Keeping the projections in
+// their ggml blocks holds the tower at ~14.6 GB, and — as with the DiT — the ggml
+// block-quant GEMM carries NO arch gate, so it runs natively where FP4 cannot.
+//
+// The two fusions the forward needs (q/k/v -> qkv_proj, gate/up -> gate_up_proj)
+// are done on the QUANTIZED BYTES. That is sound precisely because ggml rows are
+// independent: a row is a whole number of blocks (every K here is a multiple of
+// 256), so concatenating whole rows of q, k and v yields a valid block-quant tensor
+// whose rows are [q_all | k_all | v_all]. No dequantize/requantize round trip.
+struct MiniMaxH3EncoderQuantWeights {
+  MiniMaxH3EncoderConfig config;
+  std::map<std::string, std::vector<uint8_t>> quant_storage;  // ggml block bytes
+  std::map<std::string, std::vector<float>> storage;          // f32 norms/biases
+  std::map<std::string, vt::Tensor> views;                    // what the forward binds
+  // The ggml type id each kept tensor was stored as. Needed because dequantizing a
+  // SINGLE embedding row goes through the ggml entry point, which is keyed by that
+  // id rather than by vt::DType.
+  std::map<std::string, uint32_t> ggml_type;
+
+  const vt::Tensor& Get(const std::string& name) const;
+  bool Has(const std::string& name) const { return views.count(name) != 0; }
+};
+
+// `max_layers` truncates the text tower to H3's own min(num_hidden_layers, 50);
+// 0 keeps every layer. The GGUF prefixes differ from the safetensors ones
+// (`model.layers.N.` here vs `model.language_model.layers.N.` there, and `visual.`
+// vs `model.visual.`), which is itself gated.
+// Gather embedding rows for `ids` from the (block-quant) `embed_tokens` table.
+//
+// The table is the single largest tensor in the encoder — [151936, 5120], ~1.5 GB
+// even quantized — and a prompt touches a few dozen rows. So this dequantizes ONLY
+// the requested rows rather than the table: ggml rows are independent block
+// sequences, so a row can be decoded from its own bytes alone.
+//
+// Returns [ids.size(), hidden_size] f32, which is what the encoder forward takes as
+// `inputs_embeds`.
+std::vector<float> MiniMaxH3EncoderEmbedTokens(const MiniMaxH3EncoderQuantWeights& weights,
+                                               const std::vector<int32_t>& ids);
+
+// The keep-quant encoder staged onto a device: the block bytes uploaded verbatim,
+// the f32 norms uploaded as-is. Staged ONCE — a prompt is encoded per request but
+// the tower does not change.
+struct MiniMaxH3EncoderDeviceWeights {
+  std::vector<std::shared_ptr<void>> storage;
+  std::map<std::string, vt::Tensor> views;
+
+  const vt::Tensor& Get(const std::string& name) const;
+  bool Has(const std::string& name) const { return views.count(name) != 0; }
+};
+
+MiniMaxH3EncoderDeviceWeights StageMiniMaxH3EncoderWeights(
+    vt::Queue& queue, const MiniMaxH3EncoderQuantWeights& host);
+
+// The DEVICE-resident encoder text tower — H3's conditioning path.
+//
+// Same graph as MiniMaxH3EncoderTextForward, with the three H3 deltas intact:
+// layer truncation to min(num_hidden_layers, selected_layer), the UNNORMALIZED
+// output (no final RMSNorm), and DeepStack injection left to the caller.
+//
+// Reuses the shared ops throughout — the projections go through vt::MatmulBT,
+// which dispatches kMatmulBTQuant on the block weights, so a 32B tower runs from
+// its ggml blocks with no dequantization. `positions` is [3, seq] (the M-RoPE
+// temporal/height/width axes); for a pure text prompt all three are the token
+// index. Returns [seq, hidden] f32.
+std::vector<float> MiniMaxH3EncoderTextForwardDevice(
+    vt::Queue& queue, const MiniMaxH3EncoderConfig& config,
+    const MiniMaxH3EncoderDeviceWeights& weights, const std::vector<float>& inputs_embeds,
+    const int64_t* positions, int64_t seq);
+
+MiniMaxH3EncoderQuantWeights LoadMiniMaxH3EncoderFromGguf(const GgufFile& file,
+                                                          int64_t max_layers = 0);
+
+// Materialize the H3-Encoder (FL2VA/text_encoder, 14 shards / 1058 tensors) into
+// the name map both encoder forwards read.
+//
+// Unlike the VAE loaders this one TRANSFORMS tensors, it does not merely rename
+// them. Two fusions, because the port consumes what vLLM consumes rather than what
+// HF ships:
+//   * self_attn.{q,k,v}_proj  ->  self_attn.qkv_proj   (row concat, [q|k|v] order)
+//   * mlp.{gate,up}_proj      ->  mlp.gate_up_proj     (row concat, [gate|up])
+// The VISION tower needs no fusion: HF already ships `attn.qkv` fused, and
+// `mlp.linear_fc{1,2}` already match.
+//
+// Prefixes: `model.language_model.` -> `layers.N....`, `model.visual.` -> stripped.
+//
+// `max_layers` truncates the text tower, which is H3's own behaviour
+// (min(num_hidden_layers, 50) — the file ships 64). 0 keeps every layer.
+//
+// DELIBERATELY NOT LOADED: `model.language_model.norm.weight`. H3 reads the
+// UNNORMALIZED layer-49 output — no final RMSNorm — and loading that tensor would
+// imply it is applied. `lm_head.weight` is a logits head the encoder never uses.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3EncoderWeights(const std::vector<SafetensorsFile>& shards,
+                                                     int64_t max_layers = 0);
+
+// One vision-tower block (encoder.py:417-481) — the repeated unit of the ViT.
+// Unlike the text tower it uses LayerNorm (with bias), a [q_all|k_all|v_all] qkv
+// layout, fp32 rotary, NON-CAUSAL attention segmented by `cu_seqlens`, and the
+// TANH-approximate GELU.
+struct MiniMaxH3VisionBlockConfig {
+  int64_t hidden_size = 1152;
+  int64_t num_heads = 16;
+  int64_t intermediate_size = 4304;
+  double eps = 1e-6;
+};
+
+std::vector<float> MiniMaxH3VisionBlockForward(const MiniMaxH3VisionBlockConfig& config,
+                                               const MiniMaxH3AudioVaeWeights& weights,
+                                               const std::string& prefix,
+                                               const std::vector<float>& hidden, int64_t seq,
+                                               const float* cos, const float* sin,
+                                               const int32_t* cu_seqlens, int64_t num_segments);
+
+// The whole vision tower (encoder.py:483-600).
+struct MiniMaxH3VisionTowerConfig {
+  MiniMaxH3VisionBlockConfig block;
+  int64_t depth = 27;
+  int64_t patch_size = 16;
+  int64_t temporal_patch_size = 2;
+  int64_t in_channels = 3;
+  int64_t spatial_merge_size = 2;
+  int64_t out_hidden_size = 5120;
+  int64_t num_position_embeddings = 2304;  // must be a perfect square
+  double rope_theta = 10000.0;
+  std::vector<int64_t> deepstack_visual_indexes;
+};
+
+struct MiniMaxH3VisionTowerResult {
+  std::vector<float> merged;                    // [tokens/merge^2, out_hidden_size]
+  std::vector<std::vector<float>> deepstack;    // one per deepstack index
+};
+
+// Bilinear resample of the learned position grid, then spatial-merge permute.
+std::vector<float> MiniMaxH3VisionPosEmbedInterpolate(const std::vector<float>& pos_embed_table,
+                                                      int64_t num_grid_per_side, int64_t dim,
+                                                      const std::vector<int64_t>& grid_thw,
+                                                      int64_t merge_size);
+
+// 2D rotary frequencies in spatial-merge order.
+std::vector<float> MiniMaxH3VisionRotary(const std::vector<int64_t>& grid_thw, int64_t merge_size,
+                                         int64_t rotary_dim, double theta);
+
+// `patches` is [tokens, in_channels * temporal_patch * patch * patch]; `grid_thw`
+// is a flat list of (t, h, w) triples, one per image/video.
+MiniMaxH3VisionTowerResult MiniMaxH3VisionTowerForward(const MiniMaxH3VisionTowerConfig& config,
+                                                       const MiniMaxH3AudioVaeWeights& weights,
+                                                       const std::vector<float>& patches,
+                                                       const std::vector<int64_t>& grid_thw);
+
+// The checkpoint stores qkv GROUPED per query group as [q_per_group, k, v]; the
+// fused qkv projection wants [q_all, k_all, v_all] (minimax_h3_transformer.py:
+// 139-168). H3 is MHA, so heads_per_group == 1.
+std::vector<float> MiniMaxH3ReorderGroupedQkv(const std::vector<float>& weight,
+                                              int64_t num_query_groups, int64_t heads_per_group,
+                                              int64_t head_dim, int64_t in_features);
+
+// Non-owning views of every DiT parameter, in the shape the forward consumes.
+struct MiniMaxH3DitBlockWeights {
+  vt::Tensor norm1;      // [H]
+  vt::Tensor norm2;      // [H]
+  vt::Tensor qkv_proj;   // [3*heads*Dh, H]
+  vt::Tensor q_norm;     // [Dh]
+  vt::Tensor k_norm;     // [Dh]
+  vt::Tensor out_proj;   // [H, heads*Dh]
+  vt::Tensor fc1;        // [2*ffn, H] as [gate; up]
+  vt::Tensor fc2;        // [H, ffn]
+  vt::Tensor adaln_w;    // [expand*modality*H, time_embed_dim] (blocks only)
+  vt::Tensor adaln_b;    // [expand*modality*H]
+};
+
+struct MiniMaxH3DitWeights {
+  vt::Tensor video_patch_proj_w, video_patch_proj_b;
+  vt::Tensor audio_patch_proj_w, audio_patch_proj_b;
+  vt::Tensor condition_proj_w, condition_proj_b;
+  vt::Tensor time_proj_in_w, time_proj_in_b;
+  vt::Tensor time_proj_out_w, time_proj_out_b;
+  vt::Tensor rope_inv_freq;  // [rope_inv_freq_len], fp32
+  std::vector<MiniMaxH3DitBlockWeights> refiner;  // no adaln, no rope
+  vt::Tensor refiner_final_norm;
+  std::vector<MiniMaxH3DitBlockWeights> blocks;
+  vt::Tensor final_norm;
+  vt::Tensor final_adaln_w, final_adaln_b;
+  vt::Tensor video_out_w, video_out_b;
+  vt::Tensor audio_out_w, audio_out_b;
+};
+
+// A GGUF-loaded DiT: owned dequantized buffers plus the views the forward takes.
+// `storage` must outlive `weights` (the views are non-owning).
+struct MiniMaxH3GgufDit {
+  MiniMaxH3DitParams params;
+  std::map<std::string, std::vector<float>> storage;  // dequantized tensors (f32)
+  // KEEP-QUANT residency: the tensor's ggml bytes VERBATIM, plus the vt block
+  // dtype they encode. A name appears in exactly one of `storage` /
+  // `quant_storage`; the view binder checks both, so a keep-quant load and a
+  // dequantizing load produce the same weight-view struct.
+  std::map<std::string, std::vector<uint8_t>> quant_storage;
+  std::map<std::string, vt::DType> quant_dtype;
+  std::map<std::string, uint32_t> quant_ggml_type;  // for a later dequant
+  // bf16 bit patterns, when the DiT is loaded for a bf16 GEMM (see the loader's
+  // `bf16` flag). Mutually exclusive with `storage` per tensor.
+  std::map<std::string, std::vector<uint16_t>> bf16_storage;
+  std::map<std::string, std::vector<int64_t>> shapes;
+  MiniMaxH3DitWeights weights;
+};
+
+// Materialize the DiT from a ComfyUI-format GGUF: derive the geometry from the
+// manifest, dequantize every tensor to f32 through the shared GGUF dequant path
+// (so the Q2_K/Q3_K/Q4_K families the H3 GGUFs use are covered), and bind the
+// forward's views. Missing tensors throw by name rather than reading as zeros.
+// `keep_quant` leaves every ELIGIBLE 2-D projection in its ggml block encoding
+// instead of dequantizing it to f32. Eligibility is the shared rule
+// (KeepQuantDType + K a whole number of blocks); norms, biases and anything
+// unported still dequantize, so the forward sees a uniform weight struct either
+// way. vt::MatmulBT dispatches a block-typed weight to kMatmulBTQuant on its own
+// (ops.cpp:146), so NO call site in the forward changes -- which is exactly why
+// this is a loader+staging change rather than a forward rewrite.
+//
+// This is the arm that makes a quantized H3 run cheap on hardware WITHOUT fp4
+// tensor cores: the block-quant GEMM carries no arch gate (cuda_quant_dot.cu has
+// no #if at all), unlike every cutlass/marlin/fp4 path.
+MiniMaxH3GgufDit LoadMiniMaxH3DitFromGguf(const GgufFile& file, bool keep_quant = false);
+
+// Load the DiT dequantized straight to BF16 — never materializing f32.
+//
+// This is the THROUGHPUT configuration, and it is what ComfyUI-GGUF effectively does
+// (it dequantizes to bf16 and calls F.linear rather than computing in-quant). Our
+// in-quant GEMM measured ~103 GFLOP/s because it re-streams the whole weight set per
+// SEQUENCE ROW; a bf16 weight goes through the tuned cuBLASLt MatmulBT instead.
+//
+// It is also the only way this fits: keeping blocks leaves the AdaLN projections
+// ineligible (K=2688 is not a whole number of 256-element Q3_K blocks) and they
+// dequantize to ~52 GB of f32. Straight to bf16 the whole DiT is ~33 GB.
+MiniMaxH3GgufDit LoadMiniMaxH3DitFromGgufBf16(const GgufFile& file);
+// Bind the forward's views onto a MiniMaxH3GgufDit's owned buffers. Shared by the
+// GGUF and NVFP4 arms: both land on the SAME weight contract.
+void BindMiniMaxH3DitViews(MiniMaxH3GgufDit* out);
+
+class SafetensorsFile;
+// Materialize the DiT from an NVFP4 safetensors checkpoint. Quantized projections
+// carry the compressed-tensors triple (U8 packed FP4 + E4M3 group-16
+// `weight_scale` + F32 scalar `weight_scale_2`) and are dequantized through the
+// project's existing NVFP4 path; the fp32/bf16 islands are read as-is.
+MiniMaxH3GgufDit LoadMiniMaxH3DitFromNvfp4(const SafetensorsFile& file);
+
+// The per-step inputs of one denoise step (minimax_h3_transformer.py:986-1102).
+// Row-major host buffers; the forward stages them onto `device` itself.
+struct MiniMaxH3DitInputs {
+  int64_t seq_len = 0;
+  const float* x = nullptr;            // [seq_len, video_row_width]
+  const float* audio_x = nullptr;      // [seq_len, audio_latents_dim]
+  const double* img_position_ids = nullptr;  // [seq_len, 3]
+  const float* unique_timesteps = nullptr;   // [M]
+  int64_t num_unique_timesteps = 0;
+  const int64_t* inverse_indices = nullptr;  // [seq_len] -> [0, M)
+  const int64_t* token_tags = nullptr;       // [seq_len]
+  const float* prompt_embeds = nullptr;      // [text_len, text_dim]
+  const int64_t* img_pos = nullptr;
+  int64_t num_img_pos = 0;
+  const int64_t* audio_pos = nullptr;
+  int64_t num_audio_pos = 0;
+  const int64_t* text_pos = nullptr;
+  int64_t num_text_pos = 0;
+  const int64_t* infer_out_pos = nullptr;  // rows the video head reports
+  int64_t num_infer_out_pos = 0;
+  const uint8_t* update_mask = nullptr;        // [num_infer_out_pos]
+  const uint8_t* audio_update_mask = nullptr;  // optional, [num_audio_pos]
+  const int32_t* cu_seqlens = nullptr;         // {0, used, seq_len}
+  int64_t num_cu_seqlens = 0;
+  const int32_t* refiner_cu_seqlens = nullptr;
+  int64_t num_refiner_cu_seqlens = 0;
+  bool skip_mask_out_condition = false;
+};
+
+struct MiniMaxH3DitOutputs {
+  std::vector<float> video_logits;  // [num_infer_out_pos, video_row_width]
+  std::vector<float> audio_logits;  // [num_audio_pos, audio_latents_dim]
+};
+
+// One DiT forward = one denoise step's velocity prediction. `compute_dtype` picks
+// the block-stream dtype: kBF16 is the production path (upstream's cast points are
+// preserved), kF32 is the parity path the golden suite gates.
+MiniMaxH3DitOutputs MiniMaxH3DitForward(vt::Device device, const MiniMaxH3DitParams& params,
+                                        const MiniMaxH3DitWeights& weights,
+                                        const MiniMaxH3DitInputs& inputs,
+                                        vt::DType compute_dtype);
+
+// --- device-resident forward (brick H3-2b, minimax_h3_device.cpp) -----------
+// Owned device copies of every DiT weight, plus the views the device forward
+// takes. Upload once, reuse across denoise steps -- the whole point of the
+// device path is that the 50-step loop never re-stages weights.
+struct MiniMaxH3DitDeviceWeights {
+  std::vector<std::shared_ptr<void>> storage;  // owns the device allocations
+  // rope.inv_freq is consumed on the HOST (it builds the cos/sin cache before any
+  // kernel runs), so it must stay host-resident f32 no matter how the rest is
+  // staged. Binding it to device memory segfaults the moment the forward reads it.
+  std::vector<float> rope_inv_freq_host;
+  MiniMaxH3DitWeights weights;                 // views into `storage`
+};
+
+// Stage a host-resident weight set onto `queue`'s device. Every tensor must be
+// f32 and host-resident; the returned views live on the device.
+// `compute_dtype` picks the WEIGHT storage policy, mirroring upstream's own split
+// (MINIMAX_H3_FP32_PARAM_NAMES / _BUFFER_NAMES, minimax_h3_transformer.py:85-101):
+//   kF32  -> every weight staged as f32.
+//   kBF16 -> the bf16-STORED modules staged as bf16 (condition_proj, every refiner
+//            and block norm/attn/mlp/adaln, refiner_final_norm, final_norm,
+//            final_adaln), while the fp32 ISLANDS stay f32 (both patch projections,
+//            both time-embedder projections, both output heads, rope.inv_freq).
+// This is exactly what the bf16 GOLDEN was generated with (the generator's
+// to_bf16_weights), so the bf16 device path now matches upstream's weight dtypes
+// as well as its activation cast points.
+// Stream the DiT from a GGUF STRAIGHT ONTO THE DEVICE as bf16, one tensor at a time.
+//
+// This exists because peak memory, not total, is what kills a run on a UNIFIED-memory
+// box: loading to host bf16 (~33 GB) and then staging to device (~33 GB more) holds
+// BOTH at once, and 66 GB of a 122 GiB pool alongside the VAEs and page cache wedged
+// the machine hard enough to stop answering ping. Dequantizing and uploading tensor
+// by tensor — freeing each host buffer before the next — keeps the peak at the device
+// copy plus ONE tensor.
+//
+// `params` is recovered from the manifest exactly as the loaders do.
+MiniMaxH3DitDeviceWeights StreamMiniMaxH3DitToDeviceBf16(vt::Queue& queue, const GgufFile& file,
+                                                         MiniMaxH3DitParams* out_params);
+
+// The NVFP4 twin of the above. The non-streaming LoadMiniMaxH3DitFromNvfp4
+// materializes every weight as host f32 (~132 GB for this checkpoint) and is an
+// OOM kill on a 122 GiB unified box; it stays as the reference loader, and this
+// is what a real run uses.
+MiniMaxH3DitDeviceWeights StreamMiniMaxH3Nvfp4ToDeviceBf16(vt::Queue& queue,
+                                                           const SafetensorsFile& file,
+                                                           MiniMaxH3DitParams* out_params = nullptr);
+
+MiniMaxH3DitDeviceWeights StageMiniMaxH3DitWeights(vt::Queue& queue,
+                                                   const MiniMaxH3DitParams& params,
+                                                   const MiniMaxH3DitWeights& host,
+                                                   vt::DType compute_dtype = vt::DType::kF32);
+
+// The same staging, but DEQUANTIZING block-quant weights to bf16 on the way up
+// instead of keeping their blocks.
+//
+// This is a THROUGHPUT trade, and the measurement behind it is stark: the keep-quant
+// GEMM achieves ~103 GFLOP/s on the DiT, which makes a full-quality render a
+// ~12-day job. Dequantized to bf16 the projections go through the tuned cuBLASLt
+// MatmulBT instead. It costs memory — the DiT is ~33 GB in bf16 against 15.6 GB
+// kept-quant — which is affordable where 145 GB of f32 was not.
+//
+// `gguf` supplies the ggml type ids the block bytes were stored as; a weight with no
+// entry is uploaded unchanged.
+MiniMaxH3DitDeviceWeights StageMiniMaxH3DitWeightsDequantBf16(
+    vt::Queue& queue, const MiniMaxH3DitParams& params, const MiniMaxH3GgufDit& gguf);
+
+// The DEVICE-RESIDENT DiT forward: same graph as MiniMaxH3DitForward, but every
+// activation stays in device memory for the whole block stack -- only the inputs
+// go up and the selected output rows come back.
+//
+// NOT bit-identical to the CPU reference, and deliberately so: it reuses the
+// tuned SHARED vt:: ops (notably vt::RmsNorm, whose reduction is f32 where the
+// reference accumulates in double -- f32 is what upstream torch does). It is
+// gated against the SAME upstream goldens, at the same tolerance.
+//
+// `weights` must be device-resident on `queue`'s device (see
+// StageMiniMaxH3DitWeights). compute_dtype must be kF32 for now; the bf16 stream
+// policy is a follow-up (see .agents/specs/minimax-h3.md).
+MiniMaxH3DitOutputs MiniMaxH3DitForwardDevice(vt::Queue& queue,
+                                              const MiniMaxH3DitParams& params,
+                                              const MiniMaxH3DitWeights& weights,
+                                              const MiniMaxH3DitInputs& inputs,
+                                              vt::DType compute_dtype);
+
+
+// ---------------------------------------------------------------------------
+// Denoise loop (denoise_loop.py:129-239)
+// ---------------------------------------------------------------------------
+
+// Static per-branch state: the packed layout plus the fixed forward inputs.
+struct MiniMaxH3DenoiseBranch {
+  MiniMaxH3PackedSequence packed;
+  std::vector<float> text_embeddings;  // [text_len, text_dim]
+  std::vector<int64_t> token_tags;     // seq_len, with fl2va vision overrides applied
+};
+
+// Runs the CFG-distilled loop: one positive forward per step, video and audio
+// target rows chained through the Euler-eta0 update while pinned condition rows
+// are reset to their anchors every step. Returns the final (video, audio) rows.
+struct MiniMaxH3DenoiseResult {
+  std::vector<float> video_rows;  // [num_img_pos, video_row_width]
+  std::vector<float> audio_rows;  // [num_audio_pos, audio_latents_dim]
+};
+
+MiniMaxH3DenoiseResult MiniMaxH3DenoiseLoop(
+    vt::Device device, const MiniMaxH3DitParams& params, const MiniMaxH3DitWeights& weights,
+    const MiniMaxH3DenoiseBranch& branch, const std::vector<float>& initial_video_rows,
+    const std::vector<float>& initial_audio_rows, const std::vector<float>& keyframe_cond_rows,
+    const std::vector<float>& audio_ref_rows, const std::vector<double>& sigmas_video,
+    const std::vector<double>& sigmas_audio, vt::DType compute_dtype,
+    const MiniMaxH3DitDeviceWeights* prestaged = nullptr);
+
+
+// ---------------------------------------------------------------------------
+// t2va pipeline assembly (minimax_h3_pipeline.cpp)
+//
+// The wiring from prompt embeddings to frames + waveform. Every stage it calls is
+// separately ported and gated; this composes them.
+// ---------------------------------------------------------------------------
+
+struct MiniMaxH3T2vaRequest {
+  int64_t text_len = 0;
+  int64_t latent_t = 0, latent_h = 0, latent_w = 0;
+  int64_t audio_t = 0;
+  int64_t audio_channel = kMiniMaxH3AudioChannels;
+  // The frame count the request asked for. The temporal decode produces whole
+  // chunks and upstream center-crops to this (trim_output); 0 keeps every frame.
+  int64_t num_frames = 0;
+  int64_t num_steps = kMiniMaxH3DefaultSteps;
+
+  // --- fl2va KEYFRAME CONDITIONING (empty => plain t2va) ---
+  // Which generated frames the supplied keyframes pin. Upstream allows exactly
+  // {}, {0}, {-1} or {0, -1}: first frame, last frame, or both.
+  std::vector<int64_t> keyframe_frame_indices;
+  // The conditioning rows, already VAE-encoded and patchified into the packed
+  // layout -- see MiniMaxH3EncodeKeyframeCondRows.
+  std::vector<float> keyframe_cond_rows;
+  // Condition-noise augmentation: out = aug*clean + (1-aug)*noise. 1.0 pins the
+  // keyframe exactly; upstream lowers it to let the model deviate.
+  double imgvid_noise_aug = 1.0;
+
+  // --- ref2va REFERENCE BLOCKS (empty => no references) ---
+  // Mutually exclusive with keyframe_frame_indices: fl2va pins frames of the
+  // OUTPUT, ref2va prepends whole reference blocks. When non-empty the packed
+  // layout is built by BuildMiniMaxH3PackedSequenceRef2va and the visual rows come
+  // from the same pinned-condition mechanism keyframes use.
+  std::vector<MiniMaxH3RefBlock> ref_blocks;
+  // The AUDIO conditioning rows for the audio-bearing reference blocks, in block
+  // order and channel-major within a block -- see MiniMaxH3EncodeReferenceAudio.
+  // Exactly `sum(ref_audio_t) * audio_channel` rows of `audio_latents_dim`; a
+  // block that claims audio rows without supplying them is refused, because the
+  // layout would grow around rows nothing ever wrote.
+  std::vector<float> audio_ref_rows;
+  double video_shift = kMiniMaxH3DefaultVideoShift;
+  double audio_shift = kMiniMaxH3DefaultAudioShift;
+  // Per-channel latent statistics from each VAE's config.json; empty skips the
+  // denormalization (useful in unit tests).
+  std::vector<float> video_latents_mean, video_latents_std;
+  std::vector<float> audio_latents_mean, audio_latents_std;
+};
+
+struct MiniMaxH3T2vaResult {
+  std::vector<float> frames;  // [C, T, H, W]
+  MiniMaxH3VideoFrameShape frame_shape;
+  std::vector<float> waveform;  // channel-major, audio_samples_per_channel each
+  int64_t audio_channels = 0;
+  int64_t audio_samples_per_channel = 0;
+  int64_t sample_rate = 0;
+};
+
+// Run the whole t2va path. NOISE IS AN INPUT: upstream seeds a torch CPU
+// generator, and reproducing torch's RNG bit-exactly decides WHICH sample you get
+// rather than whether the pipeline is right, so the caller supplies it.
+// --- video output (minimax_h3_mux.cpp) ---
+// `/v1/videos` returns MP4. Upstream shells out to ffmpeg; this LIBRARY does not
+// spawn processes (no precedent in src/vllm/), so it produces the ARTIFACTS and
+// BUILDS the argv, and the example/server layer performs the invocation.
+
+// One frame as binary PPM (P6, 8-bit RGB); ffmpeg reads it natively.
+std::string MiniMaxH3WritePpmFrame(const std::vector<float>& frames,
+                                   const MiniMaxH3VideoFrameShape& shape, int64_t frame_index);
+
+struct MiniMaxH3MuxRequest {
+  std::string frame_pattern;  // printf-style, e.g. ".../frame_%06d.ppm"
+  std::string audio_path;     // WAV path; empty for a silent clip
+  std::string output_path;    // .mp4
+  int64_t fps = kMiniMaxH3Fps;
+  int64_t crf = 18;
+};
+
+// The argv the server layer runs. Pure string assembly — never spawns anything.
+std::vector<std::string> MiniMaxH3BuildMp4MuxArgs(const MiniMaxH3MuxRequest& request);
+
+// Serialize a decoded waveform as RIFF/WAVE 16-bit PCM. The VAE's output is
+// CHANNEL-MAJOR; this interleaves it. Dependency-free, and required under either
+// outcome of the open MP4/muxer dependency decision.
+std::string MiniMaxH3WriteWav(const std::vector<float>& waveform, int64_t channels,
+                              int64_t samples_per_channel, int64_t sample_rate);
+
+// The inverse, for REFERENCE AUDIO: parse 16-bit PCM RIFF/WAVE into the same
+// CHANNEL-MAJOR float layout, mono REPEATED up to `want_channels` and anything
+// wider truncated (vae.py:305-313). `want_sample_rate` > 0 REFUSES a mismatch
+// rather than resampling — encoding at the wrong rate would shift every latent
+// frame, and this library has no audio dependency to resample with.
+std::vector<float> MiniMaxH3ReadWav(const std::string& bytes, int64_t want_channels,
+                                    int64_t want_sample_rate, int64_t* out_samples_per_channel);
+
+MiniMaxH3T2vaResult MiniMaxH3GenerateT2va(vt::Device device, const MiniMaxH3T2vaRequest& request,
+                                          const MiniMaxH3DitParams& dit_params,
+                                          const MiniMaxH3DitWeights& dit_weights,
+                                          const MiniMaxH3VideoVaeDecoderConfig& video_config,
+                                          const MiniMaxH3AudioVaeWeights& video_weights,
+                                          const MiniMaxH3AudioVaeConfig& audio_config,
+                                          const MiniMaxH3AudioVaeWeights& audio_weights,
+                                          const std::vector<float>& prompt_embeds,
+                                          const std::vector<float>& initial_video_rows,
+                                          const std::vector<float>& initial_audio_rows,
+                                          vt::DType compute_dtype,
+                                          // Weights already staged on `device`. Staging the DiT
+                                          // costs tens of seconds, so a driver or server stages
+                                          // ONCE and passes it here rather than per generation.
+                                          // Null stages internally, as before.
+                                          const MiniMaxH3DitDeviceWeights* prestaged = nullptr);
+
+// The DENOISE half of `MiniMaxH3GenerateT2va` on its own: packed layout, the two
+// sigma schedules, and the step loop, stopping before the VAEs.
+//
+// `MiniMaxH3GenerateT2va` is implemented in terms of this, so there is one copy of
+// the layout and schedule logic rather than two. Exposed separately because the DiT
+// and the VAE decoders have very different cost profiles, and a caller measuring or
+// debugging the step loop should not have to load, or find memory for, either VAE.
+// Encode supplied KEYFRAME IMAGES (each [in_channels, H, W] in [-1, 1]) into the
+// packed conditioning rows the denoise loop pins. Each image is encoded as a
+// one-frame causal clip, then patchified with the DiT's patch volume so the rows
+// are interchangeable with the video rows the loop carries.
+// Encode REFERENCE IMAGES for ref2va: the same VAE encode + patchify as keyframes,
+// but it also reports the per-image latent geometry, because a ref2va block must
+// declare the shape it occupies in the packed layout.
+//
+// Returns the packed condition rows; `out_blocks` receives one kImage block per
+// image, in the same order.
+// Encode a REFERENCE VIDEO (a clip, [in_channels, T, H, W] in [-1, 1]) for ref2va.
+//
+// Needs no new porting beyond the image path: the 3D CNN is CAUSAL in time, so a
+// clip is the same call with t > 1. Emits a kVideoAudio block -- the only kind that
+// carries a temporal extent, since kImage counts exactly one frame however large
+// its latent_t -- with `ref_audio_t = 0`, i.e. a SILENT video reference, which is
+// the part that can be honoured without the (unported) audio-VAE encoder.
+std::vector<float> MiniMaxH3EncodeReferenceVideo(
+    const MiniMaxH3EncoderFcn3dConfig& encoder_config,
+    const MiniMaxH3AudioVaeWeights& encoder_weights, const MiniMaxH3DitParams& dit_params,
+    const std::vector<float>& frames, int64_t frame_count, int64_t frame_h, int64_t frame_w,
+    MiniMaxH3RefBlock* out_block);
+
+std::vector<float> MiniMaxH3EncodeReferenceImages(
+    const MiniMaxH3EncoderFcn3dConfig& encoder_config,
+    const MiniMaxH3AudioVaeWeights& encoder_weights, const MiniMaxH3DitParams& dit_params,
+    const std::vector<std::vector<float>>& images, int64_t image_h, int64_t image_w,
+    std::vector<MiniMaxH3RefBlock>* out_blocks);
+
+// Encode a REFERENCE WAVEFORM (channel-major, already at
+// kMiniMaxH3AudioSampleRate) into the packed audio conditioning rows, and report
+// the kAudio block it occupies. The audio counterpart of
+// MiniMaxH3EncodeReferenceImages, and what makes an audio-bearing ref2va request
+// expressible: the rows belong in MiniMaxH3T2vaRequest::audio_ref_rows.
+//
+// For a VIDEO+AUDIO reference, encode the clip with MiniMaxH3EncodeReferenceVideo
+// and copy the `ref_audio_t` this reports onto that block: one kVideoAudio block
+// then carries both, which is the layout packed_sequence.py builds.
+std::vector<float> MiniMaxH3EncodeReferenceAudio(
+    const MiniMaxH3AudioVaeEncoderConfig& encoder_config,
+    const MiniMaxH3AudioVaeWeights& encoder_weights, const std::vector<float>& waveform,
+    int64_t channels, int64_t samples_per_channel, const std::vector<float>& latents_mean,
+    const std::vector<float>& latents_std, double noise_aug,
+    const std::vector<float>& noise_rows, MiniMaxH3RefBlock* out_block);
+
+std::vector<float> MiniMaxH3EncodeKeyframeCondRows(
+    const MiniMaxH3EncoderFcn3dConfig& encoder_config,
+    const MiniMaxH3AudioVaeWeights& encoder_weights, const MiniMaxH3DitParams& dit_params,
+    const std::vector<std::vector<float>>& images, int64_t image_h, int64_t image_w,
+    int64_t target_latent_t, double noise_aug, const std::vector<float>& noise_rows);
+
+MiniMaxH3DenoiseResult MiniMaxH3DenoiseT2va(vt::Device device, const MiniMaxH3T2vaRequest& request,
+                                            const MiniMaxH3DitParams& dit_params,
+                                            const MiniMaxH3DitWeights& dit_weights,
+                                            const std::vector<float>& prompt_embeds,
+                                            const std::vector<float>& initial_video_rows,
+                                            const std::vector<float>& initial_audio_rows,
+                                            vt::DType compute_dtype,
+                                            const MiniMaxH3DitDeviceWeights* prestaged = nullptr);
+
+}  // namespace vllm
diff --git a/include/vllm/model_executor/models/minimax_h3_device.h b/include/vllm/model_executor/models/minimax_h3_device.h
new file mode 100644
index 000000000..57d394128
--- /dev/null
+++ b/include/vllm/model_executor/models/minimax_h3_device.h
@@ -0,0 +1,84 @@
+// MiniMax-H3 DiT — the device-resident-forward kernel seam (brick H3-2b).
+//
+// The CPU reference (`MiniMaxH3DitForward`, minimax_h3.cpp) computes into host
+// `std::vector<float>` buffers. `MiniMaxH3DitForwardDevice` runs the SAME graph
+// with every activation resident in device memory, so the block stack never
+// round-trips through the host.
+//
+// ─── WHY THIS TABLE IS SO SMALL ──────────────────────────────────────────────
+// Almost the whole forward is already covered by tuned SHARED vt:: ops, and the
+// port reuses them rather than growing a private kernel set:
+//
+//   Linear                 -> vt::MatmulBT + vt::Add (rank-1 row-broadcast bias)
+//   RmsNormRows            -> vt::RmsNorm
+//   qkv split              -> vt::QkvSplit   ([q_all|k_all|v_all] is its exact layout)
+//   ApplyRope (3-axis)     -> vt::RopeFromCache
+//   MLP silu(gate)*up      -> vt::SiluAndMul (fc1 emits [gate;up] per row)
+//   residual add           -> vt::Add
+//   row gather / scatter   -> vt::IndexSelect / vt::IndexCopy
+//   packed varlen attention-> vt::DFlashBlockAttention(causal=false)
+//
+// H3's RoPE looks exotic but is NOT: `_apply_rope`
+// (minimax_h3_transformer.py:233-244) is plain NeoX rotate_half over the leading
+// `rot_dim` head dims. Only the ANGLES are unusual — three axes (t,h,w) derived
+// from the fp64 position grid instead of one scalar position. Since
+// vt::RopeFromCache takes a per-row [S, rot_dim] cos/sin cache and an index, the
+// port builds that cache from the position grid and passes positions=arange(S),
+// which reproduces ApplyRope without a bespoke kernel.
+//
+// That leaves exactly THREE ops the shared surface does not provide.
+//
+// SEAM: one OpProvider entry (vt/ops.h: kMiniMaxH3) whose `fn` points at a static
+// kernels-struct of typed launchers, mirroring the kLaguna precedent. Registered
+// for BOTH kCPU (cpu_ops.cpp) and kCUDA (cuda_minimax_h3.cu) — unlike Laguna,
+// which is CUDA-only — so the device forward is covered by CPU CI as well as by
+// a real GPU.
+#pragma once
+
+#include <cstdint>
+
+#include "vt/device.h"
+#include "vt/dtype.h"
+#include "vt/tensor.h"
+
+namespace vllm::minimax_h3 {
+
+struct MiniMaxH3DeviceKernels {
+  // _modulate_scale_shift (minimax_h3_transformer.py:183-192), in place:
+  //   x[r, i] = x[r, i] * (1 + scale[idx[r], i]) + shift[idx[r], i]
+  // `idx` is the per-row AdaLN row selector (combined_indices for a block,
+  // inverse_indices for the final layer), i32 [rows] on the device.
+  //
+  // `src_stride` is the ROW stride of shift/scale, which are strided CHUNK VIEWS
+  // into the flat AdaLN projection [rows, expand*width] -- chunk c of row r lives
+  // at r*src_stride + c*width, so the rows are width-wide but src_stride apart.
+  // Passing it explicitly is deliberate: treating the views as contiguous reads
+  // the wrong memory and yields a plausible-but-wrong result.
+  //
+  // `dtype` is the STREAM dtype (kF32 or kBF16) of x/shift/scale. Arithmetic is
+  // always f32; a bf16 stream rounds on STORE, which is what makes the cast point
+  // identical to upstream's -- there is no separate rounding pass.
+  void (*modulate_scale_shift)(vt::Queue&, void* x, const void* shift, const void* scale,
+                               const int32_t* idx, int64_t rows, int64_t width,
+                               int64_t src_stride, vt::DType dtype);
+  // _modulate_gate (minimax_h3_transformer.py:195-204), accumulating in place:
+  //   residual[r, i] += gate[idx[r], i] * other[r, i]
+  // `src_stride` and `dtype` as for modulate_scale_shift.
+  void (*modulate_gate)(vt::Queue&, void* residual, const void* gate, const void* other,
+                        const int32_t* idx, int64_t rows, int64_t width, int64_t src_stride,
+                        vt::DType dtype);
+  // Plain elementwise SiLU in place: x[i] = x[i] * sigmoid(x[i]). The shared op
+  // set has SiluAndMul / MoeSiluMul (both GATED forms) but no ungated SiLU, which
+  // the time embedder (:272-285) and the AdaLN projection (:555-561) both need.
+  // f32 only: both call sites are fp32 ISLANDS.
+  void (*silu)(vt::Queue&, float* x, int64_t n);
+};
+
+// Resolver. Throws when nothing is registered for (kMiniMaxH3, device) — which
+// cannot happen for kCPU/kCUDA in a normal build, but keeps the failure explicit
+// rather than a null dereference on an unexpected backend.
+const MiniMaxH3DeviceKernels* MiniMaxH3Device(vt::DeviceType device);
+// True iff the table is registered for `device` (guards the device forward).
+bool MiniMaxH3DeviceKernelsAvailable(vt::DeviceType device);
+
+}  // namespace vllm::minimax_h3
diff --git a/include/vt/ops.h b/include/vt/ops.h
index 3b0b95636..09ea3f69b 100644
--- a/include/vt/ops.h
+++ b/include/vt/ops.h
@@ -331,6 +331,16 @@ enum class OpId : uint8_t {
   // BYTE-EXACT (sequential reductions) to the host Laguna forward. Additive: only
   // LagunaForwardResidentDecode dispatches it. Appended before kCount (no id shift).
   kLaguna,
+  // MiniMax-H3 DiT device-resident-forward glue table (brick H3-2b). Only the 3
+  // small ops the shared vt:: surface does NOT already cover: the two indexed
+  // AdaLN modulates and plain elementwise SiLU. Everything else in the DiT
+  // forward reuses tuned shared ops (kMatmulBT, kRmsNorm, kQkvSplit, kSiluAndMul,
+  // kAdd, kIndexSelect, kIndexCopy, kRopeFromCache, kDFlashBlockAttention), so
+  // this table stays deliberately tiny. Registered on BOTH kCPU and kCUDA
+  // (cpu_ops.cpp / cuda_minimax_h3.cu) so the device forward is exercised in CPU
+  // CI too; resolved via minimax_h3::MiniMaxH3Device(). Additive: only
+  // MiniMaxH3DitForwardDevice dispatches it. Appended before kCount (no id shift).
+  kMiniMaxH3,
   kCount
 };
 
diff --git a/real20-beach-puppy.mp4 b/real20-beach-puppy.mp4
new file mode 100644
index 000000000..0aed50381
Binary files /dev/null and b/real20-beach-puppy.mp4 differ
diff --git a/scripts/check-agent-record.py b/scripts/check-agent-record.py
index ff7802c29..69f2e2fdf 100644
--- a/scripts/check-agent-record.py
+++ b/scripts/check-agent-record.py
@@ -14,7 +14,7 @@
 AGENTS = ROOT / ".agents"
 
 MATRICES = {
-    "MODEL": (AGENTS / "model-matrix.md", 327),
+    "MODEL": (AGENTS / "model-matrix.md", 328),
     # 82 since 2026-07-21: +`QUANT-NVFP4-CT-W4A16` (compressed-tensors NVFP4A16 /
     # W4A16 — NVFP4 weights with BF16 activations, distinct from the existing
     # `QUANT-NVFP4-CT-W4A4` and `QUANT-NVFP4-MO-W4A16` rows in both scheme
diff --git a/scripts/gen-minimax-h3-audio-vae-encoder-goldens.py b/scripts/gen-minimax-h3-audio-vae-encoder-goldens.py
new file mode 100644
index 000000000..4c5fdd279
--- /dev/null
+++ b/scripts/gen-minimax-h3-audio-vae-encoder-goldens.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""Emit tests/vllm/models/minimax_h3_audio_vae_encoder_goldens.inc.
+
+The companion to scripts/gen-minimax-h3-audio-vae-goldens.py, for the ANALYSIS
+half of the same VAE. The decoder generator gates BigVGAN; this one gates the
+DAC-lineage ENCODER plus the two stages the reference-audio path runs after it:
+
+    preprocess (right-pad to a multiple of hop_length)
+      -> Encoder            (dac_audio_vae.py:90-117)
+      -> pre_block          (dac_attn_proj.py:69-88, when attn_proj is set)
+      -> mean_proj          (dac_audio_vae.py:157)
+
+which is exactly the sequence vLLM-Omni runs to turn a reference waveform into
+conditioning rows (vae.py:317-325). It takes the distribution MEAN (`mean_proj`)
+and never `logs_proj`, so the same reference always yields the same rows.
+
+Like every other H3 generator this executes the CHECKPOINT'S OWN remote-code
+modules as the oracle; the remote code is not vendored here (it ships under the
+MiniMax H3 Community License with the checkpoint). Point --h3-vae-source at a
+local copy of the checkpoint's `audio_vae/` directory; only the .py files are
+needed, not the 605 MB model.safetensors:
+
+    python3 scripts/gen-minimax-h3-audio-vae-encoder-goldens.py \\
+        --h3-vae-source ~/h3/FL2VA/audio_vae \\
+        --out tests/vllm/models/minimax_h3_audio_vae_encoder_goldens.inc
+
+Weights come from the shared FNV-1a + splitmix64 stream keyed by state_dict
+NAME, identical to gen-minimax-h3-goldens.py :: h3_rand and the C++ H3Rand, so
+the golden is reproducible from source alone and no weight byte is checked in.
+
+Shipped geometry (metadata.json + config.yaml, and confirmed by the real
+1087-tensor manifest): encoder_dim 64, encoder_rates [2,4,4,5,5] (hop 800),
+latent_dim 2048, vae_latent_channels 32, attn_proj true with 8 heads. The
+reduced configuration below keeps every structural feature — the strided
+downsampling stack, the 3 dilated residual units per block, Snake1d, the causal
+attention projection with its head-mean + adaptive-average-pool narrowing, and
+the GeGLU MLP — and only shrinks the magnitudes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import math
+import sys
+import types
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch import nn
+
+_MASK64 = (1 << 64) - 1
+
+
+def fnv1a64(name: str) -> int:
+    h = 0xCBF29CE484222325
+    for byte in name.encode("utf-8"):
+        h ^= byte
+        h = (h * 0x100000001B3) & _MASK64
+    return h
+
+
+def splitmix64(x: int) -> int:
+    x = (x + 0x9E3779B97F4A7C15) & _MASK64
+    z = x
+    z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & _MASK64
+    z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & _MASK64
+    return z ^ (z >> 31)
+
+
+def h3_rand(name: str, count: int) -> np.ndarray:
+    """Identical to gen-minimax-h3-goldens.py :: h3_rand and the C++ H3Rand."""
+    seed = fnv1a64(name)
+    out = np.empty(count, dtype=np.float64)
+    for i in range(count):
+        u = splitmix64((seed + i) & _MASK64)
+        out[i] = ((u >> 11) * (2.0**-53)) * 2.0 - 1.0
+    return out
+
+
+def load_remote_package(source: Path) -> types.ModuleType:
+    """Import the checkpoint's audio_vae bundle without vendoring it."""
+    source = source.expanduser().resolve()
+    for required in ("dac_audio_vae.py", "dac_attn_proj.py", "dac_bigvgan.py"):
+        if not (source / required).is_file():
+            raise SystemExit(
+                f"missing {required} in {source}; point --h3-vae-source at the checkpoint's audio_vae/"
+            )
+    pkg = types.ModuleType("h3_audio_vae")
+    pkg.__path__ = [str(source)]
+    sys.modules["h3_audio_vae"] = pkg
+    spec = importlib.util.spec_from_file_location(
+        "h3_audio_vae.dac_audio_vae", source / "dac_audio_vae.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+# Reduced dimensions. The SHIPPED encoder is 5 strided blocks 64 -> 2048 over a
+# hop of 800; this keeps the structure and shrinks the numbers.
+ENCODER_DIM = 8
+ENCODER_RATES = [2, 2]
+LATENT_DIM = 16
+VAE_LATENT_CHANNELS = 4
+ATTN_HEADS = 2
+# Deliberately NOT a multiple of hop_length (4): preprocess must right-pad it,
+# and a port that skipped the padding would produce one frame fewer.
+INPUT_SAMPLES = 25
+
+
+class RefAudioEncoder(nn.Module):
+    """The encode half of DacAudioVAE, assembled exactly as DacAudioVAE does.
+
+    Submodule NAMES match the checkpoint (`encoder.block.*`, `pre_block.*`,
+    `mean_proj.*`), so the emitted golden is keyed by the same state_dict names
+    the C++ loader maps onto. DacAudioVAE itself cannot be instantiated at these
+    dimensions because its __init__ always builds a full BigVGAN and rejects any
+    sample_rate other than 16k/32k (dac_audio_vae.py:162-193); the encode path it
+    would build is reproduced here from the same lines.
+    """
+
+    def __init__(self, vae_mod) -> None:
+        super().__init__()
+        # dac_audio_vae.py:148-149
+        self.hop_length = int(np.prod(ENCODER_RATES))
+        self.encoder = vae_mod.Encoder(ENCODER_DIM, ENCODER_RATES, LATENT_DIM)
+        # dac_audio_vae.py:151-158
+        if LATENT_DIM % VAE_LATENT_CHANNELS == 0:
+            attn_proj_dim = VAE_LATENT_CHANNELS
+        else:
+            attn_proj_dim = 2 ** int(np.ceil(np.log2(VAE_LATENT_CHANNELS)))
+        self.attn_proj_dim = attn_proj_dim
+        self.mean_proj = nn.Conv1d(attn_proj_dim, VAE_LATENT_CHANNELS, 1)
+        # dac_audio_vae.py:195-196
+        self.pre_block = vae_mod.AttnProjection(LATENT_DIM, attn_proj_dim, num_heads=ATTN_HEADS)
+
+    def preprocess(self, audio_data):
+        # dac_audio_vae.py:201-209
+        length = audio_data.shape[-1]
+        right_pad = math.ceil(length / self.hop_length) * self.hop_length - length
+        return nn.functional.pad(audio_data, (0, right_pad))
+
+    def forward(self, waveform):
+        # vae.py:317-325 — the reference-audio encode, verbatim.
+        audio = self.preprocess(waveform.unsqueeze(1))
+        latent = self.encoder(audio)
+        latent = self.pre_block(latent.transpose(1, 2)).transpose(1, 2)
+        return self.mean_proj(latent)
+
+
+def fill_from_stream(model: nn.Module) -> None:
+    """Set every parameter from the deterministic stream, by NAME."""
+    state = model.state_dict()
+    for name, tensor in state.items():
+        count = tensor.numel()
+        if name.endswith("original0"):  # weight-norm magnitude g
+            values = h3_rand(name, count) * 0.03 + 0.15
+        elif name.endswith("original1"):  # weight-norm direction v
+            values = h3_rand(name, count) * 0.08
+        elif name.endswith(".alpha"):
+            # Snake1d divides by (alpha + 1e-9), and upstream initializes alpha to
+            # ONES (dac_audio_vae.py:37). Centering on 1 keeps the reciprocal
+            # well-conditioned; centering on 0 would make the golden a numerical
+            # accident rather than a test.
+            values = h3_rand(name, count) * 0.2 + 1.0
+        elif name.endswith("zero_k_bias"):
+            continue  # a registered BUFFER that must stay zero (dac_attn_proj.py:37)
+        elif name.endswith("bias"):  # covers .bias, q_bias and v_bias
+            values = h3_rand(name, count) * 0.05
+        elif "norm" in name and tensor.dim() == 1 and name.endswith(".weight"):
+            values = h3_rand(name, count) * 0.1 + 1.0  # LayerNorm gain, centered on 1
+        else:
+            values = h3_rand(name, count) * 0.1
+        state[name] = torch.from_numpy(values.astype(np.float32)).reshape(tensor.shape)
+    model.load_state_dict(state, strict=True)
+
+
+def emit_f32(out, name: str, values) -> None:
+    flat = np.asarray(values, dtype=np.float32).reshape(-1).tolist()
+    out.write(f"inline constexpr float {name}[] = {{\n")
+    for i in range(0, len(flat), 6):
+        chunk = []
+        for v in flat[i : i + 6]:
+            text = f"{v:.9g}"
+            if "." not in text and "e" not in text and "E" not in text:
+                text += ".0"
+            chunk.append(text + "f")
+        out.write("    " + ", ".join(chunk) + ",\n")
+    out.write("};\n\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--h3-vae-source", required=True, type=Path,
+                        help="the checkpoint's FL2VA/audio_vae directory (.py files only)")
+    parser.add_argument("--out", required=True, type=Path)
+    args = parser.parse_args()
+
+    vae_mod = load_remote_package(args.h3_vae_source)
+    torch.set_grad_enabled(False)
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+
+    model = RefAudioEncoder(vae_mod).eval()
+    fill_from_stream(model)
+
+    # One MONO waveform row: the reference path encodes each channel separately
+    # (it repeats a mono file up to the model's 2 channels), so one row is the
+    # unit under test.
+    waveform = torch.from_numpy(
+        h3_rand("audiovae.encoder.input", INPUT_SAMPLES).astype(np.float32)
+    ).reshape(1, INPUT_SAMPLES)
+
+    # The three staged tensors, so a C++ mismatch can be localized to a stage
+    # instead of being a single opaque end-to-end number.
+    padded = model.preprocess(waveform.unsqueeze(1))
+    enc = model.encoder(padded)                                   # [1, LATENT_DIM, frames]
+    proj = model.pre_block(enc.transpose(1, 2)).transpose(1, 2)   # [1, attn_proj_dim, frames]
+    latent = model.mean_proj(proj)                                # [1, VAE_LATENT_CHANNELS, frames]
+    frames = int(enc.shape[-1])
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as out:
+        out.write(
+            "// GENERATED by scripts/gen-minimax-h3-audio-vae-encoder-goldens.py — DO NOT EDIT BY HAND.\n"
+            "//\n"
+            "// MiniMax-H3 AUDIO VAE **encoder** goldens, produced by executing the CHECKPOINT'S OWN\n"
+            "// remote-code modules (FL2VA/audio_vae/dac_audio_vae.py + dac_attn_proj.py) at reduced\n"
+            "// dimensions, in the exact sequence vLLM-Omni's reference-audio path runs\n"
+            "// (vae.py:317-325): preprocess -> Encoder -> pre_block -> mean_proj. The remote code is\n"
+            "// not vendored here; see the generator's docstring. Weights come from the shared H3Rand\n"
+            "// stream, so no weight byte is checked in.\n"
+            "#pragma once\n\n#include <cstdint>\n\nnamespace vllm_test {\n\n"
+        )
+        out.write(f"inline constexpr int64_t kH3AudioEncDim = {ENCODER_DIM};\n")
+        out.write(f"inline constexpr int64_t kH3AudioEncLatentDim = {LATENT_DIM};\n")
+        out.write(
+            f"inline constexpr int64_t kH3AudioEncVaeChannels = {VAE_LATENT_CHANNELS};\n")
+        out.write(f"inline constexpr int64_t kH3AudioEncHeads = {ATTN_HEADS};\n")
+        out.write(f"inline constexpr int64_t kH3AudioEncSamples = {INPUT_SAMPLES};\n")
+        out.write(f"inline constexpr int64_t kH3AudioEncFrames = {frames};\n")
+        out.write("inline constexpr int64_t kH3AudioEncRates[] = {"
+                  + ", ".join(str(r) for r in ENCODER_RATES) + "};\n\n")
+        emit_f32(out, "kH3AudioEncInputGolden", waveform.reshape(-1))
+        emit_f32(out, "kH3AudioEncBlockGolden", enc.reshape(-1))
+        emit_f32(out, "kH3AudioEncAttnProjGolden", proj.reshape(-1))
+        emit_f32(out, "kH3AudioEncMeanGolden", latent.reshape(-1))
+        out.write("}  // namespace vllm_test\n")
+    print(f"wrote {args.out} (frames {frames})", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/gen-minimax-h3-audio-vae-goldens.py b/scripts/gen-minimax-h3-audio-vae-goldens.py
new file mode 100644
index 000000000..58399ebee
--- /dev/null
+++ b/scripts/gen-minimax-h3-audio-vae-goldens.py
@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""Emit tests/vllm/models/minimax_h3_audio_vae_goldens.inc.
+
+The MiniMax-H3 audio VAE is **checkpoint REMOTE CODE**: its implementation ships
+inside the HF repo (`FL2VA/audio_vae/*.py`) and vLLM-Omni only adapts it under
+`trust_remote_code` (vae.py:41-53). A pure-C++ engine cannot do that, so the VAE
+must be REIMPLEMENTED — and this generator is what makes that reimplementation
+verifiable: it imports the checkpoint's OWN Python modules and runs them at
+reduced dimensions as the oracle, exactly like gen-minimax-h3-goldens.py does for
+the DiT.
+
+The remote code is NOT vendored into this repository (it ships under the MiniMax
+H3 Community License with the checkpoint). Point --h3-vae-source at a local copy
+of the checkpoint's `audio_vae/` directory; only the .py files are needed, not the
+605 MB model.safetensors:
+
+    python3 scripts/gen-minimax-h3-audio-vae-goldens.py \\
+        --h3-vae-source ~/h3/FL2VA/audio_vae \\
+        --out tests/vllm/models/minimax_h3_audio_vae_goldens.inc
+
+Architecture (from the checkpoint's config.yaml + metadata.json):
+  decode(z) = dec_in_proj(Conv1d 32 -> 2048, k=1) -> BigVGAN
+  BigVGAN: conv_pre(2048 -> 1024, k=7) -> 7 x [ConvTranspose1d upsample +
+           3 AMPBlock1 residual blocks averaged] -> anti-aliased SnakeBeta ->
+           conv_post(-> 1 channel, k=7, no bias) -> clamp[-1, 1]
+  upsample_rates [5,5,2,2,2,2,2], kernels [9,9,4,4,4,4,4], resblock kernels
+  [3,7,11] with dilations [1,3,5], snakebeta activations in LOG scale.
+Every conv is weight-normalized, so the checkpoint stores (g, v) pairs
+(`parametrizations.weight.original0/1`) and the loader must materialize
+w = g * v / ||v|| with the norm taken over every dim except dim 0.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+import numpy as np
+import torch
+
+_MASK64 = (1 << 64) - 1
+
+
+def fnv1a64(name: str) -> int:
+    h = 0xCBF29CE484222325
+    for byte in name.encode("utf-8"):
+        h ^= byte
+        h = (h * 0x100000001B3) & _MASK64
+    return h
+
+
+def splitmix64(x: int) -> int:
+    x = (x + 0x9E3779B97F4A7C15) & _MASK64
+    z = x
+    z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & _MASK64
+    z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & _MASK64
+    return z ^ (z >> 31)
+
+
+def h3_rand(name: str, count: int) -> np.ndarray:
+    """Identical to gen-minimax-h3-goldens.py :: h3_rand and the C++ H3Rand."""
+    seed = fnv1a64(name)
+    out = np.empty(count, dtype=np.float64)
+    for i in range(count):
+        u = splitmix64((seed + i) & _MASK64)
+        out[i] = ((u >> 11) * (2.0**-53)) * 2.0 - 1.0
+    return out
+
+
+def load_remote_package(source: Path) -> types.ModuleType:
+    """Import the checkpoint's audio_vae bundle without vendoring it.
+
+    The bundle uses relative imports, so it is registered as a real package
+    whose __path__ is the source directory.
+    """
+    source = source.expanduser().resolve()
+    for required in ("dac_bigvgan.py", "dac_activations.py", "dac_alias_free_act.py"):
+        if not (source / required).is_file():
+            raise SystemExit(f"missing {required} in {source}; point --h3-vae-source at the checkpoint's audio_vae/")
+    pkg = types.ModuleType("h3_audio_vae")
+    pkg.__path__ = [str(source)]
+    sys.modules["h3_audio_vae"] = pkg
+    spec = importlib.util.spec_from_file_location(
+        "h3_audio_vae.dac_bigvgan", source / "dac_bigvgan.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+# Reduced dimensions. The SHIPPED decoder is 7 upsample stages at
+# initial_channel 1024 over 2048 mels; this keeps every structural feature
+# (multiple stages, 3 resblock kernels x 3 dilations, the anti-aliased snakebeta,
+# the final clamp) and only shrinks the magnitudes.
+REDUCED = dict(
+    resblock="1",
+    num_mels=16,
+    upsample_rates=[2, 2],
+    upsample_kernel_sizes=[4, 4],
+    upsample_initial_channel=16,
+    resblock_kernel_sizes=[3, 7, 11],
+    resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+    use_tanh_at_final=False,
+    use_bias_at_final=False,
+    activation="snakebeta",
+    snake_logscale=True,
+)
+INPUT_FRAMES = 8
+
+
+def fill_from_stream(model: torch.nn.Module) -> None:
+    """Set every parameter/buffer from the deterministic stream, by NAME.
+
+    Scales differ per role so the test exercises realistic magnitudes: weight-norm
+    magnitudes (`original0`) stay near 1, directions and biases stay small, and
+    the snakebeta log-scale alpha/beta stay near 0 (i.e. exp() near 1).
+    """
+    state = model.state_dict()
+    for name, tensor in state.items():
+        count = tensor.numel()
+        if name.endswith("original0"):  # weight-norm magnitude g
+            # g IS the per-output-channel norm of the materialized weight, so it
+            # sets the gain of every conv. Kept well below 1 so the residual stack
+            # does not saturate the decoder's final clamp[-1, 1] (a saturated
+            # golden would hide errors rather than catch them).
+            values = h3_rand(name, count) * 0.03 + 0.15
+        elif name.endswith("original1"):  # weight-norm direction v
+            # Deliberately small: the residual stack otherwise saturates the final
+            # clamp[-1, 1] on most samples, and a saturated golden would HIDE
+            # errors instead of catching them.
+            values = h3_rand(name, count) * 0.08
+        elif name.endswith(".alpha") or name.endswith(".beta"):
+            values = h3_rand(name, count) * 0.2
+        elif name.endswith(".bias"):
+            values = h3_rand(name, count) * 0.05
+        elif name.endswith("filter"):
+            continue  # the kaiser-sinc filters are COMPUTED, never loaded
+        else:
+            values = h3_rand(name, count) * 0.1
+        state[name] = torch.from_numpy(values.astype(np.float32)).reshape(tensor.shape)
+    model.load_state_dict(state, strict=True)
+
+
+def emit_f32(out, name: str, values) -> None:
+    flat = np.asarray(values, dtype=np.float32).reshape(-1).tolist()
+    out.write(f"inline constexpr float {name}[] = {{\n")
+    for i in range(0, len(flat), 6):
+        chunk = []
+        for v in flat[i : i + 6]:
+            text = f"{v:.9g}"
+            if "." not in text and "e" not in text and "E" not in text:
+                text += ".0"
+            chunk.append(text + "f")
+        out.write("    " + ", ".join(chunk) + ",\n")
+    out.write("};\n\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--h3-vae-source", required=True, type=Path,
+                        help="the checkpoint's FL2VA/audio_vae directory (.py files only)")
+    parser.add_argument("--out", required=True, type=Path)
+    args = parser.parse_args()
+
+    bigvgan = load_remote_package(args.h3_vae_source)
+    torch.set_grad_enabled(False)
+
+    h = bigvgan.AttrDict(**REDUCED)
+    model = bigvgan.BigVGAN(h).eval()
+    fill_from_stream(model)
+
+    x = torch.from_numpy(
+        h3_rand("audiovae.input", REDUCED["num_mels"] * INPUT_FRAMES).astype(np.float32)
+    ).reshape(1, REDUCED["num_mels"], INPUT_FRAMES)
+    y = model(x)
+
+    # The kaiser-sinc filter the anti-aliased activation uses (up ratio 2,
+    # kernel 12). Emitted so the C++ side can prove its filter construction
+    # matches before blaming the rest of the decoder for a mismatch.
+    from importlib import import_module
+    filt_mod = import_module("h3_audio_vae.dac_alias_free_filter")
+    up_filter = filt_mod.kaiser_sinc_filter1d(cutoff=0.5 / 2, half_width=0.6 / 2, kernel_size=12)
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as out:
+        out.write(
+            "// GENERATED by scripts/gen-minimax-h3-audio-vae-goldens.py — DO NOT EDIT BY HAND.\n"
+            "//\n"
+            "// MiniMax-H3 AUDIO VAE decoder goldens, produced by executing the CHECKPOINT'S OWN\n"
+            "// remote-code modules (FL2VA/audio_vae/*.py) at reduced dimensions. The remote code\n"
+            "// is not vendored here; see the generator's docstring. Weights come from the shared\n"
+            "// H3Rand stream, so no weight byte is checked in.\n"
+            "#pragma once\n\n#include <cstdint>\n\nnamespace vllm_test {\n\n"
+        )
+        out.write(f"inline constexpr int64_t kH3AudioVaeNumMels = {REDUCED['num_mels']};\n")
+        out.write(f"inline constexpr int64_t kH3AudioVaeFrames = {INPUT_FRAMES};\n")
+        out.write(
+            f"inline constexpr int64_t kH3AudioVaeInitialChannel = {REDUCED['upsample_initial_channel']};\n")
+        out.write(f"inline constexpr int64_t kH3AudioVaeOutSamples = {int(y.shape[-1])};\n\n")
+        emit_f32(out, "kH3AudioVaeUpFilterGolden", up_filter.reshape(-1))
+        emit_f32(out, "kH3AudioVaeWaveformGolden", y.reshape(-1))
+        out.write("}  // namespace vllm_test\n")
+    print(f"wrote {args.out} (out samples {int(y.shape[-1])})", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/gen-minimax-h3-encoder-goldens.py b/scripts/gen-minimax-h3-encoder-goldens.py
new file mode 100644
index 000000000..aab2d9564
--- /dev/null
+++ b/scripts/gen-minimax-h3-encoder-goldens.py
@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""Emit tests/vllm/models/minimax_h3_encoder_goldens.inc.
+
+The MiniMax-H3 text/vision encoder (`H3-Encoder`) is a Qwen3-VL whose TEXT tower
+H3 uses with three deltas (encoder.py:1-30):
+  1. only the first MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER (50) decoder layers are
+     kept, and the checkpoint consumes the hidden state AFTER layer 49;
+  2. that state is UNNORMALIZED -- there is no final RMSNorm, unlike a standard
+     Qwen3-VL text model;
+  3. DeepStack visual features are added into the first
+     len(deepstack_visual_indexes) layers' outputs at the visual token positions.
+The result is the [seq, 5120] `prompt_embeds` the DiT consumes.
+
+This runs the UPSTREAM `MiniMaxH3Qwen3VLTextModel` at reduced dimensions as the
+oracle (vllm-omni is imported by file path with a one-symbol `vllm.logger` stub,
+so neither vllm nor its dependencies are needed).
+
+    python3 scripts/gen-minimax-h3-encoder-goldens.py \
+        --vllm-omni ~/_git/vllm-omni \
+        --out tests/vllm/models/minimax_h3_encoder_goldens.inc
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import logging
+import sys
+import types
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+import torch
+
+_MASK64 = (1 << 64) - 1
+
+
+def fnv1a64(name: str) -> int:
+    h = 0xCBF29CE484222325
+    for byte in name.encode("utf-8"):
+        h ^= byte
+        h = (h * 0x100000001B3) & _MASK64
+    return h
+
+
+def splitmix64(x: int) -> int:
+    x = (x + 0x9E3779B97F4A7C15) & _MASK64
+    z = x
+    z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & _MASK64
+    z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & _MASK64
+    return z ^ (z >> 31)
+
+
+def h3_rand(name: str, count: int) -> np.ndarray:
+    seed = fnv1a64(name)
+    out = np.empty(count, dtype=np.float64)
+    for i in range(count):
+        u = splitmix64((seed + i) & _MASK64)
+        out[i] = ((u >> 11) * (2.0**-53)) * 2.0 - 1.0
+    return out
+
+
+def load_encoder(root: Path):
+    """Import vllm-omni's encoder module with a minimal vllm stub."""
+    if "vllm" not in sys.modules:
+        v = types.ModuleType("vllm")
+        sys.modules["vllm"] = v
+        lg = types.ModuleType("vllm.logger")
+        lg.init_logger = logging.getLogger
+        sys.modules["vllm.logger"] = lg
+        v.logger = lg
+    path = root / "vllm_omni" / "diffusion" / "models" / "minimax_h3" / "encoder.py"
+    if not path.is_file():
+        raise SystemExit(f"upstream encoder not found: {path}")
+    spec = importlib.util.spec_from_file_location("h3_encoder", path)
+    m = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = m
+    spec.loader.exec_module(m)
+    return m
+
+
+# Reduced Qwen3-VL text geometry. GQA (2 q-heads over 1 kv-head), interleaved
+# M-RoPE sections, and a layer budget larger than the selected layer so the
+# TRUNCATION rule is actually exercised.
+VOCAB = 32
+HIDDEN = 16
+NUM_LAYERS = 4      # the config claims 4 ...
+SELECTED_LAYER = 3  # ... but only 3 are kept, exactly like 50-of-N upstream
+HEADS = 2
+KV_HEADS = 1
+HEAD_DIM = 8
+INTERMEDIATE = 32
+MROPE_SECTION = [2, 1, 1]
+SEQ = 5
+DEEPSTACK_LAYERS = 2
+
+# Reduced vision tower block. Two packed images so the varlen (cu_seqlens)
+# segmentation is actually exercised rather than degenerating to one segment.
+VIS_DIM = 16
+VIS_HEADS = 2
+VIS_INTERMEDIATE = 32
+VIS_SEQ = 6
+VIS_CU_SEQLENS = [0, 4, 6]
+
+# Reduced FULL vision tower. num_position_embeddings must be a perfect square
+# (the learned grid is num_grid_per_side^2), and grid h/w must divide by
+# spatial_merge_size.
+VIS_DEPTH = 2
+VIS_PATCH = 2
+VIS_TEMPORAL_PATCH = 2
+VIS_IN_CH = 3
+VIS_MERGE = 2
+VIS_OUT_HIDDEN = 16
+VIS_NUM_POS = 16          # 4x4 learned grid
+VIS_GRID_THW = [[1, 4, 4], [1, 2, 2]]   # two images, second smaller
+VIS_DEEPSTACK_IDX = [0]
+
+
+def emit_f32(out, name: str, values) -> None:
+    flat = np.asarray(values, dtype=np.float32).reshape(-1).tolist()
+    out.write(f"inline constexpr float {name}[] = {{\n")
+    for i in range(0, len(flat), 6):
+        chunk = []
+        for v in flat[i : i + 6]:
+            text = f"{v:.9g}"
+            if "." not in text and "e" not in text and "E" not in text:
+                text += ".0"
+            chunk.append(text + "f")
+        out.write("    " + ", ".join(chunk) + ",\n")
+    out.write("};\n\n")
+
+
+def emit_i64(out, name: str, values) -> None:
+    flat = [int(v) for v in np.asarray(values).reshape(-1).tolist()]
+    out.write(f"inline constexpr int64_t {name}[] = {{\n")
+    for i in range(0, len(flat), 12):
+        out.write("    " + ", ".join(str(v) for v in flat[i : i + 12]) + ",\n")
+    out.write("};\n\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--vllm-omni", required=True, type=Path)
+    parser.add_argument("--out", required=True, type=Path)
+    args = parser.parse_args()
+
+    enc = load_encoder(args.vllm_omni.expanduser())
+    torch.set_grad_enabled(False)
+
+    group = SimpleNamespace(rank_in_group=0, world_size=1)  # TP=1
+    config = SimpleNamespace(
+        vocab_size=VOCAB, hidden_size=HIDDEN, num_hidden_layers=NUM_LAYERS,
+        num_attention_heads=HEADS, num_key_value_heads=KV_HEADS, head_dim=HEAD_DIM,
+        intermediate_size=INTERMEDIATE, rms_norm_eps=1e-6,
+        rope_parameters={"rope_theta": 10000.0, "mrope_section": MROPE_SECTION},
+        max_position_embeddings=128, attention_bias=False, attention_dropout=0.0,
+    )
+    model = enc.MiniMaxH3Qwen3VLTextModel(group, config, selected_layer=SELECTED_LAYER,
+                                          dtype=torch.float32).eval()
+    assert model.num_layers == SELECTED_LAYER, "layer truncation did not apply"
+
+    state = model.state_dict()
+    for name, tensor in state.items():
+        scale, offset = (0.1, 0.0)
+        if name.endswith("norm.weight") or name.endswith("layernorm.weight"):
+            scale, offset = 0.1, 1.0
+        state[name] = torch.from_numpy(
+            (h3_rand("encoder." + name, tensor.numel()) * scale + offset).astype(np.float32)
+        ).reshape(tensor.shape)
+    model.load_state_dict(state, strict=True)
+
+    inputs_embeds = torch.from_numpy(
+        h3_rand("encoder.inputs_embeds", SEQ * HIDDEN).astype(np.float32)
+    ).reshape(1, SEQ, HIDDEN)
+    # M-RoPE positions are (3, batch, seq): temporal / height / width.
+    positions = torch.arange(SEQ).view(1, 1, SEQ).expand(3, 1, SEQ).contiguous()
+
+    plain = model(inputs_embeds, positions)
+
+    # DeepStack: visual features added at the visual token positions, for the
+    # FIRST len(deepstack_visual_embeds) layers only.
+    visual_mask = torch.zeros(1, SEQ, dtype=torch.bool)
+    visual_mask[0, 1] = True
+    visual_mask[0, 3] = True
+    num_visual = int(visual_mask.sum())
+    deepstack = [
+        torch.from_numpy(
+            (h3_rand(f"encoder.deepstack.{i}", num_visual * HIDDEN) * 0.1).astype(np.float32)
+        ).reshape(num_visual, HIDDEN)
+        for i in range(DEEPSTACK_LAYERS)
+    ]
+    with_deepstack = model(inputs_embeds, positions, visual_pos_masks=visual_mask,
+                           deepstack_visual_embeds=deepstack)
+
+    # --- vision tower BLOCK (the repeated unit of the ViT) ---
+    vision_config = SimpleNamespace(
+        hidden_size=VIS_DIM, num_heads=VIS_HEADS, intermediate_size=VIS_INTERMEDIATE,
+    )
+    vblock = enc.MiniMaxH3Qwen3VLVisionBlock(vision_config).eval()
+    vstate = vblock.state_dict()
+    for name, tensor in vstate.items():
+        scale, offset = (0.1, 0.0)
+        if name.endswith("norm1.weight") or name.endswith("norm2.weight"):
+            scale, offset = 0.1, 1.0
+        elif name.endswith(".bias"):
+            scale = 0.05
+        vstate[name] = torch.from_numpy(
+            (h3_rand("encoder.vision." + name, tensor.numel()) * scale + offset).astype(np.float32)
+        ).reshape(tensor.shape)
+    vblock.load_state_dict(vstate, strict=True)
+
+    vhidden = torch.from_numpy(
+        h3_rand("encoder.vision.input", VIS_SEQ * VIS_DIM).astype(np.float32)
+    ).reshape(VIS_SEQ, VIS_DIM)
+    # cos/sin are [seq, head_dim]; the tower builds them from a 2D rotary table,
+    # but the BLOCK just consumes them, so they are supplied directly here.
+    head_dim = VIS_DIM // VIS_HEADS
+    vcos = torch.from_numpy(
+        h3_rand("encoder.vision.cos", VIS_SEQ * head_dim).astype(np.float32)
+    ).reshape(VIS_SEQ, head_dim).cos()
+    vsin = torch.from_numpy(
+        h3_rand("encoder.vision.sin", VIS_SEQ * head_dim).astype(np.float32)
+    ).reshape(VIS_SEQ, head_dim).sin()
+    vcu = torch.tensor(VIS_CU_SEQLENS, dtype=torch.int32)
+    vout = vblock(vhidden, cu_seqlens=vcu, position_embeddings=(vcos, vsin))
+
+    # --- the WHOLE vision tower ---
+    tower_config = SimpleNamespace(
+        hidden_size=VIS_DIM, num_heads=VIS_HEADS, intermediate_size=VIS_INTERMEDIATE,
+        depth=VIS_DEPTH, patch_size=VIS_PATCH, temporal_patch_size=VIS_TEMPORAL_PATCH,
+        in_channels=VIS_IN_CH, spatial_merge_size=VIS_MERGE, out_hidden_size=VIS_OUT_HIDDEN,
+        num_position_embeddings=VIS_NUM_POS, deepstack_visual_indexes=VIS_DEEPSTACK_IDX,
+    )
+    tower = enc.MiniMaxH3Qwen3VLVisionModel(tower_config).eval()
+    tstate = tower.state_dict()
+    for name, tensor in tstate.items():
+        scale, offset = (0.1, 0.0)
+        if name.endswith("norm1.weight") or name.endswith("norm2.weight") or ".norm.weight" in name:
+            scale, offset = 0.1, 1.0
+        elif name.endswith(".bias"):
+            scale = 0.05
+        tstate[name] = torch.from_numpy(
+            (h3_rand("encoder.tower." + name, tensor.numel()) * scale + offset).astype(np.float32)
+        ).reshape(tensor.shape)
+    tower.load_state_dict(tstate, strict=True)
+
+    grid = torch.tensor(VIS_GRID_THW, dtype=torch.long)
+    patch_elems = VIS_IN_CH * VIS_TEMPORAL_PATCH * VIS_PATCH * VIS_PATCH
+    total_patches = sum(t * h * w for t, h, w in VIS_GRID_THW)
+    pixels = torch.from_numpy(
+        h3_rand("encoder.tower.pixels", total_patches * patch_elems).astype(np.float32)
+    ).reshape(total_patches, patch_elems)
+    merged, deepstack_feats = tower(pixels, grid)
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as out:
+        out.write(
+            "// GENERATED by scripts/gen-minimax-h3-encoder-goldens.py — DO NOT EDIT BY HAND.\n"
+            "//\n"
+            "// MiniMax-H3 ENCODER text-tower goldens from the UPSTREAM vLLM-Omni\n"
+            "// MiniMaxH3Qwen3VLTextModel at reduced dimensions. Weights come from the shared\n"
+            "// H3Rand stream, so no weight byte is checked in. The three H3 deltas vs a stock\n"
+            "// Qwen3-VL text model — layer truncation, the UNNORMALIZED output, and DeepStack\n"
+            "// injection into the first N layers — are all exercised here.\n"
+            "#pragma once\n\n#include <cstdint>\n\nnamespace vllm_test {\n\n"
+        )
+        for key, value in (
+            ("Vocab", VOCAB), ("Hidden", HIDDEN), ("ConfigLayers", NUM_LAYERS),
+            ("SelectedLayer", SELECTED_LAYER), ("Heads", HEADS), ("KvHeads", KV_HEADS),
+            ("HeadDim", HEAD_DIM), ("Intermediate", INTERMEDIATE), ("Seq", SEQ),
+            ("DeepstackLayers", DEEPSTACK_LAYERS), ("NumVisual", num_visual),
+        ):
+            out.write(f"inline constexpr int64_t kH3Enc{key} = {value};\n")
+        out.write("\n")
+        emit_i64(out, "kH3EncMropeSection", MROPE_SECTION)
+        emit_i64(out, "kH3EncVisualMask", visual_mask.to(torch.int64))
+        emit_f32(out, "kH3EncGolden", plain.reshape(-1))
+        emit_f32(out, "kH3EncDeepstackGolden", with_deepstack.reshape(-1))
+
+        out.write(f"inline constexpr int64_t kH3EncVisDim = {VIS_DIM};\n")
+        out.write(f"inline constexpr int64_t kH3EncVisHeads = {VIS_HEADS};\n")
+        out.write(f"inline constexpr int64_t kH3EncVisIntermediate = {VIS_INTERMEDIATE};\n")
+        out.write(f"inline constexpr int64_t kH3EncVisSeq = {VIS_SEQ};\n\n")
+        emit_i64(out, "kH3EncVisCuSeqlens", VIS_CU_SEQLENS)
+        emit_f32(out, "kH3EncVisCos", vcos.reshape(-1))
+        emit_f32(out, "kH3EncVisSin", vsin.reshape(-1))
+        emit_f32(out, "kH3EncVisBlockGolden", vout.reshape(-1))
+
+        out.write(f"inline constexpr int64_t kH3EncTowerDepth = {VIS_DEPTH};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerPatch = {VIS_PATCH};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerTemporalPatch = {VIS_TEMPORAL_PATCH};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerInCh = {VIS_IN_CH};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerMerge = {VIS_MERGE};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerOutHidden = {VIS_OUT_HIDDEN};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerNumPos = {VIS_NUM_POS};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerPatches = {int(total_patches)};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerMergedRows = {int(merged.shape[0])};\n")
+        out.write(f"inline constexpr int64_t kH3EncTowerDeepstackCount = {len(deepstack_feats)};\n\n")
+        emit_i64(out, "kH3EncTowerGridThw", [v for row in VIS_GRID_THW for v in row])
+        emit_i64(out, "kH3EncTowerDeepstackIdx", VIS_DEEPSTACK_IDX)
+        emit_f32(out, "kH3EncTowerMergedGolden", merged.reshape(-1))
+        emit_f32(out, "kH3EncTowerDeepstackGolden", torch.cat([d.reshape(-1) for d in deepstack_feats]))
+        out.write("}  // namespace vllm_test\n")
+    print(f"wrote {args.out}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/gen-minimax-h3-gguf-manifest.py b/scripts/gen-minimax-h3-gguf-manifest.py
new file mode 100644
index 000000000..acacb61ff
--- /dev/null
+++ b/scripts/gen-minimax-h3-gguf-manifest.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Emit tests/vllm/models/minimax_h3_gguf_manifest.inc from a REAL H3 GGUF.
+
+The ComfyUI-format MiniMax-H3 GGUFs (e.g. realrebelai/MiniMax-H3_GGUFs,
+`MiniMax-H3-FL2VA-Q3_K_M.gguf`) are the quantized checkpoints that actually FIT
+this project's hardware. This script reads only the GGUF **header** — the tensor
+names, dims, types, and the `comfy.gguf.orig_shape.*` metadata — and freezes it
+into a C++ fixture, so the loader's name map and shape resolution are gated
+against a real 535-tensor checkpoint without checking in (or even downloading)
+the ~15 GB payload.
+
+The header is self-delimiting and lives at the front of the file, so a range
+request is enough:
+
+    curl -sL -r 0-4194303 -o h3.head \\
+      https://huggingface.co/realrebelai/MiniMax-H3_GGUFs/resolve/main/MiniMax-H3-FL2VA-Q3_K_M.gguf
+    python3 scripts/gen-minimax-h3-gguf-manifest.py h3.head \\
+      > tests/vllm/models/minimax_h3_gguf_manifest.inc
+
+Self-contained: deliberately does NOT use gguf-py, so it runs anywhere the file
+does (same rationale as scripts/gen-gguf-nvfp4-goldens.py).
+"""
+
+import struct
+import sys
+
+(
+    UINT8, INT8, UINT16, INT16, UINT32, INT32, FLOAT32, BOOL, STRING, ARRAY,
+    UINT64, INT64, FLOAT64,
+) = range(13)
+
+FMT = {
+    UINT8: ("<B", 1), INT8: ("<b", 1), UINT16: ("<H", 2), INT16: ("<h", 2),
+    UINT32: ("<I", 4), INT32: ("<i", 4), FLOAT32: ("<f", 4), BOOL: ("<?", 1),
+    UINT64: ("<Q", 8), INT64: ("<q", 8), FLOAT64: ("<d", 8),
+}
+
+# ggml_type ids (ggml.h). Only the ones a MiniMax-H3 GGUF can carry are named;
+# anything else is emitted numerically so the fixture never silently mislabels.
+GGML_TYPE_NAMES = {
+    0: "F32", 1: "F16", 2: "Q4_0", 3: "Q4_1", 6: "Q5_0", 7: "Q5_1", 8: "Q8_0",
+    9: "Q8_1", 10: "Q2_K", 11: "Q3_K", 12: "Q4_K", 13: "Q5_K", 14: "Q6_K",
+    15: "Q8_K", 30: "BF16",
+}
+
+
+class Reader:
+    def __init__(self, fh):
+        self.fh = fh
+
+    def raw(self, n):
+        data = self.fh.read(n)
+        if len(data) != n:
+            raise SystemExit("short read: the header is larger than the fetched prefix")
+        return data
+
+    def u32(self):
+        return struct.unpack("<I", self.raw(4))[0]
+
+    def u64(self):
+        return struct.unpack("<Q", self.raw(8))[0]
+
+    def string(self):
+        return self.raw(self.u64()).decode("utf-8", "replace")
+
+    def value(self, type_id):
+        if type_id in FMT:
+            fmt, size = FMT[type_id]
+            return struct.unpack(fmt, self.raw(size))[0]
+        if type_id == STRING:
+            return self.string()
+        if type_id == ARRAY:
+            elem = self.u32()
+            count = self.u64()
+            return [self.value(elem) for _ in range(count)]
+        raise SystemExit(f"unknown GGUF value type {type_id}")
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        raise SystemExit(f"usage: {sys.argv[0]} <gguf-or-header-prefix>")
+    path = sys.argv[1]
+    with open(path, "rb") as fh:
+        r = Reader(fh)
+        if r.raw(4) != b"GGUF":
+            raise SystemExit("not a GGUF file")
+        version = r.u32()
+        n_tensors = r.u64()
+        n_kv = r.u64()
+
+        kv = {}
+        for _ in range(n_kv):
+            key = r.string()
+            kv[key] = r.value(r.u32())
+
+        tensors = []
+        for _ in range(n_tensors):
+            name = r.string()
+            n_dims = r.u32()
+            dims = [r.u64() for _ in range(n_dims)]
+            type_id = r.u32()
+            r.u64()  # offset — not part of the shape contract
+            tensors.append((name, dims, type_id))
+
+    tensors.sort(key=lambda t: t[0])
+    out = sys.stdout
+    out.write(
+        "// GENERATED by scripts/gen-minimax-h3-gguf-manifest.py — DO NOT EDIT BY HAND.\n"
+        "//\n"
+        "// The tensor manifest of a REAL ComfyUI-format MiniMax-H3 GGUF\n"
+        f"// (GGUF v{version}, {n_tensors} tensors, architecture "
+        f"{kv.get('general.architecture', '?')!r}, file_type "
+        f"{kv.get('general.file_type', '?')}). Names, dims and ggml type ids only —\n"
+        "// no weight bytes. This is what gates the loader's name map and shape\n"
+        "// resolution against a real checkpoint. See .agents/specs/minimax-h3.md.\n"
+        "#pragma once\n\n"
+        "#include <cstdint>\n\n"
+        "namespace vllm_test {\n\n"
+    )
+    out.write(f"inline constexpr int64_t kH3GgufTensorCount = {len(tensors)};\n")
+    out.write(f"inline constexpr int64_t kH3GgufVersion = {version};\n")
+    arch = kv.get("general.architecture", "")
+    out.write(f'inline constexpr const char* kH3GgufArchitecture = "{arch}";\n\n')
+
+    out.write("struct H3GgufTensor {\n"
+              "  const char* name;\n"
+              "  int64_t dims[4];   // GGUF ne order (reversed vs torch), 0-padded\n"
+              "  int32_t n_dims;\n"
+              "  uint32_t ggml_type;\n"
+              "  int64_t orig_shape[4];  // comfy.gguf.orig_shape.<name>, 0 if absent\n"
+              "  int32_t orig_n_dims;    // 0 when the key is absent\n"
+              "};\n\n")
+    out.write("inline constexpr H3GgufTensor kH3GgufTensors[] = {\n")
+    for name, dims, type_id in tensors:
+        padded = list(dims) + [0] * (4 - len(dims))
+        orig = kv.get(f"comfy.gguf.orig_shape.{name}")
+        if orig is None:
+            orig_padded, orig_n = [0, 0, 0, 0], 0
+        else:
+            orig_padded = list(int(v) for v in orig) + [0] * (4 - len(orig))
+            orig_n = len(orig)
+        type_name = GGML_TYPE_NAMES.get(type_id, str(type_id))
+        out.write(
+            f'    {{"{name}", {{{", ".join(str(v) for v in padded)}}}, {len(dims)}, '
+            f"{type_id}u, {{{', '.join(str(v) for v in orig_padded)}}}, {orig_n}}},"
+            f"  // {type_name}\n"
+        )
+    out.write("};\n\n")
+    out.write("}  // namespace vllm_test\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/gen-minimax-h3-goldens.py b/scripts/gen-minimax-h3-goldens.py
new file mode 100644
index 000000000..a6bd163cd
--- /dev/null
+++ b/scripts/gen-minimax-h3-goldens.py
@@ -0,0 +1,1155 @@
+#!/usr/bin/env python3
+"""Emit tests/vllm/models/minimax_h3_goldens.inc — the MiniMax-H3 parity oracle.
+
+MiniMax-H3 (`MiniMaxAI/MiniMax-H3`) is a 33.1B omni-modal video+audio diffusion
+transformer whose full checkpoint is ~354 GB and whose validated serving config is
+4x NVIDIA B300. Neither fits this project's hardware, so the H3 port cannot be
+gated end-to-end (see .agents/specs/minimax-h3.md section 0). What CAN be gated
+exactly, on any CPU, is the MATH: this generator runs the upstream vLLM-Omni H3
+modules (and a TP=1 restatement of its DiT) at REDUCED dimensions with
+deterministic pseudo-random weights, and emits the resulting tensors as C++
+goldens. The C++ suite regenerates the identical inputs from the identical PRNG
+and must reproduce these outputs.
+
+Upstream sources (vllm-project/vllm-omni, vllm_omni/diffusion/models/minimax_h3/):
+  packed_sequence.py                       -> section 1 + 2 goldens
+  packed_tokens.py                         -> section 3 goldens
+  scheduling_minimax_h3_euler_ancestral.py -> section 4 goldens
+  minimax_h3_transformer.py                -> section 5 goldens (TP=1 restatement)
+
+The first three are imported and executed VERBATIM (loaded by file path, which
+bypasses the vllm_omni package __init__ and so needs neither vllm nor aenum). Only
+the DiT is restated here, because upstream's module imports the whole vLLM
+tensor-parallel linear stack; at tensor_parallel_size=1 every {Column,Row,QKV,
+MergedColumn}ParallelLinear degenerates to a plain nn.Linear, so the restatement
+below is line-for-line faithful and each class cites the upstream lines it mirrors.
+
+Usage:
+    python3 scripts/gen-minimax-h3-goldens.py \
+        --vllm-omni ~/_git/vllm-omni \
+        --out tests/vllm/models/minimax_h3_goldens.inc
+
+Needs torch + numpy (CPU only).
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import math
+import os
+import sys
+import types
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+# ---------------------------------------------------------------------------
+# Deterministic weight/input stream, mirrored bit-for-bit by the C++ suite
+# (tests/vllm/models/test_minimax_h3_dit.cpp :: H3Rand). A per-tensor FNV-1a seed
+# plus a splitmix64 counter makes every tensor independent of fill ORDER, so the
+# two sides cannot silently drift by reordering their parameter construction.
+# ---------------------------------------------------------------------------
+
+_MASK64 = (1 << 64) - 1
+
+
+def fnv1a64(name: str) -> int:
+    h = 0xCBF29CE484222325
+    for byte in name.encode("utf-8"):
+        h ^= byte
+        h = (h * 0x100000001B3) & _MASK64
+    return h
+
+
+def splitmix64(x: int) -> int:
+    x = (x + 0x9E3779B97F4A7C15) & _MASK64
+    z = x
+    z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & _MASK64
+    z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & _MASK64
+    return z ^ (z >> 31)
+
+
+def h3_rand(name: str, count: int) -> np.ndarray:
+    """`count` values uniform in [-1, 1), reproducible from `name` alone."""
+    seed = fnv1a64(name)
+    out = np.empty(count, dtype=np.float64)
+    for i in range(count):
+        u = splitmix64((seed + i) & _MASK64)
+        # Top 53 bits -> [0, 1), then map to [-1, 1). Both sides use the same
+        # 53-bit mantissa construction so the doubles are bit-identical.
+        unit = (u >> 11) * (2.0**-53)
+        out[i] = unit * 2.0 - 1.0
+    return out
+
+
+def make_param(name: str, shape, scale: float, offset: float = 0.0) -> torch.Tensor:
+    count = int(np.prod(shape)) if shape else 1
+    values = h3_rand(name, count) * scale + offset
+    return torch.from_numpy(values.astype(np.float32)).reshape(shape)
+
+
+# ---------------------------------------------------------------------------
+# Reduced-dimension arch. Every ratio that the port's code paths branch on is
+# preserved: 3 modalities x 6 AdaLN vectors, patch (1,2,2), rot_dim < head_dim,
+# a token refiner shallower than the block stack, and distinct video/audio latent
+# widths. Only the magnitudes shrink.
+#
+# rot_dim = 6 * rope_inv_freq_len must be <= attention_head_dim (upstream:
+# 6*16=96 <= 128; here 6*2=12 <= 16).
+# ---------------------------------------------------------------------------
+
+ARCH = dict(
+    num_layers=2,
+    token_refiner_num_layers=1,
+    hidden_size=64,
+    num_attention_heads=4,
+    attention_head_dim=16,
+    ffn_hidden_size=128,
+    latents_dim=8,
+    audio_latents_dim=6,
+    patch_size=(1, 2, 2),
+    text_dim=24,
+    timestep_input_dim=16,
+    time_embed_hidden_size=64,
+    time_embed_dim=32,
+    rope_inv_freq_len=2,
+    norm_eps=1e-5,
+    qk_norm_eps=1e-5,
+    final_norm_eps=1e-5,
+)
+ARCH["adaln_out_features"] = 18 * ARCH["hidden_size"]
+ARCH["final_adaln_out_features"] = 2 * ARCH["hidden_size"]
+
+MODALITY_NUM = 3  # minimax_h3_transformer.py:106 MINIMAX_H3_ADALN_MODALITY_NUM
+
+
+# ---------------------------------------------------------------------------
+# TP=1 restatement of minimax_h3_transformer.py. Computed in float32 throughout:
+# the C++ gate runs f32 so the comparison isolates the ALGORITHM from bf16
+# rounding order (the production path keeps upstream's bf16 cast points, which are
+# marked in the port and exercised separately).
+# ---------------------------------------------------------------------------
+
+
+def rms_norm(x: torch.Tensor, weight: torch.Tensor, eps: float) -> torch.Tensor:
+    """nn.RMSNorm semantics: fp32 variance reduction (transformer.py:171-175)."""
+    variance = x.to(torch.float32).pow(2).mean(-1, keepdim=True)
+    return (x.to(torch.float32) * torch.rsqrt(variance + eps) * weight).to(x.dtype)
+
+
+def rotate_half(x: torch.Tensor) -> torch.Tensor:
+    """minimax_h3_transformer.py:178-180."""
+    x1, x2 = torch.chunk(x, 2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def rope_freqs(inv_freq: torch.Tensor, img_position_ids: torch.Tensor) -> torch.Tensor:
+    """MiniMaxH3Rope.forward (minimax_h3_transformer.py:222-230).
+
+    img_position_ids [1,S,3] (t,h,w) -> freqs [S, 6*inv_freq_len].
+    """
+    pos = img_position_ids[0].to(torch.float32)
+    per_axis = pos.unsqueeze(-1) * inv_freq.view(1, 1, -1)
+    t_f, h_f, w_f = per_axis.unbind(dim=1)
+    half = torch.cat((t_f, h_f, w_f), dim=-1)
+    return torch.cat((half, half), dim=-1)
+
+
+def apply_rope(x: torch.Tensor, freqs: torch.Tensor) -> torch.Tensor:
+    """_apply_rope (minimax_h3_transformer.py:233-244). x [T,heads,dim]."""
+    rot_dim = freqs.shape[-1]
+    x_rot, x_pass = x[..., :rot_dim], x[..., rot_dim:]
+    cos = torch.cos(freqs).to(x.dtype).unsqueeze(1)
+    sin = torch.sin(freqs).to(x.dtype).unsqueeze(1)
+    x_rot = (x_rot * cos) + (rotate_half(x_rot) * sin)
+    return torch.cat((x_rot, x_pass), dim=-1)
+
+
+def varlen_non_causal_attention(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    v: torch.Tensor,
+    cu_seqlens: torch.Tensor,
+    scale: float,
+) -> torch.Tensor:
+    """_sdpa_varlen_attention (minimax_h3_transformer.py:288-317).
+
+    Bidirectional attention within each packed document. This is exactly the
+    contract of our shared vt::DFlashBlockAttention(causal=false).
+    """
+    out = torch.empty_like(q)
+    bounds = cu_seqlens.tolist()
+    for start, stop in zip(bounds[:-1], bounds[1:]):
+        if stop == start:
+            continue
+        seg_q = q[start:stop].transpose(0, 1).unsqueeze(0)
+        seg_k = k[start:stop].transpose(0, 1).unsqueeze(0)
+        seg_v = v[start:stop].transpose(0, 1).unsqueeze(0)
+        seg = torch.nn.functional.scaled_dot_product_attention(seg_q, seg_k, seg_v, scale=scale)
+        out[start:stop] = seg.squeeze(0).transpose(0, 1)
+    return out
+
+
+def modulate_scale_shift(x, shift, scale, indices):
+    """_modulate_scale_shift (minimax_h3_transformer.py:183-192)."""
+    return x * (1.0 + scale.index_select(0, indices)) + shift.index_select(0, indices)
+
+
+def modulate_gate(x, gate, other, indices):
+    """_modulate_gate (minimax_h3_transformer.py:195-204)."""
+    return x + gate.index_select(0, indices) * other
+
+
+class RefLinear:
+    """A TP=1 {Column,Row,QKV,MergedColumn}ParallelLinear: y = x @ W^T + b."""
+
+    def __init__(self, name: str, out_features: int, in_features: int, bias: bool):
+        self.weight = make_param(f"{name}.weight", (out_features, in_features), 0.05)
+        self.bias = make_param(f"{name}.bias", (out_features,), 0.02) if bias else None
+
+    def __call__(self, x: torch.Tensor) -> torch.Tensor:
+        return torch.nn.functional.linear(x, self.weight, self.bias)
+
+    def as_bf16(self) -> None:
+        self.weight = bf16(self.weight)
+        if self.bias is not None:
+            self.bias = bf16(self.bias)
+
+
+class RefAttention:
+    """MiniMaxH3Attention (minimax_h3_transformer.py:320-467).
+
+    qkv -> per-head q/k RMSNorm -> RoPE -> varlen non-causal attention -> out.
+    """
+
+    def __init__(self, name: str, arch: dict):
+        self.heads = arch["num_attention_heads"]
+        self.head_dim = arch["attention_head_dim"]
+        inner = self.heads * self.head_dim
+        self.scale = self.head_dim**-0.5
+        self.qkv_proj = RefLinear(f"{name}.qkv_proj", 3 * inner, arch["hidden_size"], bias=False)
+        self.q_norm = make_param(f"{name}.q_norm.weight", (self.head_dim,), 0.1, 1.0)
+        self.k_norm = make_param(f"{name}.k_norm.weight", (self.head_dim,), 0.1, 1.0)
+        self.out_proj = RefLinear(f"{name}.out_proj", arch["hidden_size"], inner, bias=False)
+        self.qk_eps = arch["qk_norm_eps"]
+
+    def __call__(self, x, freqs, cu_seqlens):
+        total = x.shape[0]
+        qkv = self.qkv_proj(x)
+        size = self.heads * self.head_dim
+        q, k, v = qkv.split([size, size, size], dim=-1)
+        q = q.view(total, self.heads, self.head_dim)
+        k = k.view(total, self.heads, self.head_dim)
+        v = v.view(total, self.heads, self.head_dim)
+        q = rms_norm(q, self.q_norm, self.qk_eps)
+        k = rms_norm(k, self.k_norm, self.qk_eps)
+        if freqs is not None:
+            q = apply_rope(q, freqs)
+            k = apply_rope(k, freqs)
+        out = varlen_non_causal_attention(q, k, v, cu_seqlens, self.scale)
+        return self.out_proj(out.reshape(total, size))
+
+
+class RefMLP:
+    """MiniMaxH3MLP (minimax_h3_transformer.py:470-517): silu(gate) * up."""
+
+    def __init__(self, name: str, arch: dict):
+        ffn = arch["ffn_hidden_size"]
+        self.fc1 = RefLinear(f"{name}.fc1", 2 * ffn, arch["hidden_size"], bias=False)
+        self.fc2 = RefLinear(f"{name}.fc2", arch["hidden_size"], ffn, bias=False)
+
+    def __call__(self, x):
+        hidden = self.fc1(x)
+        gate, up = hidden.chunk(2, dim=-1)
+        return self.fc2(torch.nn.functional.silu(gate) * up)
+
+
+class RefAdalnProj:
+    """MiniMaxH3AdalnProj (minimax_h3_transformer.py:520-561).
+
+    [M, t_dim] -> silu -> linear -> view(M*modality_num, expand*H) -> chunk.
+    """
+
+    def __init__(self, name: str, arch: dict, out_features: int, expand_ratio: int, modality_num: int):
+        assert out_features == expand_ratio * arch["hidden_size"] * modality_num
+        self.linear = RefLinear(f"{name}.linear", out_features, arch["time_embed_dim"], bias=True)
+        self.expand_ratio = expand_ratio
+        self.modality_num = modality_num
+        self.hidden_size = arch["hidden_size"]
+
+    def __call__(self, t_emb):
+        x = torch.nn.functional.silu(t_emb)
+        x = self.linear(x)
+        m = x.shape[0]
+        x = x.view(m * self.modality_num, self.expand_ratio * self.hidden_size)
+        return tuple(x.chunk(self.expand_ratio, dim=-1))
+
+
+def bf16(x: torch.Tensor) -> torch.Tensor:
+    """Round through bfloat16 and come back to f32.
+
+    The production H3 stream is bf16 with specific fp32 islands
+    (minimax_h3_transformer.py:85-101 for the params, and the explicit
+    `dtype=_BF16_DTYPE` casts in `_modulate_*`). Rounding in place rather than
+    switching tensor dtypes keeps the reference and the C++ port comparing the
+    SAME cast points instead of two different accumulation strategies.
+    """
+    return x.to(torch.bfloat16).to(torch.float32)
+
+
+class RefDiT:
+    """MiniMaxH3DiTModel (minimax_h3_transformer.py:765-1102) at TP=1.
+
+    `bf16_stream=True` reproduces the production dtype policy: every activation
+    that upstream materializes in bf16 is rounded to bf16, while the fp32 islands
+    (patch projections, time embedder, both output heads) stay fp32.
+    """
+
+    def __init__(self, arch: dict, bf16_stream: bool = False):
+        self.arch = arch
+        self.bf16_stream = bf16_stream
+        h = arch["hidden_size"]
+        pt, ph, pw = arch["patch_size"]
+        self.video_patch_dim = arch["latents_dim"] * pt * ph * pw
+        self.video_patch_proj = RefLinear("video_patch_proj", h, self.video_patch_dim, bias=True)
+        self.audio_patch_proj = RefLinear("audio_patch_proj", h, arch["audio_latents_dim"], bias=True)
+        self.condition_proj = RefLinear("condition_proj", h, arch["text_dim"], bias=True)
+        self.time_proj_in = RefLinear(
+            "time_embedder.proj_in", arch["time_embed_hidden_size"], arch["timestep_input_dim"], bias=True
+        )
+        self.time_proj_out = RefLinear(
+            "time_embedder.proj_out", arch["time_embed_dim"], arch["time_embed_hidden_size"], bias=True
+        )
+        # inv_freq = base^-(arange(0, 2L, 2)/(2L)) (minimax_h3_transformer.py:207-212)
+        length = arch["rope_inv_freq_len"]
+        self.inv_freq = torch.tensor(
+            [10000.0 ** (-(2.0 * i) / (2.0 * length)) for i in range(length)], dtype=torch.float32
+        )
+        self.refiner = []
+        for i in range(arch["token_refiner_num_layers"]):
+            self.refiner.append(
+                dict(
+                    norm1=make_param(f"token_refiner.blocks.{i}.norm1.weight", (h,), 0.1, 1.0),
+                    norm2=make_param(f"token_refiner.blocks.{i}.norm2.weight", (h,), 0.1, 1.0),
+                    attn=RefAttention(f"token_refiner.blocks.{i}.attn", arch),
+                    mlp=RefMLP(f"token_refiner.blocks.{i}.mlp", arch),
+                )
+            )
+        self.refiner_final_norm = make_param("token_refiner.final_norm.weight", (h,), 0.1, 1.0)
+        self.blocks = []
+        for i in range(arch["num_layers"]):
+            self.blocks.append(
+                dict(
+                    norm1=make_param(f"blocks.{i}.norm1.weight", (h,), 0.1, 1.0),
+                    norm2=make_param(f"blocks.{i}.norm2.weight", (h,), 0.1, 1.0),
+                    attn=RefAttention(f"blocks.{i}.attn", arch),
+                    mlp=RefMLP(f"blocks.{i}.mlp", arch),
+                    adaln=RefAdalnProj(
+                        f"blocks.{i}.adaln_proj", arch, arch["adaln_out_features"], 6, MODALITY_NUM
+                    ),
+                )
+            )
+        self.final_norm = make_param("final_layer.norm.weight", (h,), 0.1, 1.0)
+        self.final_adaln = RefAdalnProj(
+            "final_layer.adaln_proj", arch, arch["final_adaln_out_features"], 2, 1
+        )
+        self.video_out = RefLinear("final_layer.video_out", self.video_patch_dim, h, bias=True)
+        self.audio_out = RefLinear("final_layer.audio_out", arch["audio_latents_dim"], h, bias=True)
+
+    def to_bf16_weights(self) -> None:
+        """Round every BF16-STORED parameter; the fp32 islands stay fp32.
+
+        The fp32 islands are exactly MINIMAX_H3_FP32_PARAM_NAMES +
+        MINIMAX_H3_FP32_BUFFER_NAMES (minimax_h3_transformer.py:85-101): both
+        patch projections, both time-embedder projections, both output heads, and
+        rope.inv_freq.
+        """
+        self.condition_proj.as_bf16()
+        for group in (self.refiner, self.blocks):
+            for block in group:
+                block["norm1"] = bf16(block["norm1"])
+                block["norm2"] = bf16(block["norm2"])
+                block["attn"].qkv_proj.as_bf16()
+                block["attn"].out_proj.as_bf16()
+                block["attn"].q_norm = bf16(block["attn"].q_norm)
+                block["attn"].k_norm = bf16(block["attn"].k_norm)
+                block["mlp"].fc1.as_bf16()
+                block["mlp"].fc2.as_bf16()
+                if "adaln" in block:
+                    block["adaln"].linear.as_bf16()
+        self.refiner_final_norm = bf16(self.refiner_final_norm)
+        self.final_norm = bf16(self.final_norm)
+        self.final_adaln.linear.as_bf16()
+
+    def q(self, x: torch.Tensor) -> torch.Tensor:
+        """Round to the block-stream dtype (identity in the fp32 gate)."""
+        return bf16(x) if self.bf16_stream else x
+
+    def qw(self, w: torch.Tensor) -> torch.Tensor:
+        """Round a BF16-stored weight; the fp32 islands never go through this."""
+        return bf16(w) if self.bf16_stream else w
+
+    def time_embed(self, t: torch.Tensor) -> torch.Tensor:
+        """MiniMaxH3TimeEmbedder.forward (minimax_h3_transformer.py:272-285).
+
+        Sinusoidal embedding stays fp32 and concatenates COSINE before SINE.
+        """
+        half = self.arch["timestep_input_dim"] // 2
+        freqs = torch.exp(-math.log(10000.0) * torch.arange(half, dtype=torch.float32) / half)
+        args = t.to(torch.float32)[:, None] * freqs[None]
+        t_freq = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        return self.time_proj_out(torch.nn.functional.silu(self.time_proj_in(t_freq)))
+
+    def __call__(
+        self,
+        *,
+        x,
+        audio_x,
+        img_position_ids,
+        unique_timesteps,
+        inverse_indices,
+        update_mask,
+        token_tags,
+        prompt_embeds,
+        img_pos,
+        audio_pos,
+        text_pos,
+        infer_out_pos,
+        cu_seqlens,
+        refiner_cu_seqlens,
+    ):
+        seq_len = int(x.shape[1])
+        freqs = rope_freqs(self.inv_freq, img_position_ids)
+
+        # _embed (minimax_h3_transformer.py:944-984). The two patch projections
+        # are fp32 islands; their outputs are cast to the bf16 sequence dtype only
+        # during the indexed scatter.
+        video_embed = self.video_patch_proj(x.view(-1, x.shape[-1]).index_select(0, img_pos))
+        audio_embed = self.audio_patch_proj(audio_x.view(-1, audio_x.shape[-1]).index_select(0, audio_pos))
+        text_embed = self.q(self.condition_proj(self.q(prompt_embeds)))
+        for block in self.refiner:
+            text_embed = self.q(text_embed + block["attn"](
+                self.q(rms_norm(text_embed, block["norm1"], self.arch["norm_eps"])),
+                None,
+                refiner_cu_seqlens,
+            ))
+            text_embed = self.q(text_embed + block["mlp"](
+                self.q(rms_norm(text_embed, block["norm2"], self.arch["norm_eps"]))
+            ))
+        text_embed = self.q(rms_norm(text_embed, self.refiner_final_norm, self.arch["final_norm_eps"]))
+
+        embeddings = torch.zeros((seq_len, self.arch["hidden_size"]), dtype=torch.float32)
+        embeddings.index_add_(0, text_pos, self.q(text_embed)[: text_pos.shape[0]])
+        embeddings.index_add_(0, img_pos, self.q(video_embed)[: img_pos.shape[0]])
+        embeddings.index_add_(0, audio_pos, self.q(audio_embed)[: audio_pos.shape[0]])
+
+        t_emb = self.time_embed(unique_timesteps)
+        combined = inverse_indices * MODALITY_NUM + token_tags.clamp(min=0)
+
+        hidden = embeddings
+        for block in self.blocks:
+            # AdaLN parameters are produced by a BF16 linear over the fp32 t_emb.
+            shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = [
+                self.q(v) for v in block["adaln"](t_emb)
+            ]
+            residual = hidden
+            h = self.q(rms_norm(hidden, block["norm1"], self.arch["norm_eps"]))
+            h = self.q(modulate_scale_shift(h, shift_msa, scale_msa, combined))
+            h = self.q(block["attn"](h, freqs, cu_seqlens))
+            hidden = self.q(modulate_gate(residual, gate_msa, h, combined))
+
+            residual = hidden
+            h = self.q(rms_norm(hidden, block["norm2"], self.arch["norm_eps"]))
+            h = self.q(modulate_scale_shift(h, shift_mlp, scale_mlp, combined))
+            h = self.q(block["mlp"](h))
+            hidden = self.q(modulate_gate(residual, gate_mlp, h, combined))
+
+        # MiniMaxH3FinalLayer.forward (minimax_h3_transformer.py:724-743)
+        shift, scale = [self.q(v) for v in self.final_adaln(t_emb)]
+        h = self.q(rms_norm(hidden, self.final_norm, self.arch["final_norm_eps"]))
+        h = self.q(modulate_scale_shift(h, shift, scale, inverse_indices))
+        # Both output heads are fp32 islands; the stream is cast up before them.
+        video = self.video_out(h)
+        audio = self.audio_out(h)
+
+        video = video.index_select(0, infer_out_pos)
+        audio = audio.index_select(0, audio_pos)
+        video = video * update_mask.to(torch.float32).unsqueeze(-1)
+        return video, audio
+
+
+# ---------------------------------------------------------------------------
+# Upstream module loading (by path, bypassing the vllm_omni package __init__).
+# ---------------------------------------------------------------------------
+
+
+def load_upstream(root: Path, module: str):
+    """Import one upstream module by path, under a synthetic package.
+
+    A synthetic package is needed because some of these modules use RELATIVE
+    imports (condition_noise imports .packed_tokens); registering the directory
+    as a package's __path__ lets those resolve while still bypassing the real
+    vllm_omni __init__, which would drag in vllm and aenum.
+    """
+    directory = root / "vllm_omni" / "diffusion" / "models" / "minimax_h3"
+    path = directory / f"{module}.py"
+    if not path.is_file():
+        raise SystemExit(f"upstream module not found: {path}")
+    package = "_h3_upstream"
+    if package not in sys.modules:
+        pkg = types.ModuleType(package)
+        pkg.__path__ = [str(directory)]
+        sys.modules[package] = pkg
+    name = f"{package}.{module}"
+    if name in sys.modules:
+        return sys.modules[name]
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+# ---------------------------------------------------------------------------
+# Emission helpers
+# ---------------------------------------------------------------------------
+
+
+def emit_header(out, argv: str) -> None:
+    out.write(
+        "// GENERATED by scripts/gen-minimax-h3-goldens.py — DO NOT EDIT BY HAND.\n"
+        "//\n"
+        "// MiniMax-H3 parity goldens produced by executing the upstream vLLM-Omni\n"
+        "// modules (vllm-project/vllm-omni, vllm_omni/diffusion/models/minimax_h3/)\n"
+        "// at reduced dimensions with the deterministic H3Rand stream. Regenerate with:\n"
+        f"//   {argv}\n"
+        "//\n"
+        "// See .agents/specs/minimax-h3.md section 4 for why this is the gate: the real\n"
+        "// checkpoint is ~354 GB over 4x B300 and cannot run on this project's hardware,\n"
+        "// so the MATH is gated exactly here and the WEIGHTS are gated structurally.\n"
+        "#pragma once\n\n"
+        "#include <cstdint>\n\n"
+        "namespace vllm_test {\n\n"
+    )
+
+
+def emit_i64(out, name: str, values) -> None:
+    flat = [int(v) for v in np.asarray(values).reshape(-1).tolist()]
+    out.write(f"inline constexpr int64_t {name}[] = {{\n")
+    for i in range(0, len(flat), 12):
+        out.write("    " + ", ".join(str(v) for v in flat[i : i + 12]) + ",\n")
+    out.write("};\n\n")
+
+
+def emit_f64(out, name: str, values) -> None:
+    flat = np.asarray(values, dtype=np.float64).reshape(-1).tolist()
+    out.write(f"inline constexpr double {name}[] = {{\n")
+    for i in range(0, len(flat), 6):
+        chunk = ", ".join(_cxx_float(v, 17) for v in flat[i : i + 6])
+        out.write("    " + chunk + ",\n")
+    out.write("};\n\n")
+
+
+def _cxx_float(value: float, digits: int) -> str:
+    """Format as a valid C++ floating literal (`0` alone is an integer literal)."""
+    if not math.isfinite(value):
+        raise ValueError(f"refusing to emit non-finite golden value: {value}")
+    text = f"{value:.{digits}g}"
+    if "." not in text and "e" not in text and "E" not in text:
+        text += ".0"
+    return text
+
+
+def emit_f32(out, name: str, values) -> None:
+    flat = np.asarray(values, dtype=np.float32).reshape(-1).tolist()
+    out.write(f"inline constexpr float {name}[] = {{\n")
+    for i in range(0, len(flat), 6):
+        chunk = ", ".join(_cxx_float(v, 9) + "f" for v in flat[i : i + 6])
+        out.write("    " + chunk + ",\n")
+    out.write("};\n\n")
+
+
+def emit_scalar(out, name: str, value: int) -> None:
+    out.write(f"inline constexpr int64_t {name} = {int(value)};\n")
+
+
+# ---------------------------------------------------------------------------
+# Golden sections
+# ---------------------------------------------------------------------------
+
+# fl2va layout case: one leading keyframe, small latent grid.
+FL2VA = dict(text_len=7, latent_t=3, latent_h=4, latent_w=6, audio_t=5, audio_channel=2)
+# ref2va layout case: an image reference block plus a video+audio reference block.
+REF2VA = dict(text_len=5, latent_t=2, latent_h=4, latent_w=4, audio_t=3, audio_channel=2)
+
+
+def emit_packed_sequence(out, packed_sequence) -> None:
+    out.write("// --- section 1: minimax_h3_packed_sequence (fl2va, one leading keyframe) ---\n")
+    result = packed_sequence.minimax_h3_packed_sequence(
+        text_len=FL2VA["text_len"],
+        latent_t=FL2VA["latent_t"],
+        latent_h=FL2VA["latent_h"],
+        latent_w=FL2VA["latent_w"],
+        audio_t=FL2VA["audio_t"],
+        audio_channel=FL2VA["audio_channel"],
+        include_keyframe_cond=True,
+        keyframe_frame_indices=(0,),
+        frame_count=9,
+    )
+    for key, value in FL2VA.items():
+        emit_scalar(out, f"kH3Fl2va_{key}", value)
+    emit_scalar(out, "kH3Fl2va_frame_count", 9)
+    emit_scalar(out, "kH3Fl2va_seq_len", int(result["seq_len"]))
+    out.write("\n")
+    emit_i64(out, "kH3Fl2vaInputIds", result["input_ids"])
+    emit_i64(out, "kH3Fl2vaTokenTags", result["token_tags"])
+    emit_i64(out, "kH3Fl2vaImgPos", result["img_pos"])
+    emit_i64(out, "kH3Fl2vaAudioPos", result["audio_pos"])
+    emit_i64(out, "kH3Fl2vaTextPos", result["text_pos"])
+    emit_i64(out, "kH3Fl2vaUpdateMask", result["update_mask"].to(torch.int64))
+    emit_i64(out, "kH3Fl2vaCuSeqlens", result["cu_seqlens"].to(torch.int64))
+    emit_i64(out, "kH3Fl2vaDocumentId", result["document_id"].to(torch.int64))
+    # fp64 grid: the position ids are the one place where a last-ulp drift would
+    # silently change RoPE, so they are gated as exact doubles.
+    emit_f64(out, "kH3Fl2vaImgPositionIds", result["img_position_ids"])
+
+    out.write("// --- section 2: minimax_h3_packed_sequence_ref2va_blocks ---\n")
+    ref_blocks = [
+        {"kind": "image", "latent_h": 4, "latent_w": 4},
+        {"kind": "video_audio", "ref_audio_t": 2, "latent_t": 2, "latent_h": 4, "latent_w": 4},
+    ]
+    ref = packed_sequence.minimax_h3_packed_sequence_ref2va_blocks(
+        text_len=REF2VA["text_len"],
+        latent_t=REF2VA["latent_t"],
+        latent_h=REF2VA["latent_h"],
+        latent_w=REF2VA["latent_w"],
+        audio_t=REF2VA["audio_t"],
+        ref_blocks=ref_blocks,
+        audio_channel=REF2VA["audio_channel"],
+    )
+    for key, value in REF2VA.items():
+        emit_scalar(out, f"kH3Ref2va_{key}", value)
+    emit_scalar(out, "kH3Ref2va_seq_len", int(ref["seq_len"]))
+    out.write("\n")
+    emit_i64(out, "kH3Ref2vaInputIds", ref["input_ids"])
+    emit_i64(out, "kH3Ref2vaTokenTags", ref["token_tags"])
+    emit_i64(out, "kH3Ref2vaImgPos", ref["img_pos"])
+    emit_i64(out, "kH3Ref2vaAudioPos", ref["audio_pos"])
+    emit_i64(out, "kH3Ref2vaUpdateMask", ref["update_mask"].to(torch.int64))
+    emit_i64(out, "kH3Ref2vaAudioUpdateMask", ref["audio_update_mask"].to(torch.int64))
+    emit_i64(out, "kH3Ref2vaCuSeqlens", ref["cu_seqlens"].to(torch.int64))
+    emit_f64(out, "kH3Ref2vaImgPositionIds", ref["img_position_ids"])
+    return result
+
+
+def emit_packing(out, packed_tokens) -> None:
+    out.write("// --- section 3: packed_tokens patchify / unpatchify / audio pack ---\n")
+    latent_shape = (1, 5, 2, 4, 6)  # [B,C,T,H,W]
+    latent = torch.from_numpy(
+        h3_rand("packing.video_latent", int(np.prod(latent_shape))).astype(np.float32)
+    ).reshape(latent_shape)
+    rows = packed_tokens.minimax_h3_patchify_video_latent(latent, patch_size=(1, 2, 2))
+    emit_scalar(out, "kH3PatchifyC", latent_shape[1])
+    emit_scalar(out, "kH3PatchifyT", latent_shape[2])
+    emit_scalar(out, "kH3PatchifyH", latent_shape[3])
+    emit_scalar(out, "kH3PatchifyW", latent_shape[4])
+    emit_scalar(out, "kH3PatchifyRows", int(rows.shape[0]))
+    emit_scalar(out, "kH3PatchifyRowWidth", int(rows.shape[1]))
+    out.write("\n")
+    emit_f32(out, "kH3PatchifyRowsGolden", rows)
+
+    audio_shape = (2, 6, 4)  # [audio_channel, latent_dim, T]
+    audio = torch.from_numpy(
+        h3_rand("packing.audio_latent", int(np.prod(audio_shape))).astype(np.float32)
+    ).reshape(audio_shape)
+    audio_rows = packed_tokens.minimax_h3_pack_audio_latent(audio)
+    emit_scalar(out, "kH3AudioPackChannels", audio_shape[0])
+    emit_scalar(out, "kH3AudioPackDim", audio_shape[1])
+    emit_scalar(out, "kH3AudioPackT", audio_shape[2])
+    out.write("\n")
+    emit_f32(out, "kH3AudioPackRowsGolden", audio_rows)
+
+
+def emit_scheduler(out, scheduling) -> None:
+    out.write("// --- section 4: euler-ancestral eta0 scheduler ---\n")
+    n = 24
+    xt = torch.from_numpy(h3_rand("sched.xt", n).astype(np.float32))
+    v = torch.from_numpy(h3_rand("sched.v", n).astype(np.float32))
+    # A representative flow-matching sweep: t near 1 (start), mid, and near 0 (end).
+    timesteps = [0.02, 0.5, 0.97]
+    x0_all = []
+    step_all = []
+    for t_value in timesteps:
+        timestep = torch.tensor(t_value, dtype=torch.float32)
+        x0 = scheduling.minimax_h3_rf_v_to_x0(xt, v, timestep)
+        sigma_curr = 1.0 - t_value
+        sigma_next = sigma_curr * 0.5
+        stepped = scheduling.minimax_h3_euler_eta0_step(
+            xt, x0, sigma_curr=sigma_curr, sigma_next=sigma_next
+        )
+        x0_all.append(x0)
+        step_all.append(stepped)
+    emit_scalar(out, "kH3SchedN", n)
+    emit_scalar(out, "kH3SchedSteps", len(timesteps))
+    out.write("\n")
+    emit_f32(out, "kH3SchedTimesteps", np.asarray(timesteps, dtype=np.float32))
+    emit_f32(out, "kH3SchedX0Golden", torch.cat(x0_all))
+    emit_f32(out, "kH3SchedStepGolden", torch.cat(step_all))
+
+
+def emit_dit(out, packed) -> None:
+    out.write("// --- section 5: MiniMaxH3DiTModel forward (reduced dims, fp32) ---\n")
+    torch.manual_seed(0)
+    arch = ARCH
+    model = RefDiT(arch)
+
+    seq_len = int(packed["seq_len"])
+    img_pos = packed["img_pos"].to(torch.long)
+    audio_pos = packed["audio_pos"].to(torch.long)
+    text_pos = packed["text_pos"].to(torch.long)
+    token_tags = packed["token_tags"].to(torch.long)
+    update_mask = packed["update_mask"].to(torch.bool)
+    cu_seqlens = packed["cu_seqlens"].to(torch.int64)
+    img_position_ids = packed["img_position_ids"].to(torch.float32)[None]
+
+    video_width = arch["latents_dim"] * int(np.prod(arch["patch_size"]))
+    x = torch.zeros(1, seq_len, video_width, dtype=torch.float32)
+    x[0].index_copy_(
+        0,
+        img_pos,
+        torch.from_numpy(
+            h3_rand("dit.video_rows", img_pos.shape[0] * video_width).astype(np.float32)
+        ).reshape(img_pos.shape[0], video_width),
+    )
+    audio_x = torch.zeros(1, seq_len, arch["audio_latents_dim"], dtype=torch.float32)
+    audio_x[0].index_copy_(
+        0,
+        audio_pos,
+        torch.from_numpy(
+            h3_rand("dit.audio_rows", audio_pos.shape[0] * arch["audio_latents_dim"]).astype(np.float32)
+        ).reshape(audio_pos.shape[0], arch["audio_latents_dim"]),
+    )
+    prompt_embeds = torch.from_numpy(
+        h3_rand("dit.prompt_embeds", text_pos.shape[0] * arch["text_dim"]).astype(np.float32)
+    ).reshape(text_pos.shape[0], arch["text_dim"])
+
+    # Timestep layout mirrors MiniMaxH3DenoiseBranch.forward_kwargs
+    # (denoise_loop.py:91-126): target rows at t_video, pinned condition rows at
+    # the imgvid anchor, audio rows at t_audio, everything else at t_video.
+    t_video, t_audio, cond_t = 0.4, 0.35, 0.999
+    timesteps = torch.full((seq_len,), t_video, dtype=torch.float32)
+    timesteps[img_pos[update_mask]] = t_video
+    timesteps[img_pos[~update_mask]] = cond_t
+    timesteps[audio_pos] = t_audio
+    unique_timesteps, inverse_indices = torch.unique(timesteps, sorted=True, return_inverse=True)
+
+    refiner_cu = torch.tensor([0, text_pos.shape[0], text_pos.shape[0]], dtype=torch.int64)
+
+    video_logits, audio_logits = model(
+        x=x,
+        audio_x=audio_x,
+        img_position_ids=img_position_ids,
+        unique_timesteps=unique_timesteps,
+        inverse_indices=inverse_indices,
+        update_mask=update_mask,
+        token_tags=token_tags,
+        prompt_embeds=prompt_embeds,
+        img_pos=img_pos,
+        audio_pos=audio_pos,
+        text_pos=text_pos,
+        infer_out_pos=img_pos,
+        cu_seqlens=cu_seqlens,
+        refiner_cu_seqlens=refiner_cu,
+    )
+
+    for key in (
+        "num_layers",
+        "token_refiner_num_layers",
+        "hidden_size",
+        "num_attention_heads",
+        "attention_head_dim",
+        "ffn_hidden_size",
+        "latents_dim",
+        "audio_latents_dim",
+        "text_dim",
+        "timestep_input_dim",
+        "time_embed_hidden_size",
+        "time_embed_dim",
+        "rope_inv_freq_len",
+    ):
+        emit_scalar(out, f"kH3Dit_{key}", arch[key])
+    emit_scalar(out, "kH3Dit_video_row_width", video_width)
+    emit_scalar(out, "kH3Dit_unique_timesteps", int(unique_timesteps.shape[0]))
+    out.write("\n")
+    emit_f32(out, "kH3DitUniqueTimesteps", unique_timesteps)
+    emit_i64(out, "kH3DitInverseIndices", inverse_indices)
+    emit_f32(out, "kH3DitVideoLogitsGolden", video_logits)
+    emit_f32(out, "kH3DitAudioLogitsGolden", audio_logits)
+
+    # The PRODUCTION dtype policy: bf16 activation stream with fp32 islands.
+    bf16_model = RefDiT(arch, bf16_stream=True)
+    bf16_model.to_bf16_weights()
+    bf16_video, bf16_audio = bf16_model(
+        x=x,
+        audio_x=audio_x,
+        img_position_ids=img_position_ids,
+        unique_timesteps=unique_timesteps,
+        inverse_indices=inverse_indices,
+        update_mask=update_mask,
+        token_tags=token_tags,
+        prompt_embeds=prompt_embeds,
+        img_pos=img_pos,
+        audio_pos=audio_pos,
+        text_pos=text_pos,
+        infer_out_pos=img_pos,
+        cu_seqlens=cu_seqlens,
+        refiner_cu_seqlens=refiner_cu,
+    )
+    emit_f32(out, "kH3DitVideoLogitsBf16Golden", bf16_video)
+    emit_f32(out, "kH3DitAudioLogitsBf16Golden", bf16_audio)
+    # A handful of H3Rand probes so the C++ side can prove its PRNG matches before
+    # it ever blames the model math for a mismatch.
+    emit_f64(out, "kH3RandProbe", h3_rand("h3.probe", 8))
+
+
+def emit_condition_noise(out, condition_noise, packed_tokens) -> None:
+    """Section 7: condition-noise augmentation (condition_noise.py, VERBATIM).
+
+    The MIX is `t*clean + (1-t)*noise`; what is easy to get wrong is the ROW
+    ACCOUNTING around it -- each visual condition draws noise of length
+    `target_latent_t + imgvid_cond_num_frames`, slices the PREFIX matching its own
+    latent_t, patchifies, and advances a row cursor. The NOISE ITSELF is emitted
+    here and fed to the C++ side, so this gates the accounting and the mix while
+    torch's RNG stays a separately-tracked open item (the pipeline takes noise as
+    an input for the same reason).
+    """
+    out.write("// --- section 7: condition-noise augmentation ---\n")
+    target_latent_t = 3
+    imgvid_cond_num_frames = 1
+    shapes = [(1, 4, 6), (2, 4, 6)]
+    noise_aug = 0.999
+    seed = 1234
+
+    rows_per = [t * (h // 2) * (w // 2) for t, h, w in shapes]
+    total_rows = sum(rows_per)
+    clean = torch.from_numpy(
+        h3_rand("cond.clean_video", total_rows * 96).astype(np.float32)
+    ).reshape(total_rows, 96)
+
+    # Reproduce the per-condition draw so the SAME noise can be handed to C++.
+    noise_rows_all = []
+    for latent_t, latent_h, latent_w in shapes:
+        full_t = target_latent_t + imgvid_cond_num_frames
+        generator = torch.Generator(device="cpu").manual_seed(seed)
+        noise = torch.randn(1, 24, full_t, latent_h, latent_w, generator=generator,
+                            dtype=torch.float32, device="cpu")[:, :, :latent_t]
+        noise_rows_all.append(packed_tokens.minimax_h3_patchify_video_latent(noise, patch_size=[1, 2, 2]))
+    noise_cat = torch.cat(noise_rows_all, dim=0)
+
+    got = condition_noise.minimax_h3_imgvid_cond_noise_aug_rows(
+        clean, condition_shapes=shapes, target_latent_t=target_latent_t,
+        imgvid_cond_num_frames=imgvid_cond_num_frames, seed=seed, noise_aug=noise_aug,
+    )
+
+    audio_t_list = [2, 3]
+    audio_rows_total = 2 * sum(audio_t_list)
+    clean_audio = torch.from_numpy(
+        h3_rand("cond.clean_audio", audio_rows_total * 32).astype(np.float32)
+    ).reshape(audio_rows_total, 32)
+    audio_noise_parts = []
+    for audio_t in audio_t_list:
+        generator = torch.Generator(device="cpu").manual_seed(seed + 1)
+        audio_noise_parts.append(torch.randn((2 * audio_t, 32), generator=generator,
+                                             dtype=torch.float32, device="cpu"))
+    audio_noise = torch.cat(audio_noise_parts, dim=0)
+    got_audio = condition_noise.minimax_h3_audio_cond_noise_aug_rows(
+        clean_audio, condition_audio_t=audio_t_list, seed=seed, noise_aug=noise_aug,
+    )
+
+    emit_scalar(out, "kH3CondTargetLatentT", target_latent_t)
+    emit_scalar(out, "kH3CondImgvidFrames", imgvid_cond_num_frames)
+    emit_scalar(out, "kH3CondShapeCount", len(shapes))
+    emit_scalar(out, "kH3CondRows", total_rows)
+    emit_scalar(out, "kH3CondAudioCount", len(audio_t_list))
+    emit_scalar(out, "kH3CondAudioRows", audio_rows_total)
+    out.write("\n")
+    emit_f64(out, "kH3CondNoiseAug", [noise_aug])
+    emit_i64(out, "kH3CondShapes", [v for sh in shapes for v in sh])
+    emit_i64(out, "kH3CondAudioT", audio_t_list)
+    emit_f32(out, "kH3CondNoiseRows", noise_cat)
+    emit_f32(out, "kH3CondGolden", got)
+    emit_f32(out, "kH3CondAudioNoiseRows", audio_noise)
+    emit_f32(out, "kH3CondAudioGolden", got_audio)
+
+
+def emit_reference_video(out) -> None:
+    """Section 8: the PURE-MATH half of reference_video.py.
+
+    That module is mostly ffmpeg/soundfile plumbing (probe, transcode, decode),
+    which is blocked on the same external-dependency decision as MP4 muxing. Two
+    pieces are pure arithmetic and are ported and gated here: the reference-video
+    CANVAS geometry (aspect clamp -> 768 short edge -> max-pixel rescale -> nearest
+    multiple of 32) and the FRAME SCHEDULE (24 FPS resampled to the 2 FPS Qwen
+    video sampling rate, then block timestamps averaged over the temporal patch).
+    Restated here from reference_video.py:24-27, 84-103, 201-260 -- importing the
+    module would require ffmpeg on the path.
+    """
+    out.write("// --- section 8: reference-video geometry + frame schedule ---\n")
+
+    fps, sample_fps, temporal_patch = 24.0, 2.0, 2
+    base_short_edge, max_pixels, canvas_multiple = 768, 768 * 1344, 32
+
+    def nearest_multiple(value, multiple):
+        return max(multiple, int(round(float(value) / multiple)) * multiple)
+
+    def reference_video_shape(width, height):
+        ratio = float(width) / float(height)
+        assert 0.25 <= ratio <= 4.0
+        if ratio >= 1.0:
+            tw, th = base_short_edge * ratio, float(base_short_edge)
+        else:
+            tw, th = float(base_short_edge), base_short_edge / ratio
+        area = tw * th
+        if area > max_pixels:
+            scale = math.sqrt(max_pixels / area)
+            tw *= scale
+            th *= scale
+        return nearest_multiple(tw, canvas_multiple), nearest_multiple(th, canvas_multiple)
+
+    shape_cases = [(1920, 1080), (1080, 1920), (1000, 1000), (3840, 1080), (800, 600)]
+    shape_out = []
+    for w, h in shape_cases:
+        sw, sh = reference_video_shape(w, h)
+        shape_out.extend([sw, sh])
+
+    def frame_schedule(frame_count):
+        ratio = fps / sample_fps
+        indices, cursor = [], 0.0
+        while True:
+            frame_index = int(round(cursor))
+            if frame_index >= frame_count:
+                break
+            if not indices or frame_index > indices[-1]:
+                indices.append(frame_index)
+            cursor += ratio
+        timestamps = [i / sample_fps for i in range(len(indices))]
+        timestamps += [timestamps[-1]] * ((-len(timestamps)) % temporal_patch)
+        blocks = [
+            (timestamps[i] + timestamps[i + temporal_patch - 1]) / 2
+            for i in range(0, len(timestamps), temporal_patch)
+        ]
+        return indices, blocks
+
+    frame_cases = [13, 25, 100, 209]
+    idx_flat, idx_lens, blk_flat, blk_lens = [], [], [], []
+    for count in frame_cases:
+        indices, blocks = frame_schedule(count)
+        idx_lens.append(len(indices))
+        blk_lens.append(len(blocks))
+        idx_flat.extend(indices)
+        blk_flat.extend(blocks)
+
+    emit_scalar(out, "kH3RefVidShapeCases", len(shape_cases))
+    emit_scalar(out, "kH3RefVidFrameCases", len(frame_cases))
+    out.write("\n")
+    emit_i64(out, "kH3RefVidShapeInputs", [v for c in shape_cases for v in c])
+    emit_i64(out, "kH3RefVidShapeGolden", shape_out)
+    emit_i64(out, "kH3RefVidFrameCounts", frame_cases)
+    emit_i64(out, "kH3RefVidIndexLens", idx_lens)
+    emit_i64(out, "kH3RefVidIndicesGolden", idx_flat)
+    emit_i64(out, "kH3RefVidBlockLens", blk_lens)
+    emit_f64(out, "kH3RefVidBlockTimestamps", blk_flat)
+
+
+def emit_presentation(out, presentation) -> None:
+    """Section 9: presentation TOKEN TAGS (presentation.py, VERBATIM).
+
+    The prompt presentation interleaves text spans with vision blocks, and the
+    AdaLN token tags must line up with it: TEXT(1) for text, VIDEO(0) for the whole
+    vision block INCLUDING its <|vision_start|>/<|vision_end|> markers. That is the
+    fl2va "vision-span override" the denoise loop requires callers to have applied.
+
+    A stub tokenizer is used because only the LENGTHS matter for tags -- it returns
+    one id per character, which makes each span length exact and predictable.
+    """
+    out.write("// --- section 9: presentation token tags ---\n")
+
+    class _StubTokenizer:
+        def __call__(self, text, add_special_tokens=False):
+            return {"input_ids": [ord(c) for c in text]}
+
+        def convert_tokens_to_ids(self, token):
+            return 900000 + len(token)
+
+    tokenizer = _StubTokenizer()
+    prompt = "a cat"
+    image_token_counts = [3, 5]
+    tags = presentation.minimax_h3_multi_image_presentation_token_tags(
+        tokenizer, prompt=prompt, image_token_counts=image_token_counts
+    )
+    ids = presentation.minimax_h3_multi_image_presentation_ids(
+        tokenizer, prompt=prompt, image_token_counts=image_token_counts
+    )
+    assert len(ids) == len(tags)
+
+    # The span layout the C++ side reconstructs: label text, vision block, ... prompt.
+    spans = []
+    for index, count in enumerate(image_token_counts, start=1):
+        spans.append((1, len(f"<Picture {index}>: ")))   # TEXT
+        spans.append((0, int(count) + 2))                 # VISION (+start/+end)
+    spans.append((1, len(prompt)))                        # TEXT
+
+    emit_scalar(out, "kH3PresSpanCount", len(spans))
+    emit_scalar(out, "kH3PresTagCount", int(tags.numel()))
+    out.write("\n")
+    emit_i64(out, "kH3PresSpanKinds", [k for k, _ in spans])
+    emit_i64(out, "kH3PresSpanLens", [n for _, n in spans])
+    emit_i64(out, "kH3PresTagsGolden", tags)
+
+
+def emit_planner(out, time_request) -> None:
+    """Section 6: request planning (time_request.py executed VERBATIM).
+
+    `_align_multiple` / `_reference_image_shape` / `_resolve_shape` live in
+    pipeline_minimax_h3.py, which imports the whole vLLM-Omni diffusion stack, so
+    those three are restated here (they are five lines each) exactly as
+    pipeline_minimax_h3.py:121-122, 207-222 and 393-434 define them.
+    """
+    out.write("// --- section 6: request planning (time_request.py + shape resolution) ---\n")
+
+    frame_inputs = [1, 4, 5, 6, 17, 22, 23, 39, 40, 100, 124, 209, 210, 512]
+    aligned = [time_request.minimax_h3_align_frame_count(v) for v in frame_inputs]
+    latent_t = [time_request._video_latent_t(v) for v in aligned]
+    back = [time_request._frame_count_from_video_latent_t(v) for v in latent_t]
+    audio_t = [time_request._audio_latent_t(v / 24.0) for v in aligned]
+    emit_scalar(out, "kH3PlanFrameCases", len(frame_inputs))
+    out.write("\n")
+    emit_i64(out, "kH3PlanFrameInputs", frame_inputs)
+    emit_i64(out, "kH3PlanFrameAligned", aligned)
+    emit_i64(out, "kH3PlanVideoLatentT", latent_t)
+    emit_i64(out, "kH3PlanFrameFromLatentT", back)
+    emit_i64(out, "kH3PlanAudioLatentT", audio_t)
+
+    # Sigma schedules at the shipped video/audio flow shifts plus a short case.
+    schedules = [(50, 12.0), (50, 3.0), (8, 6.0), (1, 6.0)]
+    flat, lengths = [], []
+    for steps, shift in schedules:
+        sigmas = time_request.minimax_h3_time_shift_sigmas(num_steps=steps, shift_scale=shift)
+        lengths.append(len(sigmas))
+        flat.extend(sigmas)
+    emit_scalar(out, "kH3PlanSigmaCases", len(schedules))
+    out.write("\n")
+    emit_i64(out, "kH3PlanSigmaSteps", [s for s, _ in schedules])
+    emit_f64(out, "kH3PlanSigmaShifts", [sh for _, sh in schedules])
+    emit_i64(out, "kH3PlanSigmaLengths", lengths)
+    emit_f32(out, "kH3PlanSigmasGolden", np.asarray(flat, dtype=np.float32))
+
+    def align_multiple(value, multiple=32):
+        # pipeline_minimax_h3.py:121-122
+        return max(multiple, int(round(float(value) / multiple)) * multiple)
+
+    def reference_image_shape(width, height):
+        # pipeline_minimax_h3.py:207-222
+        if width > 4 * height or height > 4 * width:
+            raise ValueError("aspect")
+        scale = 2048 / min(width, height)
+        return align_multiple(width * scale, 32), align_multiple(height * scale, 32)
+
+    ref_cases = [(1920, 1080), (1080, 1920), (1000, 1000), (800, 600), (2400, 1000)]
+    ref_out = []
+    for w, h in ref_cases:
+        rw, rh = reference_image_shape(w, h)
+        ref_out.extend([rw, rh])
+    emit_scalar(out, "kH3PlanRefImageCases", len(ref_cases))
+    out.write("\n")
+    emit_i64(out, "kH3PlanRefImageInputs", [v for case in ref_cases for v in case])
+    emit_i64(out, "kH3PlanRefImageGolden", ref_out)
+
+    def resolve_shape(task, duration, num_frames, height, width, img_w, img_h):
+        # pipeline_minimax_h3.py:393-434
+        fps = 24
+        if duration is not None:
+            requested = int(round(float(duration) * fps))
+        elif int(num_frames or 1) > 1:
+            requested = int(num_frames)
+        else:
+            requested = 124 if task == "ref2va" else 209
+        frames = time_request.minimax_h3_align_frame_count(requested)
+        if height is None or width is None:
+            if task == "fl2va" and img_w is not None:
+                ratio = img_w / img_h
+                if ratio >= 1:
+                    height, width = 768, align_multiple(768 * ratio)
+                else:
+                    width, height = 768, align_multiple(768 / ratio)
+            else:
+                height, width = 768, 1344
+        height = int(height) // 32 * 32
+        width = int(width) // 32 * 32
+        return (height, width, frames, time_request._video_latent_t(frames),
+                time_request._audio_latent_t(frames / fps))
+
+    shape_cases = [
+        ("t2va", None, 0, None, None, None, None),
+        ("ref2va", None, 0, None, None, None, None),
+        ("t2va", 6.0, 0, None, None, None, None),
+        ("t2va", None, 100, None, None, None, None),
+        ("fl2va", None, 0, None, None, 1920, 1080),
+        ("fl2va", None, 0, None, None, 1080, 1920),
+        ("t2va", 15.0, 0, 1000, 1700, None, None),
+    ]
+    flat_shape = []
+    for task, dur, nf, h, w, iw, ih in shape_cases:
+        flat_shape.extend(resolve_shape(task, dur, nf, h, w, iw, ih))
+    emit_scalar(out, "kH3PlanShapeCases", len(shape_cases))
+    out.write("\n")
+    emit_f64(out, "kH3PlanShapeDurations", [(-1.0 if d is None else d) for _, d, _, _, _, _, _ in shape_cases])
+    emit_i64(out, "kH3PlanShapeNumFrames", [nf for _, _, nf, _, _, _, _ in shape_cases])
+    emit_i64(out, "kH3PlanShapeHeights", [(0 if h is None else h) for _, _, _, h, _, _, _ in shape_cases])
+    emit_i64(out, "kH3PlanShapeWidths", [(0 if w is None else w) for _, _, _, _, w, _, _ in shape_cases])
+    emit_i64(out, "kH3PlanShapeImageW", [(0 if iw is None else iw) for _, _, _, _, _, iw, _ in shape_cases])
+    emit_i64(out, "kH3PlanShapeImageH", [(0 if ih is None else ih) for _, _, _, _, _, _, ih in shape_cases])
+    emit_i64(out, "kH3PlanShapeGolden", flat_shape)
+    out.write("// Task order for kH3PlanShape*: " + ", ".join(c[0] for c in shape_cases) + "\n\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--vllm-omni", required=True, type=Path, help="path to a vllm-omni checkout")
+    parser.add_argument("--out", required=True, type=Path)
+    args = parser.parse_args()
+
+    root = args.vllm_omni.expanduser()
+    packed_sequence = load_upstream(root, "packed_sequence")
+    time_request = load_upstream(root, "time_request")
+    condition_noise = load_upstream(root, "condition_noise")
+    presentation = load_upstream(root, "presentation")
+    packed_tokens = load_upstream(root, "packed_tokens")
+    scheduling = load_upstream(root, "scheduling_minimax_h3_euler_ancestral")
+
+    torch.set_grad_enabled(False)
+    argv = "python3 " + " ".join(
+        [os.path.relpath(sys.argv[0])] + [f"--vllm-omni {root}", f"--out {args.out}"]
+    )
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as out:
+        emit_header(out, argv)
+        packed = emit_packed_sequence(out, packed_sequence)
+        emit_packing(out, packed_tokens)
+        emit_scheduler(out, scheduling)
+        emit_dit(out, packed)
+        emit_planner(out, time_request)
+        emit_condition_noise(out, condition_noise, packed_tokens)
+        emit_reference_video(out)
+        emit_presentation(out, presentation)
+        out.write("}  // namespace vllm_test\n")
+    print(f"wrote {args.out}", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/gen-minimax-h3-safetensors-manifest.py b/scripts/gen-minimax-h3-safetensors-manifest.py
new file mode 100644
index 000000000..b288737e8
--- /dev/null
+++ b/scripts/gen-minimax-h3-safetensors-manifest.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Emit a C++ tensor-manifest fixture from a REAL safetensors checkpoint header.
+
+A safetensors file starts with an 8-byte little-endian header length followed by a
+JSON header naming every tensor with its dtype and shape. That header is a few tens
+of KB even for a multi-GB checkpoint, so an HTTP range request over the first few
+MiB is enough to capture the whole manifest — the same trick
+gen-minimax-h3-gguf-manifest.py uses for GGUF. This is what lets the MiniMax-H3
+loader contracts be gated against REAL checkpoints (names, shapes, dtypes) without
+downloading, or checking in, a single weight byte.
+
+Used for two MiniMax-H3 arms:
+
+  NVFP4 DiT  (lilcheaty/MiniMax-H3-NVFP4, minimax_h3_ref2va_nvfp4_full.safetensors)
+    curl -sL -r 0-16777215 -o nvfp4.head <url>
+    python3 scripts/gen-minimax-h3-safetensors-manifest.py nvfp4.head \\
+        --symbol H3Nvfp4 --out tests/vllm/models/minimax_h3_nvfp4_manifest.inc
+
+  Video VAE (MiniMaxAI/MiniMax-H3, FL2VA/video_vae/source/model.safetensors)
+    curl -sL -r 0-8388607 -o videovae.head <url>
+    python3 scripts/gen-minimax-h3-safetensors-manifest.py videovae.head \\
+        --symbol H3VideoVae --out tests/vllm/models/minimax_h3_video_vae_manifest.inc
+
+Self-contained: no safetensors library needed, so it runs anywhere the file does.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import struct
+from pathlib import Path
+
+
+def read_header(path: Path) -> dict:
+    with path.open("rb") as fh:
+        raw = fh.read(8)
+        if len(raw) != 8:
+            raise SystemExit(f"{path}: too short to hold a safetensors header length")
+        length = struct.unpack("<Q", raw)[0]
+        if length <= 0 or length > 512 * 1024 * 1024:
+            raise SystemExit(
+                f"{path}: implausible header length {length} — is this a safetensors file "
+                "(an HTML error page will land here if the URL redirected)?"
+            )
+        payload = fh.read(length)
+        if len(payload) != length:
+            raise SystemExit(
+                f"{path}: header is {length} bytes but only {len(payload)} were fetched; "
+                "widen the range request"
+            )
+    header = json.loads(payload.decode("utf-8"))
+    header.pop("__metadata__", None)
+    return header
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("header_file", type=Path, help="the checkpoint, or a range-fetched prefix")
+    parser.add_argument("--symbol", required=True, help="C++ symbol prefix, e.g. H3Nvfp4")
+    parser.add_argument("--out", required=True, type=Path)
+    parser.add_argument("--label", default="", help="human label for the generated comment")
+    args = parser.parse_args()
+
+    header = read_header(args.header_file)
+    tensors = sorted(header.items())
+    label = args.label or args.header_file.name
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as out:
+        out.write(
+            "// GENERATED by scripts/gen-minimax-h3-safetensors-manifest.py — DO NOT EDIT BY HAND.\n"
+            "//\n"
+            f"// Tensor manifest of a REAL safetensors checkpoint ({label}): {len(tensors)} tensors,\n"
+            "// names/dtypes/shapes only — no weight bytes. Captured from the file's own header via\n"
+            "// an HTTP range request. See .agents/specs/minimax-h3.md.\n"
+            "#pragma once\n\n#include <cstdint>\n\nnamespace vllm_test {\n\n"
+        )
+        out.write(f"inline constexpr int64_t k{args.symbol}TensorCount = {len(tensors)};\n\n")
+        out.write(
+            f"struct {args.symbol}Tensor {{\n"
+            "  const char* name;\n"
+            "  const char* dtype;\n"
+            "  int64_t shape[5];  // 0-padded (Conv3d weights are rank 5)\n"
+            "  int32_t rank;\n"
+            "};\n\n"
+        )
+        out.write(f"inline constexpr {args.symbol}Tensor k{args.symbol}Tensors[] = {{\n")
+        for name, info in tensors:
+            shape = list(info.get("shape", []))
+            if len(shape) > 5:
+                raise SystemExit(f"{name}: rank {len(shape)} exceeds the fixture's 5-dim slots")
+            padded = shape + [0] * (5 - len(shape))
+            out.write(
+                f'    {{"{name}", "{info["dtype"]}", '
+                f"{{{', '.join(str(v) for v in padded)}}}, {len(shape)}}},\n"
+            )
+        out.write("};\n\n}  // namespace vllm_test\n")
+    print(f"wrote {args.out} ({len(tensors)} tensors)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/gen-minimax-h3-video-vae-goldens.py b/scripts/gen-minimax-h3-video-vae-goldens.py
new file mode 100644
index 000000000..d139e71ab
--- /dev/null
+++ b/scripts/gen-minimax-h3-video-vae-goldens.py
@@ -0,0 +1,478 @@
+#!/usr/bin/env python3
+"""Emit tests/vllm/models/minimax_h3_video_vae_goldens.inc.
+
+Like the audio VAE, MiniMax-H3's VIDEO VAE is checkpoint REMOTE CODE
+(`FL2VA/video_vae/*.py`, loaded under `trust_remote_code`), so it must be
+REIMPLEMENTED rather than adapted. Its real 560-tensor manifest shows the DECODER
+-- the half generation needs -- is a 36-block TRANSFORMER, so this generator runs
+the checkpoint's OWN `TransformerBlock` at reduced dimensions as the oracle.
+
+The remote code is NOT vendored here (MiniMax H3 Community License). Point
+--h3-vae-source at a local copy of the checkpoint's `video_vae/` directory; only
+the .py files are needed, not the 10 GB model.safetensors:
+
+    python3 scripts/gen-minimax-h3-video-vae-goldens.py \
+        --h3-vae-source ~/h3/FL2VA/video_vae \
+        --out tests/vllm/models/minimax_h3_video_vae_goldens.inc
+
+The bundle imports a handful of diffusers symbols (a logger, two mixin bases, two
+no-op decorators); those are STUBBED here rather than pulling the whole diffusers
+dependency in just to run an oracle.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import logging
+import sys
+import types
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+_MASK64 = (1 << 64) - 1
+
+
+def fnv1a64(name: str) -> int:
+    h = 0xCBF29CE484222325
+    for byte in name.encode("utf-8"):
+        h ^= byte
+        h = (h * 0x100000001B3) & _MASK64
+    return h
+
+
+def splitmix64(x: int) -> int:
+    x = (x + 0x9E3779B97F4A7C15) & _MASK64
+    z = x
+    z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & _MASK64
+    z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & _MASK64
+    return z ^ (z >> 31)
+
+
+def h3_rand(name: str, count: int) -> np.ndarray:
+    """Identical to the other H3 generators and the C++ H3Rand."""
+    seed = fnv1a64(name)
+    out = np.empty(count, dtype=np.float64)
+    for i in range(count):
+        u = splitmix64((seed + i) & _MASK64)
+        out[i] = ((u >> 11) * (2.0**-53)) * 2.0 - 1.0
+    return out
+
+
+def _mod(name, **attrs):
+    m = types.ModuleType(name)
+    for k, v in attrs.items():
+        setattr(m, k, v)
+    sys.modules[name] = m
+    return m
+
+
+def install_diffusers_stub() -> None:
+    if "diffusers" in sys.modules:
+        return
+    d = _mod("diffusers")
+    logging.get_logger = logging.getLogger
+    utils = _mod("diffusers.utils", logging=logging, get_logger=logging.getLogger)
+    d.utils = utils
+    utils.torch_utils = _mod("diffusers.utils.torch_utils", maybe_allow_in_graph=lambda cls: cls)
+
+    class ConfigMixin:
+        config_name = "config.json"
+
+    def register_to_config(init):
+        """Faithful-enough stand-in: capture the ctor kwargs onto `self.config`.
+
+        The bundle reads `self.config.patch_size` / `patch_size_t` in the decoder
+        forward, so a no-op decorator is NOT sufficient.
+        """
+        import functools
+        import inspect
+
+        signature = inspect.signature(init)
+
+        @functools.wraps(init)
+        def wrapper(self, *args, **kwargs):
+            bound = signature.bind_partial(self, *args, **kwargs)
+            bound.apply_defaults()
+            captured = {k: v for k, v in bound.arguments.items() if k != "self"}
+            captured.pop("kwargs", None)
+            object.__setattr__(self, "_h3_config", types.SimpleNamespace(**captured))
+            return init(self, *args, **kwargs)
+
+        return wrapper
+
+    ConfigMixin.config = property(lambda self: self._h3_config)
+    _mod("diffusers.configuration_utils", ConfigMixin=ConfigMixin,
+         register_to_config=register_to_config)
+
+    class ModelMixin(nn.Module):
+        pass
+
+    models = _mod("diffusers.models")
+    models.modeling_utils = _mod("diffusers.models.modeling_utils", ModelMixin=ModelMixin)
+    d.models = models
+
+
+def load_bundle(src: Path, module: str):
+    install_diffusers_stub()
+    if "h3vv" not in sys.modules:
+        pkg = types.ModuleType("h3vv")
+        pkg.__path__ = [str(src)]
+        sys.modules["h3vv"] = pkg
+    name = "h3vv." + module
+    spec = importlib.util.spec_from_file_location(name, src / f"{module}.py")
+    m = importlib.util.module_from_spec(spec)
+    sys.modules[name] = m
+    spec.loader.exec_module(m)
+    return m
+
+
+# Reduced dimensions. The SHIPPED decoder is 36 blocks at 36 tensors each; the
+# block is the repeated unit, so one block at small width exercises the same math.
+HEADS = 2
+DIM_HEAD = 8
+DIM = HEADS * DIM_HEAD
+SEQ = 6
+
+# Reduced ViT3DDecoder. rope_apply_dim = int(dim_head * 0.75) must stay divisible
+# by 2 * n_dim = 6 (RotaryEmbeddingND's constraint): 8 * 0.75 = 6. OK.
+DEC_LAYERS = 2
+DEC_IN_CH = 4
+DEC_OUT_CH = 3
+DEC_PATCH = 2
+DEC_PATCH_T = 1
+DEC_REGISTER_TOKENS = 4
+DEC_T, DEC_H, DEC_W = 2, 2, 3
+
+
+def emit_f32(out, name: str, values) -> None:
+    flat = np.asarray(values, dtype=np.float32).reshape(-1).tolist()
+    out.write(f"inline constexpr float {name}[] = {{\n")
+    for i in range(0, len(flat), 6):
+        chunk = []
+        for v in flat[i : i + 6]:
+            text = f"{v:.9g}"
+            if "." not in text and "e" not in text and "E" not in text:
+                text += ".0"
+            chunk.append(text + "f")
+        out.write("    " + ", ".join(chunk) + ",\n")
+    out.write("};\n\n")
+
+
+def emit_tiling(out) -> None:
+    """Section: the video VAE's spatial TILING plan and overlap blend.
+
+    Restated from the checkpoint's klvae.py:192-250 (`split_tiles`, `blend`) --
+    importing klvae directly would drag in the whole VAE bundle. The shipped
+    config is tile_size 256 / tile_overlap_min 64 / vae_ratio 16 (= prod of
+    space_down [2,2,2,2,1,1], the "f16" in f16t4).
+    """
+    import math as _math
+
+    vae_ratio = 16
+
+    def split_tiles(input_len, tile_size, tile_overlap_min):
+        if tile_size >= input_len:
+            return [0], [input_len], []
+        n = _math.ceil(input_len / tile_size)
+        while True:
+            overlaps = [tile_overlap_min] * (n - 1)
+            remaining = tile_size * n - sum(overlaps) - input_len
+            if remaining < 0:
+                n += 1
+            else:
+                break
+        remaining_units = remaining // vae_ratio
+        for i in range(remaining_units):
+            overlaps[i % (n - 1)] += vae_ratio
+        starts = [0]
+        for i in range(n - 1):
+            starts.append(starts[-1] + tile_size - overlaps[i])
+        return starts, [tile_size] * n, overlaps
+
+    cases = [(1024, 256, 64), (768, 256, 64), (256, 256, 64), (100, 256, 64),
+             (1344, 256, 64), (513, 128, 32)]
+    starts_flat, lens_flat, ovl_flat, counts = [], [], [], []
+    for input_len, tile, overlap in cases:
+        st, ln, ov = split_tiles(input_len, tile, overlap)
+        counts.append(len(st))
+        starts_flat.extend(st)
+        lens_flat.extend(ln)
+        ovl_flat.extend(ov + [0] * (len(st) - 1 - len(ov)))
+
+    # blend: linear cross-fade over `blend_extent` along one axis.
+    extent = 4
+    a = h3_rand("tiling.a", 12)
+    b = h3_rand("tiling.b", 12)
+    blended = []
+    for i in range(extent):
+        wa = 1.0 - i / extent
+        wb = i / extent
+        blended.append(a[len(a) - extent + i] * wa + b[i] * wb)
+    blended.extend(b[extent:])
+
+    out.write(f"inline constexpr int64_t kH3TileVaeRatio = {vae_ratio};\n")
+    out.write(f"inline constexpr int64_t kH3TileCases = {len(cases)};\n")
+    out.write(f"inline constexpr int64_t kH3TileBlendExtent = {extent};\n")
+    out.write(f"inline constexpr int64_t kH3TileBlendLen = {len(a)};\n\n")
+    emit_i64(out, "kH3TileInputs", [v for c in cases for v in c])
+    emit_i64(out, "kH3TileCounts", counts)
+    emit_i64(out, "kH3TileStarts", starts_flat)
+    emit_i64(out, "kH3TileLens", lens_flat)
+    emit_i64(out, "kH3TileOverlaps", ovl_flat)
+    emit_f32(out, "kH3TileBlendGolden", np.asarray(blended, dtype=np.float32))
+
+
+def emit_i64(out, name, values):
+    flat = [int(v) for v in np.asarray(values).reshape(-1).tolist()]
+    out.write(f"inline constexpr int64_t {name}[] = {{\n")
+    for i in range(0, len(flat), 12):
+        out.write("    " + ", ".join(str(v) for v in flat[i : i + 12]) + ",\n")
+    out.write("};\n\n")
+
+
+def emit_resnet3d(out, src) -> None:
+    """Section: the VAE encoder's ResnetBlock3D (the repeated unit of the 3D CNN).
+
+    GroupNorm(32, eps 1e-6) -> SiLU -> causal Conv3d(3x3x3) -> GroupNorm -> SiLU ->
+    Conv3d -> plus a 1x1x1 `nin_shortcut` when the channel count changes. The
+    convolution is CAUSAL in time (all temporal padding on the LEFT) and uses the
+    checkpoint's `reflect` spatial padding.
+    """
+    cnn = load_bundle(src, "vae_cnn")
+    # GroupNorm uses 32 groups, so channel counts must be multiples of 32.
+    in_ch, out_ch = 32, 64
+    block = cnn.ResnetBlock3D(in_ch, out_ch, padding_mode="reflect", causal=True).eval()
+    state = block.state_dict()
+    for name, tensor in state.items():
+        scale, offset = (0.1, 0.0)
+        if ".weight" in name and tensor.dim() == 1:
+            scale, offset = 0.1, 1.0     # group-norm gain
+        elif name.endswith(".bias"):
+            scale = 0.05
+        state[name] = torch.from_numpy(
+            (h3_rand("resnet3d." + name, tensor.numel()) * scale + offset).astype(np.float32)
+        ).reshape(tensor.shape)
+    block.load_state_dict(state, strict=True)
+
+    t, hh, ww = 3, 4, 4  # T>1 so the CAUSAL temporal padding path is taken
+    x = torch.from_numpy(
+        h3_rand("resnet3d.input", in_ch * t * hh * ww).astype(np.float32)
+    ).reshape(1, in_ch, t, hh, ww)
+    y = block(x)
+
+    out.write(f"inline constexpr int64_t kH3Res3dInCh = {in_ch};\n")
+    out.write(f"inline constexpr int64_t kH3Res3dOutCh = {out_ch};\n")
+    out.write(f"inline constexpr int64_t kH3Res3dT = {t};\n")
+    out.write(f"inline constexpr int64_t kH3Res3dH = {hh};\n")
+    out.write(f"inline constexpr int64_t kH3Res3dW = {ww};\n")
+    out.write(f"inline constexpr int64_t kH3Res3dGroups = 32;\n\n")
+    emit_f32(out, "kH3Res3dGolden", y.reshape(-1))
+
+
+def emit_downsample3d(out, src) -> None:
+    """Section: Downsample3D — the encoder's strided, asymmetrically-padded conv."""
+    cnn = load_bundle(src, "vae_cnn")
+    in_ch, out_ch = 32, 32
+    t, hh, ww = 3, 4, 4
+    block = cnn.Downsample3D(in_ch, out_ch, time_stride=2, space_stride=2,
+                             padding_mode="reflect", causal=True).eval()
+    state = block.state_dict()
+    for name, tensor in state.items():
+        scale = 0.05 if name.endswith(".bias") else 0.1
+        state[name] = torch.from_numpy(
+            (h3_rand("down3d." + name, tensor.numel()) * scale).astype(np.float32)
+        ).reshape(tensor.shape)
+    block.load_state_dict(state, strict=True)
+    x = torch.from_numpy(
+        h3_rand("down3d.input", in_ch * t * hh * ww).astype(np.float32)
+    ).reshape(1, in_ch, t, hh, ww)
+    y = block(x)
+    out.write(f"inline constexpr int64_t kH3Down3dInCh = {in_ch};\n")
+    out.write(f"inline constexpr int64_t kH3Down3dOutCh = {out_ch};\n")
+    out.write(f"inline constexpr int64_t kH3Down3dT = {t};\n")
+    out.write(f"inline constexpr int64_t kH3Down3dH = {hh};\n")
+    out.write(f"inline constexpr int64_t kH3Down3dW = {ww};\n")
+    out.write(f"inline constexpr int64_t kH3Down3dOutT = {int(y.shape[2])};\n")
+    out.write(f"inline constexpr int64_t kH3Down3dOutH = {int(y.shape[3])};\n")
+    out.write(f"inline constexpr int64_t kH3Down3dOutW = {int(y.shape[4])};\n\n")
+    emit_f32(out, "kH3Down3dGolden", y.reshape(-1))
+
+
+def emit_encoder_fcn3d(out, src) -> None:
+    """Section: the whole EncoderFCN3D level loop.
+
+    conv_in -> per level [num_res_blocks x ResnetBlock3D, then an optional
+    Downsample3D or a 1x1x1 channel-matching conv] -> GroupNorm -> SiLU -> conv_out.
+    The real config is ch 128, ch_mult [1,2,2,4,4,8], space_down [2,2,2,2,1,1],
+    time_down [1,2,2,1,1,1], num_res_blocks 2, embed_dim 24; only the sizes shrink.
+    """
+    cnn = load_bundle(src, "vae_cnn")
+    ch = 32
+    ch_mult = [1, 2]
+    space_down = [2, 1]
+    time_down = [2, 1]
+    num_res_blocks = 1
+    in_channels, z_channels = 3, 4
+    t, hh, ww = 3, 4, 4
+
+    enc = cnn.EncoderFCN3D(
+        ch=ch, ch_mult=ch_mult, space_down=space_down, time_down=time_down,
+        num_res_blocks=num_res_blocks, in_channels=in_channels, z_channels=z_channels,
+        double_z=False, padding_mode="reflect", causal=True,
+    ).eval()
+    state = enc.state_dict()
+    for name, tensor in state.items():
+        scale, offset = (0.1, 0.0)
+        # NOTE "norm" without a leading dot: `norm_out.weight` is a group-norm gain
+        # too, and an earlier `".norm" in name` test silently missed it.
+        if "norm" in name and name.endswith(".weight") and tensor.dim() == 1:
+            scale, offset = 0.1, 1.0
+        elif name.endswith(".bias"):
+            scale = 0.05
+        state[name] = torch.from_numpy(
+            (h3_rand("encfcn." + name, tensor.numel()) * scale + offset).astype(np.float32)
+        ).reshape(tensor.shape)
+    enc.load_state_dict(state, strict=True)
+
+    x = torch.from_numpy(
+        h3_rand("encfcn.input", in_channels * t * hh * ww).astype(np.float32)
+    ).reshape(1, in_channels, t, hh, ww)
+    y = enc(x)
+
+    out.write(f"inline constexpr int64_t kH3EncFcnCh = {ch};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnLevels = {len(ch_mult)};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnResBlocks = {num_res_blocks};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnInCh = {in_channels};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnZCh = {z_channels};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnT = {t};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnH = {hh};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnW = {ww};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnOutT = {int(y.shape[2])};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnOutH = {int(y.shape[3])};\n")
+    out.write(f"inline constexpr int64_t kH3EncFcnOutW = {int(y.shape[4])};\n\n")
+    emit_i64(out, "kH3EncFcnChMult", ch_mult)
+    emit_i64(out, "kH3EncFcnSpaceDown", space_down)
+    emit_i64(out, "kH3EncFcnTimeDown", time_down)
+    emit_f32(out, "kH3EncFcnGolden", y.reshape(-1))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--h3-vae-source", required=True, type=Path,
+                        help="the checkpoint's FL2VA/video_vae directory (.py files only)")
+    parser.add_argument("--out", required=True, type=Path)
+    args = parser.parse_args()
+
+    src = args.h3_vae_source.expanduser().resolve()
+    if not (src / "base_module.py").is_file():
+        raise SystemExit(f"missing base_module.py in {src}")
+    bm = load_bundle(src, "base_module")
+    torch.set_grad_enabled(False)
+
+    # The shipped decoder blocks: RMSNorm (affine), RMS qk-norm WITHOUT affine,
+    # gated SiLU feed-forward, and two learned residual scales -- exactly the
+    # parameter set the real manifest shows.
+    block = bm.TransformerBlock(
+        heads=HEADS, dim_head=DIM_HEAD, embed_dim=DIM,
+        norm_type="rms_norm", qk_norm_type="rms_norm", qk_norm_affine=False,
+        ffn_activation_fn="silu", ffn_use_gated=True, use_scale=True, bias=True,
+    ).eval()
+
+    state = block.state_dict()
+    for name, tensor in state.items():
+        scale, offset = (0.1, 0.0)
+        if name.endswith("norm1.weight") or name.endswith("norm2.weight"):
+            scale, offset = 0.1, 1.0
+        elif name in ("scale1", "scale2"):
+            scale, offset = 0.3, 0.0
+        elif name.endswith(".bias"):
+            scale = 0.05
+        values = h3_rand("videovae." + name, tensor.numel()) * scale + offset
+        state[name] = torch.from_numpy(values.astype(np.float32)).reshape(tensor.shape)
+    block.load_state_dict(state, strict=True)
+
+    x = torch.from_numpy(h3_rand("videovae.input", SEQ * DIM).astype(np.float32)).reshape(1, SEQ, DIM)
+    y = block(x)
+    inner = block.ff.w1.weight.shape[0] // 2
+
+    # --- the WHOLE ViT3DDecoder (surround + block stack), reduced ---
+    # Real hyperparameters (FL2VA/video_vae/source/config.json :: vit_decoder_kwargs):
+    # heads 32, dim_head 64, num_layers 36, rms_norm affine, qk rms_norm WITHOUT
+    # affine, gated SiLU, rope_theta 100.0, rope_dim_ratio 0.75. Only the sizes shrink.
+    vv = load_bundle(src, "vae_vit")
+    dec = vv.ViT3DDecoder(
+        patch_size=DEC_PATCH, patch_size_t=DEC_PATCH_T, t_causal=False,
+        in_channels=DEC_IN_CH, out_channels=DEC_OUT_CH, num_layers=DEC_LAYERS,
+        heads=HEADS, dim_head=DIM_HEAD, norm_type="rms_norm", norm_affine=True,
+        qk_norm_type="rms_norm", qk_norm_affine=False, ffn_activation_fn="silu",
+        ffn_use_gated=True, rope_theta=100.0, rope_dim_ratio=0.75, bias=True, eps=1e-5,
+        num_register_tokens=DEC_REGISTER_TOKENS,
+    ).eval()
+    dstate = dec.state_dict()
+    for name, tensor in dstate.items():
+        scale, offset = (0.1, 0.0)
+        if name.endswith("norm1.weight") or name.endswith("norm2.weight") or name.endswith("norm_out.weight"):
+            scale, offset = 0.1, 1.0
+        elif name.endswith("scale1") or name.endswith("scale2"):
+            scale, offset = 0.3, 0.0
+        elif name.endswith(".bias"):
+            scale = 0.05
+        elif name in ("mask_token",):
+            scale = 0.0  # unused at inference (mask_prob 0)
+        dstate[name] = torch.from_numpy(
+            (h3_rand("videovae.dec." + name, tensor.numel()) * scale + offset).astype(np.float32)
+        ).reshape(tensor.shape)
+    dec.load_state_dict(dstate, strict=True)
+
+    latent = torch.from_numpy(
+        h3_rand("videovae.dec.input", DEC_IN_CH * DEC_T * DEC_H * DEC_W).astype(np.float32)
+    ).reshape(1, DEC_IN_CH, DEC_T, DEC_H, DEC_W)
+    frames = dec(latent)
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    with args.out.open("w", encoding="utf-8") as out:
+        out.write(
+            "// GENERATED by scripts/gen-minimax-h3-video-vae-goldens.py — DO NOT EDIT BY HAND.\n"
+            "//\n"
+            "// MiniMax-H3 VIDEO VAE decoder TransformerBlock goldens, produced by executing the\n"
+            "// CHECKPOINT'S OWN remote-code module (FL2VA/video_vae/base_module.py) at reduced\n"
+            "// dimensions. The shipped decoder is 36 of these blocks. The remote code is not\n"
+            "// vendored here; see the generator's docstring. Weights come from the shared H3Rand\n"
+            "// stream, so no weight byte is checked in.\n"
+            "#pragma once\n\n#include <cstdint>\n\nnamespace vllm_test {\n\n"
+        )
+        out.write(f"inline constexpr int64_t kH3VideoVaeBlockHeads = {HEADS};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeBlockDimHead = {DIM_HEAD};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeBlockDim = {DIM};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeBlockSeq = {SEQ};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeBlockFfInner = {int(inner)};\n\n")
+        emit_f32(out, "kH3VideoVaeBlockGolden", y.reshape(-1))
+
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecLayers = {DEC_LAYERS};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecInCh = {DEC_IN_CH};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecOutCh = {DEC_OUT_CH};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecPatch = {DEC_PATCH};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecPatchT = {DEC_PATCH_T};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecRegisterTokens = {DEC_REGISTER_TOKENS};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecT = {DEC_T};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecH = {DEC_H};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecW = {DEC_W};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecFrameT = {int(frames.shape[2])};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecFrameH = {int(frames.shape[3])};\n")
+        out.write(f"inline constexpr int64_t kH3VideoVaeDecFrameW = {int(frames.shape[4])};\n\n")
+        emit_f32(out, "kH3VideoVaeDecoderGolden", frames.reshape(-1))
+        emit_tiling(out)
+        emit_resnet3d(out, src)
+        emit_downsample3d(out, src)
+        emit_encoder_fcn3d(out, src)
+        out.write("}  // namespace vllm_test\n")
+    print(f"wrote {args.out} (ff inner {int(inner)})", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/merged-gemm-consistency-allowlist.txt b/scripts/merged-gemm-consistency-allowlist.txt
index 1203768ba..118b4496e 100644
--- a/scripts/merged-gemm-consistency-allowlist.txt
+++ b/scripts/merged-gemm-consistency-allowlist.txt
@@ -32,3 +32,7 @@ phi3            # SwiGLU dense MLP -> UnquantizedMlpGateUpMethod (also on the gl
 gemma4_vision   # GeGLU vision-tower MLP -> UnquantizedMlpGateUpGeluMethod + a clamp-epilogue hook (Tier C2); pending FOLD-MIGRATE
 
 laguna  # known-drift pending fold: Laguna NVFP4 resident/graph decode hand-rolls the shared-expert SwiGLU epilogue; fold onto layers::MlpGateUp seam is part of the decode/runtime framework-routing port (AGENTS.md 3rd seam)
+
+minimax_h3_device  # known-drift pending fold. The DTYPE half of this blocker is now GONE: the H3 device forward uses TRUE bf16 activation storage, so it matches the seam's kBF16 DBufs. What remains is WEIGHT RESIDENCY: layers::UnquantizedMlpGateUpMethod takes an OwnedTensor (host bytes staged on demand via ResidentWeight), whereas H3 stages device tensors UP FRONT in StageMiniMaxH3DitWeights and binds plain views -- a different ownership model, not a dtype mismatch. H3's fc1 ALREADY ships merged [2*ffn, H] and is ALREADY one MatmulBT, so nothing is unmerged; adopting the seam means moving H3's loaders onto OwnedTensor residency, which is an architectural change to the quantized loaders rather than a fold.
+
+minimax_h3_encoder_device  # deliberately-not-merged: the H3-Encoder's gate/up are ggml BLOCK-QUANT weights (the 32B tower is kept in Q4_K/Q6_K so it fits a 122 GB box), and layers::UnquantizedMlpGateUpMethod is by name and by contract the UNQUANTIZED arm -- it takes an OwnedTensor of plain bf16 and has no block-quant path. Worse, the shipped Q4_K_M checkpoint keeps gate/up UNFUSED whenever the group mixes encodings, so there is not always a single merged [2I,H] operand to hand a merged-GEMM seam at all. Adopting the seam here means giving it a keep-quant arm, which is a shared-layer change, not a model fold.
diff --git a/src/vllm/entrypoints/openai/api_server.cpp b/src/vllm/entrypoints/openai/api_server.cpp
index 37d3ca9ed..795525489 100644
--- a/src/vllm/entrypoints/openai/api_server.cpp
+++ b/src/vllm/entrypoints/openai/api_server.cpp
@@ -8,6 +8,7 @@
 #include <limits>
 #include <memory>
 #include <mutex>
+#include <thread>
 #include <stdexcept>
 #include <string>
 #include <utility>
@@ -111,7 +112,19 @@ ApiServer::ApiServer(OpenAIServingCompletion& completion,
       version_(std::move(version)),
       impl_(std::make_unique<Impl>(max_concurrent_streams, worker_pool_mode)) {}
 
-ApiServer::~ApiServer() = default;
+ApiServer::~ApiServer() {
+  // Drain the async /v1/videos workers before the job store they write into is
+  // destroyed. Threads are joined, never detached, precisely so this ordering is
+  // guaranteed rather than hoped for.
+  std::vector<std::thread> workers;
+  {
+    std::lock_guard<std::mutex> lock(video_workers_mutex_);
+    workers.swap(video_workers_);
+  }
+  for (auto& worker : workers) {
+    if (worker.joinable()) worker.join();
+  }
+}
 
 ApiServer::DispatchResult ApiServer::handle_completions(
     const std::string& request_body) {
@@ -249,6 +262,101 @@ ApiServer::DispatchResult ApiServer::handle_ping() const {
   return handle_health();
 }
 
+namespace {
+
+ApiServer::DispatchResult VideoJsonOk(std::string body) {
+  ApiServer::DispatchResult out;
+  out.status = 200;
+  out.content_type = "application/json";
+  out.body = std::move(body);
+  return out;
+}
+
+}  // namespace
+
+ApiServer::DispatchResult ApiServer::handle_videos(
+    const std::string& request_body) {
+  // vLLM-Omni's ASYNC video endpoint: validate, enqueue, and return the job id
+  // immediately. Generation is minutes-long (a 50-step denoise over the packed
+  // video+audio sequence), so answering inline would hold an HTTP worker for the
+  // whole run -- which is exactly why upstream splits async from /sync.
+  if (!video_runner_) {
+    return MakeError(500, "InternalServerError", "No video runner configured.");
+  }
+  ::vllm::openai::VideoRequest request;
+  try {
+    request = ::vllm::openai::ParseVideoRequest(request_body);
+  } catch (const std::exception& e) {
+    return MakeError(400, "BadRequestError", e.what());
+  }
+
+  const std::string id = video_jobs_.Create();
+  std::thread worker([this, id, request]() {
+    try {
+      video_jobs_.MarkRunning(id);
+      video_jobs_.MarkSucceeded(id, video_runner_(request));
+    } catch (const std::exception& e) {
+      // A runner throw is a FAILED job, not a crashed server: the thread must
+      // never let an exception escape (std::terminate) and must always leave the
+      // job in a terminal state, or a poller would wait on "running" forever.
+      try {
+        video_jobs_.MarkFailed(id, e.what());
+      } catch (const std::exception&) {
+      }
+    } catch (...) {
+      try {
+        video_jobs_.MarkFailed(id, "unknown error");
+      } catch (const std::exception&) {
+      }
+    }
+  });
+  {
+    std::lock_guard<std::mutex> lock(video_workers_mutex_);
+    video_workers_.push_back(std::move(worker));
+  }
+
+  ::vllm::openai::VideoJob job;
+  video_jobs_.Get(id, &job);
+  return VideoJsonOk(::vllm::openai::VideoJobStatusJson(job));
+}
+
+ApiServer::DispatchResult ApiServer::handle_videos_sync(
+    const std::string& request_body) {
+  // The SYNCHRONOUS twin: run to completion on the calling worker and answer with
+  // the terminal job record. Same runner, same failure mapping -- only the
+  // waiting differs.
+  if (!video_runner_) {
+    return MakeError(500, "InternalServerError", "No video runner configured.");
+  }
+  ::vllm::openai::VideoRequest request;
+  try {
+    request = ::vllm::openai::ParseVideoRequest(request_body);
+  } catch (const std::exception& e) {
+    return MakeError(400, "BadRequestError", e.what());
+  }
+
+  const std::string id = video_jobs_.Create();
+  try {
+    video_jobs_.MarkRunning(id);
+    video_jobs_.MarkSucceeded(id, video_runner_(request));
+  } catch (const std::exception& e) {
+    video_jobs_.MarkFailed(id, e.what());
+    return MakeError(500, "InternalServerError", e.what());
+  }
+  ::vllm::openai::VideoJob job;
+  video_jobs_.Get(id, &job);
+  return VideoJsonOk(::vllm::openai::VideoJobStatusJson(job));
+}
+
+ApiServer::DispatchResult ApiServer::handle_video_status(
+    const std::string& job_id) const {
+  ::vllm::openai::VideoJob job;
+  if (!video_jobs_.Get(job_id, &job)) {
+    return MakeError(404, "NotFoundError", "Unknown video job: " + job_id);
+  }
+  return VideoJsonOk(::vllm::openai::VideoJobStatusJson(job));
+}
+
 ApiServer::DispatchResult ApiServer::handle_metrics() const {
   // serve/instrumentator/metrics.py:82 — the prometheus text exposition served
   // by make_asgi_app(registry). The PrometheusResponse content type is
@@ -648,6 +756,25 @@ void ApiServer::register_routes() {
                write(handle_server_info(), res);
              });
 
+  if (video_runner_) {
+    // MiniMax-H3. Registered ONLY when a runner is attached, so a server built
+    // without video support answers 404 exactly as before.
+    server.Post("/v1/videos",
+                [this, write](const httplib::Request& req,
+                              httplib::Response& res) {
+                  write(handle_videos(req.body), res);
+                });
+    server.Post("/v1/videos/sync",
+                [this, write](const httplib::Request& req,
+                              httplib::Response& res) {
+                  write(handle_videos_sync(req.body), res);
+                });
+    server.Get(R"(/v1/videos/([^/]+))",
+               [this, write](const httplib::Request& req,
+                             httplib::Response& res) {
+                 write(handle_video_status(req.matches[1]), res);
+               });
+  }
   if (metrics_ != nullptr) {
     server.Get("/metrics",
                [this, write](const httplib::Request&, httplib::Response& res) {
diff --git a/src/vllm/entrypoints/openai/video_api.cpp b/src/vllm/entrypoints/openai/video_api.cpp
new file mode 100644
index 000000000..a079a5c7b
--- /dev/null
+++ b/src/vllm/entrypoints/openai/video_api.cpp
@@ -0,0 +1,135 @@
+// See include/vllm/entrypoints/openai/video_api.h. Request contract + job
+// lifecycle only; the library never spawns a process.
+#include "vllm/entrypoints/openai/video_api.h"
+
+#include <nlohmann/json.hpp>
+
+#include "vt/dtype.h"
+
+namespace vllm::openai {
+namespace {
+
+double ReadNumber(const nlohmann::json& body, const char* key, double fallback) {
+  if (!body.contains(key) || body.at(key).is_null()) return fallback;
+  VT_CHECK(body.at(key).is_number(), "video request: field must be a number");
+  return body.at(key).get<double>();
+}
+
+}  // namespace
+
+VideoRequest ParseVideoRequest(const std::string& body) {
+  nlohmann::json json;
+  try {
+    json = nlohmann::json::parse(body);
+  } catch (const std::exception&) {
+    VT_CHECK(false, "video request: body is not valid JSON");
+  }
+  VT_CHECK(json.is_object(), "video request: body must be a JSON object");
+  VT_CHECK(json.contains("prompt") && json.at("prompt").is_string(),
+           "video request: `prompt` is required and must be a string");
+
+  VideoRequest out;
+  out.prompt = json.at("prompt").get<std::string>();
+  if (json.contains("task") && !json.at("task").is_null()) {
+    VT_CHECK(json.at("task").is_string(), "video request: `task` must be a string");
+    out.task = json.at("task").get<std::string>();
+  }
+  // vLLM-Omni carries the generation knobs under `extra_params`; accept them at
+  // the top level too so a plain client does not have to nest.
+  const nlohmann::json& extra =
+      (json.contains("extra_params") && json.at("extra_params").is_object()) ? json.at("extra_params")
+                                                                            : json;
+  out.duration_seconds = ReadNumber(extra, "duration", 0.0);
+  out.num_frames = static_cast<int64_t>(ReadNumber(extra, "num_frames", 0.0));
+  out.height = static_cast<int64_t>(ReadNumber(json, "height", 0.0));
+  out.width = static_cast<int64_t>(ReadNumber(json, "width", 0.0));
+  out.num_inference_steps = static_cast<int64_t>(ReadNumber(extra, "num_inference_steps", 50.0));
+  out.flow_shift = ReadNumber(extra, "flow_shift", 12.0);
+  out.audio_flow_shift = ReadNumber(extra, "audio_flow_shift", 3.0);
+  if (extra.contains("seed") && !extra.at("seed").is_null()) {
+    VT_CHECK(extra.at("seed").is_number(), "video request: `seed` must be a number");
+    out.seed = extra.at("seed").get<int64_t>();
+    out.has_seed = true;
+  }
+
+  VT_CHECK(out.num_inference_steps > 0, "video request: `num_inference_steps` must be > 0");
+  VT_CHECK(out.flow_shift > 0.0 && out.audio_flow_shift > 0.0,
+           "video request: flow shifts must be > 0");
+  VT_CHECK(out.duration_seconds >= 0.0, "video request: `duration` must be >= 0");
+  VT_CHECK(out.height >= 0 && out.width >= 0, "video request: height/width must be >= 0");
+  return out;
+}
+
+const char* VideoJobStatusName(VideoJobStatus status) {
+  switch (status) {
+    case VideoJobStatus::kQueued: return "queued";
+    case VideoJobStatus::kRunning: return "running";
+    case VideoJobStatus::kSucceeded: return "succeeded";
+    case VideoJobStatus::kFailed: return "failed";
+  }
+  return "unknown";
+}
+
+std::string VideoJobStore::Create() {
+  std::lock_guard<std::mutex> guard(mutex_);
+  VideoJob job;
+  job.id = "vid_" + std::to_string(++next_);
+  job.status = VideoJobStatus::kQueued;
+  jobs_[job.id] = job;
+  return job.id;
+}
+
+void VideoJobStore::MarkRunning(const std::string& id) {
+  std::lock_guard<std::mutex> guard(mutex_);
+  const auto it = jobs_.find(id);
+  VT_CHECK(it != jobs_.end(), "video job store: unknown job id");
+  VT_CHECK(it->second.status == VideoJobStatus::kQueued,
+           "video job store: only a queued job may start running");
+  it->second.status = VideoJobStatus::kRunning;
+}
+
+void VideoJobStore::MarkSucceeded(const std::string& id, const std::string& output_path) {
+  std::lock_guard<std::mutex> guard(mutex_);
+  const auto it = jobs_.find(id);
+  VT_CHECK(it != jobs_.end(), "video job store: unknown job id");
+  VT_CHECK(it->second.status == VideoJobStatus::kRunning,
+           "video job store: only a running job may succeed");
+  VT_CHECK(!output_path.empty(), "video job store: a succeeded job needs an output path");
+  it->second.status = VideoJobStatus::kSucceeded;
+  it->second.output_path = output_path;
+}
+
+void VideoJobStore::MarkFailed(const std::string& id, const std::string& error) {
+  std::lock_guard<std::mutex> guard(mutex_);
+  const auto it = jobs_.find(id);
+  VT_CHECK(it != jobs_.end(), "video job store: unknown job id");
+  VT_CHECK(it->second.status == VideoJobStatus::kQueued ||
+               it->second.status == VideoJobStatus::kRunning,
+           "video job store: only a pending job may fail");
+  it->second.status = VideoJobStatus::kFailed;
+  it->second.error = error.empty() ? "unspecified error" : error;
+}
+
+bool VideoJobStore::Get(const std::string& id, VideoJob* out) const {
+  std::lock_guard<std::mutex> guard(mutex_);
+  const auto it = jobs_.find(id);
+  if (it == jobs_.end()) return false;
+  if (out != nullptr) *out = it->second;
+  return true;
+}
+
+int64_t VideoJobStore::Size() const {
+  std::lock_guard<std::mutex> guard(mutex_);
+  return static_cast<int64_t>(jobs_.size());
+}
+
+std::string VideoJobStatusJson(const VideoJob& job) {
+  nlohmann::json out;
+  out["id"] = job.id;
+  out["status"] = VideoJobStatusName(job.status);
+  if (job.status == VideoJobStatus::kSucceeded) out["output_path"] = job.output_path;
+  if (job.status == VideoJobStatus::kFailed) out["error"] = job.error;
+  return out.dump();
+}
+
+}  // namespace vllm::openai
diff --git a/src/vllm/model_executor/models/minimax_h3.cpp b/src/vllm/model_executor/models/minimax_h3.cpp
new file mode 100644
index 000000000..62e684c45
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3.cpp
@@ -0,0 +1,920 @@
+// MiniMax-H3 DiT — config parse, weight contract, packed forward, denoise loop.
+// Port of vllm-project/vllm-omni, vllm_omni/diffusion/models/minimax_h3/
+// minimax_h3_transformer.py (the DiT) and denoise_loop.py (the CFG-distilled loop).
+//
+// ─── SCOPE OF THIS TU (read before trusting it for performance) ──────────────
+// This is the CORRECTNESS forward: the two structurally hard pieces route through
+// the SHARED vt:: ops — every projection is `vt::MatmulBT` and the packed
+// varlen NON-CAUSAL attention is `vt::DFlashBlockAttention(causal=false)`, whose
+// per-document bidirectional contract is exactly upstream's `cu_seqlens` varlen FA
+// call (minimax_h3_transformer.py:288-317, 383-419) — while the elementwise glue
+// (RMSNorm, SiLU, 3D RoPE, AdaLN modulate/gate, the indexed scatter/gather) runs as
+// explicit host loops so the math can be read against upstream line by line and
+// gated exactly. It therefore requires a CPU device.
+//
+// The DEVICE-RESIDENT forward is a separate, tracked brick (H3-2b in
+// .agents/specs/minimax-h3.md): it folds the glue onto `vt::FusedChain` recipes and
+// a fused AdaLN modulate op, which is also where the speed work belongs (upstream
+// reports the DiT at 88% of request latency). Nothing here claims a speed result.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstddef>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "vt/dtype.h"
+#include "vt/backend.h"
+#include "vt/ops.h"
+
+namespace vllm {
+namespace {
+
+using vt::DType;
+using vt::Tensor;
+
+// ---------------------------------------------------------------------------
+// Small host helpers. Every one names the upstream lines it mirrors.
+// ---------------------------------------------------------------------------
+
+// nn.RMSNorm with fp32 variance accumulation (minimax_h3_transformer.py:171-175).
+void RmsNormRows(const float* in, const float* weight, float* out, int64_t rows, int64_t width,
+                 double eps) {
+  for (int64_t r = 0; r < rows; ++r) {
+    const float* src = in + r * width;
+    double sum = 0.0;
+    for (int64_t i = 0; i < width; ++i) sum += static_cast<double>(src[i]) * src[i];
+    const float inv = static_cast<float>(1.0 / std::sqrt(sum / static_cast<double>(width) + eps));
+    float* dst = out + r * width;
+    for (int64_t i = 0; i < width; ++i) dst[i] = src[i] * inv * weight[i];
+  }
+}
+
+float Silu(float x) { return x / (1.0f + std::exp(-x)); }
+
+// Round through bfloat16 (round-to-nearest-even, matching torch's .to(bf16)).
+// The production H3 stream is bf16 with fp32 islands; rounding IN PLACE rather
+// than switching storage keeps this forward comparing the same CAST POINTS as
+// upstream instead of a different accumulation strategy.
+float RoundBf16(float value) {
+  uint32_t bits;
+  std::memcpy(&bits, &value, sizeof(bits));
+  if ((bits & 0x7F800000u) == 0x7F800000u) {  // inf/nan pass through
+    bits &= 0xFFFF0000u;
+  } else {
+    const uint32_t lsb = (bits >> 16) & 1u;
+    bits = (bits + 0x7FFFu + lsb) & 0xFFFF0000u;
+  }
+  float out;
+  std::memcpy(&out, &bits, sizeof(out));
+  return out;
+}
+
+// The block-stream dtype policy for one forward.
+struct StreamDtype {
+  bool bf16 = false;
+  float operator()(float value) const { return bf16 ? RoundBf16(value) : value; }
+  void Apply(float* data, int64_t count) const {
+    if (!bf16) return;
+    for (int64_t i = 0; i < count; ++i) data[i] = RoundBf16(data[i]);
+  }
+  void Apply(std::vector<float>& buffer) const {
+    Apply(buffer.data(), static_cast<int64_t>(buffer.size()));
+  }
+};
+
+// vt::MatmulBT + optional bias. Weight is [out_features, in_features], matching
+// every {Column,Row,QKV,MergedColumn}ParallelLinear at TP=1.
+void Linear(vt::Queue& q, const float* in, int64_t rows, int64_t in_features,
+            const Tensor& weight, const Tensor* bias, float* out) {
+  const int64_t out_features = weight.shape[0];
+  VT_CHECK(weight.rank == 2 && weight.shape[1] == in_features,
+           "minimax_h3 linear: weight shape does not match input width");
+  VT_CHECK(weight.dtype == DType::kF32, "minimax_h3 linear: reference forward expects f32 weights");
+  Tensor a = Tensor::Contiguous(const_cast<float*>(in), DType::kF32, weight.device,
+                                {rows, in_features});
+  Tensor o = Tensor::Contiguous(out, DType::kF32, weight.device, {rows, out_features});
+  vt::MatmulBT(q, o, a, weight);
+  if (bias != nullptr && bias->data != nullptr) {
+    const float* b = bias->Ptr<float>();
+    for (int64_t r = 0; r < rows; ++r) {
+      float* dst = out + r * out_features;
+      for (int64_t i = 0; i < out_features; ++i) dst[i] += b[i];
+    }
+  }
+}
+
+// MiniMaxH3Rope.forward (minimax_h3_transformer.py:222-230).
+// img_position_ids [S,3] fp64 -> freqs [S, 6*L] fp32, laid out as
+// [t|h|w|t|h|w] with L frequencies per axis.
+std::vector<float> RopeFreqs(const double* position_ids, int64_t seq_len,
+                             const float* inv_freq, int64_t inv_freq_len) {
+  const int64_t half = 3 * inv_freq_len;
+  std::vector<float> freqs(static_cast<size_t>(seq_len * 2 * half));
+  for (int64_t s = 0; s < seq_len; ++s) {
+    float* dst = freqs.data() + s * 2 * half;
+    for (int64_t axis = 0; axis < 3; ++axis) {
+      const float pos = static_cast<float>(position_ids[s * 3 + axis]);
+      for (int64_t i = 0; i < inv_freq_len; ++i) {
+        dst[axis * inv_freq_len + i] = pos * inv_freq[i];
+      }
+    }
+    std::memcpy(dst + half, dst, static_cast<size_t>(half) * sizeof(float));
+  }
+  return freqs;
+}
+
+// _apply_rope (minimax_h3_transformer.py:233-244): rotate the first rot_dim head
+// dims with rotate_half, pass the rest through.
+void ApplyRope(float* x, int64_t rows, int64_t heads, int64_t head_dim, const float* freqs,
+               int64_t rot_dim) {
+  const int64_t half = rot_dim / 2;
+  for (int64_t r = 0; r < rows; ++r) {
+    const float* f = freqs + r * rot_dim;
+    for (int64_t h = 0; h < heads; ++h) {
+      float* v = x + (r * heads + h) * head_dim;
+      for (int64_t i = 0; i < half; ++i) {
+        const float cos_lo = std::cos(f[i]), sin_lo = std::sin(f[i]);
+        const float cos_hi = std::cos(f[i + half]), sin_hi = std::sin(f[i + half]);
+        const float lo = v[i], hi = v[i + half];
+        // rotate_half: (-x2, x1) => out_lo = lo*cos - hi*sin, out_hi = hi*cos + lo*sin
+        v[i] = lo * cos_lo - hi * sin_lo;
+        v[i + half] = hi * cos_hi + lo * sin_hi;
+      }
+    }
+  }
+}
+
+// _modulate_scale_shift (minimax_h3_transformer.py:183-192).
+void ModulateScaleShift(float* x, int64_t rows, int64_t width, const float* shift,
+                        const float* scale, const int64_t* indices) {
+  for (int64_t r = 0; r < rows; ++r) {
+    const int64_t idx = indices[r];
+    float* dst = x + r * width;
+    const float* s = scale + idx * width;
+    const float* h = shift + idx * width;
+    for (int64_t i = 0; i < width; ++i) dst[i] = dst[i] * (1.0f + s[i]) + h[i];
+  }
+}
+
+// _modulate_gate (minimax_h3_transformer.py:195-204).
+void ModulateGate(float* residual, int64_t rows, int64_t width, const float* gate,
+                  const float* other, const int64_t* indices) {
+  for (int64_t r = 0; r < rows; ++r) {
+    const int64_t idx = indices[r];
+    float* dst = residual + r * width;
+    const float* g = gate + idx * width;
+    const float* o = other + r * width;
+    for (int64_t i = 0; i < width; ++i) dst[i] += g[i] * o[i];
+  }
+}
+
+// MiniMaxH3AdalnProj.forward (minimax_h3_transformer.py:555-561):
+// silu(t_emb) -> linear -> view(M*modality_num, expand*H) -> chunk(expand).
+// Returns the flat [M*modality_num, expand*H] buffer; chunk c of row m starts at
+// (m * expand + c) * H within the caller's indexing scheme below.
+std::vector<float> AdalnProject(vt::Queue& q, const float* t_emb, int64_t m, int64_t time_embed_dim,
+                                const Tensor& weight, const Tensor& bias, const StreamDtype& dt) {
+  std::vector<float> activated(static_cast<size_t>(m * time_embed_dim));
+  for (int64_t i = 0; i < m * time_embed_dim; ++i) activated[static_cast<size_t>(i)] = Silu(t_emb[i]);
+  const int64_t out_features = weight.shape[0];
+  // silu(t_emb) is fp32, then cast to the BF16 linear's dtype before the GEMM.
+  dt.Apply(activated);
+  std::vector<float> out(static_cast<size_t>(m * out_features));
+  Linear(q, activated.data(), m, time_embed_dim, weight, &bias, out.data());
+  dt.Apply(out);
+  return out;
+}
+
+// One chunk of an AdaLN projection, materialized as [M*modality_num, H] so the
+// per-row `index_select` in the modulate helpers is a plain row lookup.
+std::vector<float> AdalnChunk(const std::vector<float>& projected, int64_t m, int64_t modality_num,
+                              int64_t hidden_size, int64_t expand_ratio, int64_t chunk) {
+  const int64_t rows = m * modality_num;
+  const int64_t row_width = expand_ratio * hidden_size;
+  std::vector<float> out(static_cast<size_t>(rows * hidden_size));
+  for (int64_t r = 0; r < rows; ++r) {
+    const float* src = projected.data() + r * row_width + chunk * hidden_size;
+    std::memcpy(out.data() + r * hidden_size, src, static_cast<size_t>(hidden_size) * sizeof(float));
+  }
+  return out;
+}
+
+struct AttentionBlockWeights {
+  const Tensor* qkv;
+  const Tensor* q_norm;
+  const Tensor* k_norm;
+  const Tensor* out_proj;
+};
+
+// MiniMaxH3Attention.forward (minimax_h3_transformer.py:421-467): fused qkv ->
+// per-head q/k RMSNorm -> RoPE -> varlen non-causal attention -> output projection.
+void AttentionForward(vt::Queue& q, const MiniMaxH3DitParams& params,
+                      const AttentionBlockWeights& w, const float* in, int64_t rows,
+                      const float* rope_freqs, const int32_t* cu_seqlens, int num_reqs,
+                      const StreamDtype& dt, float* out) {
+  const int64_t heads = params.num_attention_heads;
+  const int64_t head_dim = params.attention_head_dim;
+  const int64_t inner = heads * head_dim;
+  const int64_t hidden = params.hidden_size;
+
+  std::vector<float> qkv(static_cast<size_t>(rows * 3 * inner));
+  Linear(q, in, rows, hidden, *w.qkv, nullptr, qkv.data());
+  dt.Apply(qkv);
+
+  std::vector<float> qbuf(static_cast<size_t>(rows * inner));
+  std::vector<float> kbuf(static_cast<size_t>(rows * inner));
+  std::vector<float> vbuf(static_cast<size_t>(rows * inner));
+  for (int64_t r = 0; r < rows; ++r) {
+    const float* src = qkv.data() + r * 3 * inner;
+    std::memcpy(qbuf.data() + r * inner, src, static_cast<size_t>(inner) * sizeof(float));
+    std::memcpy(kbuf.data() + r * inner, src + inner, static_cast<size_t>(inner) * sizeof(float));
+    std::memcpy(vbuf.data() + r * inner, src + 2 * inner, static_cast<size_t>(inner) * sizeof(float));
+  }
+
+  // Per-head RMSNorm over head_dim: [rows, heads, head_dim] -> [rows*heads, head_dim].
+  std::vector<float> qn(qbuf.size()), kn(kbuf.size());
+  RmsNormRows(qbuf.data(), w.q_norm->Ptr<float>(), qn.data(), rows * heads, head_dim,
+              params.qk_norm_eps);
+  RmsNormRows(kbuf.data(), w.k_norm->Ptr<float>(), kn.data(), rows * heads, head_dim,
+              params.qk_norm_eps);
+
+  dt.Apply(qn);
+  dt.Apply(kn);
+  if (rope_freqs != nullptr) {
+    ApplyRope(qn.data(), rows, heads, head_dim, rope_freqs, params.rope_rot_dim());
+    ApplyRope(kn.data(), rows, heads, head_dim, rope_freqs, params.rope_rot_dim());
+    dt.Apply(qn);
+    dt.Apply(kn);
+  }
+
+  // The SHARED packed bidirectional attention op. `cu_seqlens` carries the packed
+  // document bounds, so attention never crosses into the alignment padding.
+  const vt::Device device = w.qkv->device;
+  Tensor tq = Tensor::Contiguous(qn.data(), DType::kF32, device, {rows, heads, head_dim});
+  Tensor tk = Tensor::Contiguous(kn.data(), DType::kF32, device, {rows, heads, head_dim});
+  Tensor tv = Tensor::Contiguous(vbuf.data(), DType::kF32, device, {rows, heads, head_dim});
+  std::vector<float> attn(static_cast<size_t>(rows * inner));
+  Tensor ta = Tensor::Contiguous(attn.data(), DType::kF32, device, {rows, heads, head_dim});
+  vt::DFlashBlockAttentionArgs args;
+  args.scale = static_cast<float>(1.0 / std::sqrt(static_cast<double>(head_dim)));
+  args.causal = false;  // bidirectional within each packed document
+  args.sliding_window = 0;
+  args.cu_seqlens = cu_seqlens;
+  args.num_reqs = num_reqs;
+  vt::DFlashBlockAttention(q, ta, tq, tk, tv, args);
+  dt.Apply(attn);
+
+  Linear(q, attn.data(), rows, inner, *w.out_proj, nullptr, out);
+  dt.Apply(out, rows * hidden);
+}
+
+// MiniMaxH3MLP.forward (minimax_h3_transformer.py:512-517): silu(gate) * up.
+void MlpForward(vt::Queue& q, const MiniMaxH3DitParams& params, const Tensor& fc1,
+                const Tensor& fc2, const float* in, int64_t rows, const StreamDtype& dt,
+                float* out) {
+  const int64_t ffn = params.ffn_hidden_size;
+  std::vector<float> hidden(static_cast<size_t>(rows * 2 * ffn));
+  Linear(q, in, rows, params.hidden_size, fc1, nullptr, hidden.data());
+  dt.Apply(hidden);
+  std::vector<float> act(static_cast<size_t>(rows * ffn));
+  for (int64_t r = 0; r < rows; ++r) {
+    const float* src = hidden.data() + r * 2 * ffn;
+    float* dst = act.data() + r * ffn;
+    for (int64_t i = 0; i < ffn; ++i) dst[i] = Silu(src[i]) * src[ffn + i];
+  }
+  dt.Apply(act);
+  Linear(q, act.data(), rows, ffn, fc2, nullptr, out);
+  dt.Apply(out, rows * params.hidden_size);
+}
+
+AttentionBlockWeights AttnOf(const MiniMaxH3DitBlockWeights& b) {
+  return AttentionBlockWeights{&b.qkv_proj, &b.q_norm, &b.k_norm, &b.out_proj};
+}
+
+}  // namespace
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+// MiniMaxH3DiTArchConfig.from_mapping (minimax_h3_transformer.py:69-78): take the
+// keys the mapping actually carries, keep the shipped defaults for the rest.
+MiniMaxH3DitParams ParseMiniMaxH3DitParams(const nlohmann::json& config) {
+  MiniMaxH3DitParams p;
+  auto get_int = [&](const char* key, int64_t& slot) {
+    if (config.contains(key) && config.at(key).is_number()) slot = config.at(key).get<int64_t>();
+  };
+  auto get_double = [&](const char* key, double& slot) {
+    if (config.contains(key) && config.at(key).is_number()) slot = config.at(key).get<double>();
+  };
+  get_int("num_layers", p.num_layers);
+  get_int("token_refiner_num_layers", p.token_refiner_num_layers);
+  get_int("hidden_size", p.hidden_size);
+  get_int("num_attention_heads", p.num_attention_heads);
+  get_int("attention_head_dim", p.attention_head_dim);
+  get_int("ffn_hidden_size", p.ffn_hidden_size);
+  get_int("latents_dim", p.latents_dim);
+  get_int("audio_latents_dim", p.audio_latents_dim);
+  get_int("text_dim", p.text_dim);
+  get_int("timestep_input_dim", p.timestep_input_dim);
+  get_int("time_embed_hidden_size", p.time_embed_hidden_size);
+  get_int("time_embed_dim", p.time_embed_dim);
+  get_int("adaln_out_features", p.adaln_out_features);
+  get_int("final_adaln_out_features", p.final_adaln_out_features);
+  get_int("rope_inv_freq_len", p.rope_inv_freq_len);
+  get_double("norm_eps", p.norm_eps);
+  get_double("qk_norm_eps", p.qk_norm_eps);
+  get_double("final_norm_eps", p.final_norm_eps);
+  if (config.contains("patch_size")) {
+    const nlohmann::json& patch = config.at("patch_size");
+    VT_CHECK(patch.is_array() && patch.size() == 3,
+             "minimax_h3: patch_size must contain three values");
+    p.patch_size_t = patch[0].get<int64_t>();
+    p.patch_size_h = patch[1].get<int64_t>();
+    p.patch_size_w = patch[2].get<int64_t>();
+  }
+  // The invariants the upstream model asserts at construction
+  // (minimax_h3_transformer.py:539-541, 810-828, 852-859).
+  VT_CHECK(p.num_attention_heads > 0 && p.hidden_size > 0 && p.attention_head_dim > 0 &&
+               p.ffn_hidden_size > 0,
+           "minimax_h3: geometry scalars must be positive");
+  VT_CHECK(p.adaln_out_features == 6 * p.hidden_size * kMiniMaxH3AdalnModalityNum,
+           "minimax_h3: adaln_out_features must be 6 * hidden_size * 3");
+  VT_CHECK(p.final_adaln_out_features == 2 * p.hidden_size,
+           "minimax_h3: final_adaln_out_features must be 2 * hidden_size");
+  VT_CHECK(p.rope_rot_dim() <= p.attention_head_dim,
+           "minimax_h3: 6 * rope_inv_freq_len must not exceed attention_head_dim");
+  return p;
+}
+
+// ---------------------------------------------------------------------------
+// Weight contract
+// ---------------------------------------------------------------------------
+
+// The DiT loads by EXACT checkpoint name (minimax_h3_transformer.py:906-922), so
+// this enumeration IS the contract. FP32 names come from
+// MINIMAX_H3_FP32_PARAM_NAMES / _BUFFER_NAMES (:85-101), which post_load_weights
+// re-asserts (:898-904).
+std::vector<MiniMaxH3TensorSpec> EnumerateMiniMaxH3DitTensors(const MiniMaxH3DitParams& p) {
+  std::vector<MiniMaxH3TensorSpec> out;
+  const int64_t inner = p.num_attention_heads * p.attention_head_dim;
+  const int64_t video_patch_dim = p.video_row_width();
+
+  out.push_back({"video_patch_proj.weight", {p.hidden_size, video_patch_dim}, true});
+  out.push_back({"video_patch_proj.bias", {p.hidden_size}, true});
+  out.push_back({"audio_patch_proj.weight", {p.hidden_size, p.audio_latents_dim}, true});
+  out.push_back({"audio_patch_proj.bias", {p.hidden_size}, true});
+  out.push_back({"condition_proj.weight", {p.hidden_size, p.text_dim}, false});
+  out.push_back({"condition_proj.bias", {p.hidden_size}, false});
+  out.push_back({"time_embedder.proj_in.weight", {p.time_embed_hidden_size, p.timestep_input_dim}, true});
+  out.push_back({"time_embedder.proj_in.bias", {p.time_embed_hidden_size}, true});
+  out.push_back({"time_embedder.proj_out.weight", {p.time_embed_dim, p.time_embed_hidden_size}, true});
+  out.push_back({"time_embedder.proj_out.bias", {p.time_embed_dim}, true});
+  out.push_back({"rope.inv_freq", {p.rope_inv_freq_len}, true});
+
+  auto push_attn_and_mlp = [&](const std::string& prefix) {
+    // The checkpoint stores qkv GROUPED per query group; the reorder at load time
+    // turns it into [q_all, k_all, v_all] without changing the row count.
+    out.push_back({prefix + ".attn.qkv_proj.weight", {3 * inner, p.hidden_size}, false});
+    out.push_back({prefix + ".attn.q_norm.weight", {p.attention_head_dim}, false});
+    out.push_back({prefix + ".attn.k_norm.weight", {p.attention_head_dim}, false});
+    out.push_back({prefix + ".attn.out_proj.weight", {p.hidden_size, inner}, false});
+    // fc1 rows split evenly into [gate; up] at load (minimax_h3_transformer.py:497-510).
+    out.push_back({prefix + ".mlp.fc1.weight", {2 * p.ffn_hidden_size, p.hidden_size}, false});
+    out.push_back({prefix + ".mlp.fc2.weight", {p.hidden_size, p.ffn_hidden_size}, false});
+  };
+
+  for (int64_t i = 0; i < p.token_refiner_num_layers; ++i) {
+    const std::string prefix = "token_refiner.blocks." + std::to_string(i);
+    out.push_back({prefix + ".norm1.weight", {p.hidden_size}, false});
+    out.push_back({prefix + ".norm2.weight", {p.hidden_size}, false});
+    push_attn_and_mlp(prefix);
+  }
+  out.push_back({"token_refiner.final_norm.weight", {p.hidden_size}, false});
+
+  for (int64_t i = 0; i < p.num_layers; ++i) {
+    const std::string prefix = "blocks." + std::to_string(i);
+    out.push_back({prefix + ".norm1.weight", {p.hidden_size}, false});
+    out.push_back({prefix + ".norm2.weight", {p.hidden_size}, false});
+    push_attn_and_mlp(prefix);
+    out.push_back({prefix + ".adaln_proj.linear.weight", {p.adaln_out_features, p.time_embed_dim}, false});
+    out.push_back({prefix + ".adaln_proj.linear.bias", {p.adaln_out_features}, false});
+  }
+
+  out.push_back({"final_layer.norm.weight", {p.hidden_size}, false});
+  out.push_back(
+      {"final_layer.adaln_proj.linear.weight", {p.final_adaln_out_features, p.time_embed_dim}, false});
+  out.push_back({"final_layer.adaln_proj.linear.bias", {p.final_adaln_out_features}, false});
+  out.push_back({"final_layer.video_out.weight", {video_patch_dim, p.hidden_size}, true});
+  out.push_back({"final_layer.video_out.bias", {video_patch_dim}, true});
+  out.push_back({"final_layer.audio_out.weight", {p.audio_latents_dim, p.hidden_size}, true});
+  out.push_back({"final_layer.audio_out.bias", {p.audio_latents_dim}, true});
+  return out;
+}
+
+// _reorder_grouped_qkv_to_qkv (minimax_h3_transformer.py:139-168).
+std::vector<float> MiniMaxH3ReorderGroupedQkv(const std::vector<float>& weight,
+                                              int64_t num_query_groups, int64_t heads_per_group,
+                                              int64_t head_dim, int64_t in_features) {
+  const int64_t per_group = (heads_per_group + 2) * head_dim;
+  const int64_t expected_out = num_query_groups * per_group;
+  VT_CHECK(static_cast<int64_t>(weight.size()) == expected_out * in_features,
+           "minimax_h3 qkv reorder: weight has incompatible output dim for the grouped layout");
+  const int64_t q_rows = num_query_groups * heads_per_group * head_dim;
+  const int64_t kv_rows = num_query_groups * head_dim;
+  std::vector<float> out(weight.size());
+  for (int64_t g = 0; g < num_query_groups; ++g) {
+    const int64_t src_base = g * per_group;
+    for (int64_t r = 0; r < heads_per_group * head_dim; ++r) {
+      const int64_t dst = g * heads_per_group * head_dim + r;
+      std::memcpy(out.data() + dst * in_features, weight.data() + (src_base + r) * in_features,
+                  static_cast<size_t>(in_features) * sizeof(float));
+    }
+    for (int64_t r = 0; r < head_dim; ++r) {
+      const int64_t src_k = src_base + heads_per_group * head_dim + r;
+      const int64_t dst_k = q_rows + g * head_dim + r;
+      std::memcpy(out.data() + dst_k * in_features, weight.data() + src_k * in_features,
+                  static_cast<size_t>(in_features) * sizeof(float));
+      const int64_t src_v = src_k + head_dim;
+      const int64_t dst_v = q_rows + kv_rows + g * head_dim + r;
+      std::memcpy(out.data() + dst_v * in_features, weight.data() + src_v * in_features,
+                  static_cast<size_t>(in_features) * sizeof(float));
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Forward
+// ---------------------------------------------------------------------------
+
+MiniMaxH3DitOutputs MiniMaxH3DitForward(vt::Device device, const MiniMaxH3DitParams& params,
+                                        const MiniMaxH3DitWeights& weights,
+                                        const MiniMaxH3DitInputs& inputs, DType compute_dtype) {
+  VT_CHECK(device.type == vt::DeviceType::kCPU,
+           "minimax_h3: the reference DiT forward is CPU-only; the device-resident "
+           "forward is brick H3-2b (.agents/specs/minimax-h3.md)");
+  VT_CHECK(compute_dtype == DType::kF32 || compute_dtype == DType::kBF16,
+           "minimax_h3: the reference DiT forward computes in f32 (parity) or bf16 "
+           "(the production stream policy)");
+  // kBF16 reproduces upstream's PRODUCTION dtype policy: the block stream is bf16
+  // while the patch projections, the time embedder, and both output heads stay
+  // fp32 islands (minimax_h3_transformer.py:85-101). Both dtypes run the SAME
+  // code; only the rounding points differ.
+  const StreamDtype dt{compute_dtype == DType::kBF16};
+  VT_CHECK(static_cast<int64_t>(weights.blocks.size()) == params.num_layers,
+           "minimax_h3: block weight count does not match num_layers");
+  VT_CHECK(static_cast<int64_t>(weights.refiner.size()) == params.token_refiner_num_layers,
+           "minimax_h3: refiner weight count does not match token_refiner_num_layers");
+  VT_CHECK(inputs.num_cu_seqlens >= 2, "minimax_h3: packed_seq_params.cu_seqlens is required");
+
+  vt::Queue q{device, nullptr};
+  const int64_t seq_len = inputs.seq_len;
+  const int64_t hidden = params.hidden_size;
+  const int64_t video_width = params.video_row_width();
+  const int64_t m = inputs.num_unique_timesteps;
+
+  // --- RoPE over the full packed sequence (minimax_h3_transformer.py:1040-1041) ---
+  const std::vector<float> inv_freq(weights.rope_inv_freq.Ptr<float>(),
+                                    weights.rope_inv_freq.Ptr<float>() + params.rope_inv_freq_len);
+  const std::vector<float> freqs =
+      RopeFreqs(inputs.img_position_ids, seq_len, inv_freq.data(), params.rope_inv_freq_len);
+
+  // --- _embed (minimax_h3_transformer.py:944-984) ---
+  std::vector<float> video_rows(static_cast<size_t>(inputs.num_img_pos * video_width));
+  for (int64_t r = 0; r < inputs.num_img_pos; ++r) {
+    std::memcpy(video_rows.data() + r * video_width, inputs.x + inputs.img_pos[r] * video_width,
+                static_cast<size_t>(video_width) * sizeof(float));
+  }
+  std::vector<float> video_embed(static_cast<size_t>(inputs.num_img_pos * hidden));
+  Linear(q, video_rows.data(), inputs.num_img_pos, video_width, weights.video_patch_proj_w,
+         &weights.video_patch_proj_b, video_embed.data());
+
+  const int64_t audio_width = params.audio_latents_dim;
+  std::vector<float> audio_rows(static_cast<size_t>(inputs.num_audio_pos * audio_width));
+  for (int64_t r = 0; r < inputs.num_audio_pos; ++r) {
+    std::memcpy(audio_rows.data() + r * audio_width,
+                inputs.audio_x + inputs.audio_pos[r] * audio_width,
+                static_cast<size_t>(audio_width) * sizeof(float));
+  }
+  std::vector<float> audio_embed(static_cast<size_t>(inputs.num_audio_pos * hidden));
+  Linear(q, audio_rows.data(), inputs.num_audio_pos, audio_width, weights.audio_patch_proj_w,
+         &weights.audio_patch_proj_b, audio_embed.data());
+
+  std::vector<float> text_embed(static_cast<size_t>(inputs.num_text_pos * hidden));
+  {
+    // text rows enter as the stream dtype before the BF16 condition projection.
+    std::vector<float> text_rows(inputs.prompt_embeds,
+                                 inputs.prompt_embeds + inputs.num_text_pos * params.text_dim);
+    dt.Apply(text_rows);
+    Linear(q, text_rows.data(), inputs.num_text_pos, params.text_dim, weights.condition_proj_w,
+           &weights.condition_proj_b, text_embed.data());
+    dt.Apply(text_embed);
+  }
+
+  // Token refiner: a plain pre-norm stack, no AdaLN and no RoPE
+  // (minimax_h3_transformer.py:564-623). It runs on the REPLICATED text rows, so
+  // it uses the refiner's own cu_seqlens.
+  {
+    const int64_t rows = inputs.num_text_pos;
+    std::vector<float> normed(text_embed.size()), tmp(text_embed.size());
+    for (const MiniMaxH3DitBlockWeights& block : weights.refiner) {
+      RmsNormRows(text_embed.data(), block.norm1.Ptr<float>(), normed.data(), rows, hidden,
+                  params.norm_eps);
+      dt.Apply(normed.data(), rows * hidden);
+      AttentionForward(q, params, AttnOf(block), normed.data(), rows, nullptr,
+                       inputs.refiner_cu_seqlens,
+                       static_cast<int>(inputs.num_refiner_cu_seqlens - 1), dt, tmp.data());
+      for (size_t i = 0; i < text_embed.size(); ++i) text_embed[i] = dt(text_embed[i] + tmp[i]);
+      RmsNormRows(text_embed.data(), block.norm2.Ptr<float>(), normed.data(), rows, hidden,
+                  params.norm_eps);
+      dt.Apply(normed.data(), rows * hidden);
+      MlpForward(q, params, block.fc1, block.fc2, normed.data(), rows, dt, tmp.data());
+      for (size_t i = 0; i < text_embed.size(); ++i) text_embed[i] = dt(text_embed[i] + tmp[i]);
+    }
+    std::vector<float> final_normed(text_embed.size());
+    RmsNormRows(text_embed.data(), weights.refiner_final_norm.Ptr<float>(), final_normed.data(),
+                rows, hidden, params.final_norm_eps);
+    dt.Apply(final_normed);
+    text_embed.swap(final_normed);
+  }
+
+  // index_add_ scatter of the three modality embeddings into the packed stream.
+  std::vector<float> stream(static_cast<size_t>(seq_len * hidden), 0.0f);
+  auto scatter = [&](const int64_t* pos, int64_t count, const std::vector<float>& src) {
+    for (int64_t r = 0; r < count; ++r) {
+      float* dst = stream.data() + pos[r] * hidden;
+      const float* s = src.data() + r * hidden;
+      for (int64_t i = 0; i < hidden; ++i) dst[i] += s[i];
+    }
+  };
+  // The patch projections are fp32 islands; their outputs enter the bf16 stream
+  // only at this indexed scatter (minimax_h3_transformer.py:978-981).
+  dt.Apply(text_embed);
+  dt.Apply(video_embed);
+  dt.Apply(audio_embed);
+  scatter(inputs.text_pos, inputs.num_text_pos, text_embed);
+  scatter(inputs.img_pos, inputs.num_img_pos, video_embed);
+  scatter(inputs.audio_pos, inputs.num_audio_pos, audio_embed);
+  dt.Apply(stream);
+
+  // --- time embedding (minimax_h3_transformer.py:272-285) ---
+  std::vector<float> t_emb(static_cast<size_t>(m * params.time_embed_dim));
+  {
+    const int64_t half = params.timestep_input_dim / 2;
+    std::vector<float> t_freq(static_cast<size_t>(m * params.timestep_input_dim));
+    for (int64_t r = 0; r < m; ++r) {
+      for (int64_t i = 0; i < half; ++i) {
+        const double freq =
+            std::exp(-std::log(10000.0) * static_cast<double>(i) / static_cast<double>(half));
+        const double arg = static_cast<double>(inputs.unique_timesteps[r]) * freq;
+        // Cosine values are concatenated BEFORE sine values.
+        t_freq[static_cast<size_t>(r * params.timestep_input_dim + i)] =
+            static_cast<float>(std::cos(arg));
+        t_freq[static_cast<size_t>(r * params.timestep_input_dim + half + i)] =
+            static_cast<float>(std::sin(arg));
+      }
+    }
+    std::vector<float> mid(static_cast<size_t>(m * params.time_embed_hidden_size));
+    Linear(q, t_freq.data(), m, params.timestep_input_dim, weights.time_proj_in_w,
+           &weights.time_proj_in_b, mid.data());
+    for (float& value : mid) value = Silu(value);
+    Linear(q, mid.data(), m, params.time_embed_hidden_size, weights.time_proj_out_w,
+           &weights.time_proj_out_b, t_emb.data());
+  }
+
+  // combined_indices = inverse_indices * modality_num + token_tags.clamp(min=0)
+  // (minimax_h3_transformer.py:1057).
+  std::vector<int64_t> combined(static_cast<size_t>(seq_len));
+  for (int64_t i = 0; i < seq_len; ++i) {
+    const int64_t tag = inputs.token_tags[i] < 0 ? 0 : inputs.token_tags[i];
+    combined[static_cast<size_t>(i)] = inputs.inverse_indices[i] * kMiniMaxH3AdalnModalityNum + tag;
+  }
+
+  // --- the DiT block stack (minimax_h3_transformer.py:645-688) ---
+  const int num_reqs = static_cast<int>(inputs.num_cu_seqlens - 1);
+  std::vector<float> normed(stream.size()), tmp(stream.size());
+  for (const MiniMaxH3DitBlockWeights& block : weights.blocks) {
+    const std::vector<float> projected =
+        AdalnProject(q, t_emb.data(), m, params.time_embed_dim, block.adaln_w, block.adaln_b, dt);
+    const std::vector<float> shift_msa =
+        AdalnChunk(projected, m, kMiniMaxH3AdalnModalityNum, hidden, 6, 0);
+    const std::vector<float> scale_msa =
+        AdalnChunk(projected, m, kMiniMaxH3AdalnModalityNum, hidden, 6, 1);
+    const std::vector<float> gate_msa =
+        AdalnChunk(projected, m, kMiniMaxH3AdalnModalityNum, hidden, 6, 2);
+    const std::vector<float> shift_mlp =
+        AdalnChunk(projected, m, kMiniMaxH3AdalnModalityNum, hidden, 6, 3);
+    const std::vector<float> scale_mlp =
+        AdalnChunk(projected, m, kMiniMaxH3AdalnModalityNum, hidden, 6, 4);
+    const std::vector<float> gate_mlp =
+        AdalnChunk(projected, m, kMiniMaxH3AdalnModalityNum, hidden, 6, 5);
+
+    RmsNormRows(stream.data(), block.norm1.Ptr<float>(), normed.data(), seq_len, hidden,
+                params.norm_eps);
+    dt.Apply(normed);
+    ModulateScaleShift(normed.data(), seq_len, hidden, shift_msa.data(), scale_msa.data(),
+                       combined.data());
+    dt.Apply(normed);  // _modulate_scale_shift casts its result to the stream dtype
+    AttentionForward(q, params, AttnOf(block), normed.data(), seq_len, freqs.data(),
+                     inputs.cu_seqlens, num_reqs, dt, tmp.data());
+    ModulateGate(stream.data(), seq_len, hidden, gate_msa.data(), tmp.data(), combined.data());
+    dt.Apply(stream);
+
+    RmsNormRows(stream.data(), block.norm2.Ptr<float>(), normed.data(), seq_len, hidden,
+                params.norm_eps);
+    dt.Apply(normed);
+    ModulateScaleShift(normed.data(), seq_len, hidden, shift_mlp.data(), scale_mlp.data(),
+                       combined.data());
+    dt.Apply(normed);
+    MlpForward(q, params, block.fc1, block.fc2, normed.data(), seq_len, dt, tmp.data());
+    ModulateGate(stream.data(), seq_len, hidden, gate_mlp.data(), tmp.data(), combined.data());
+    dt.Apply(stream);
+  }
+
+  // --- final layer (minimax_h3_transformer.py:724-743) ---
+  const std::vector<float> final_projected =
+      AdalnProject(q, t_emb.data(), m, params.time_embed_dim, weights.final_adaln_w,
+                   weights.final_adaln_b, dt);
+  const std::vector<float> final_shift = AdalnChunk(final_projected, m, 1, hidden, 2, 0);
+  const std::vector<float> final_scale = AdalnChunk(final_projected, m, 1, hidden, 2, 1);
+  RmsNormRows(stream.data(), weights.final_norm.Ptr<float>(), normed.data(), seq_len, hidden,
+              params.final_norm_eps);
+  dt.Apply(normed);
+  // The final layer is single-modality, so it indexes by inverse_indices directly.
+  std::vector<int64_t> inverse(inputs.inverse_indices, inputs.inverse_indices + seq_len);
+  ModulateScaleShift(normed.data(), seq_len, hidden, final_shift.data(), final_scale.data(),
+                     inverse.data());
+  // Cast UP before both output heads: they are fp32 islands.
+  dt.Apply(normed);
+
+  std::vector<float> video_all(static_cast<size_t>(seq_len * video_width));
+  Linear(q, normed.data(), seq_len, hidden, weights.video_out_w, &weights.video_out_b,
+         video_all.data());
+  std::vector<float> audio_all(static_cast<size_t>(seq_len * audio_width));
+  Linear(q, normed.data(), seq_len, hidden, weights.audio_out_w, &weights.audio_out_b,
+         audio_all.data());
+
+  // Select the inference-output rows, then zero the pinned condition rows
+  // (minimax_h3_transformer.py:1087-1101).
+  MiniMaxH3DitOutputs out;
+  out.video_logits.resize(static_cast<size_t>(inputs.num_infer_out_pos * video_width));
+  for (int64_t r = 0; r < inputs.num_infer_out_pos; ++r) {
+    std::memcpy(out.video_logits.data() + r * video_width,
+                video_all.data() + inputs.infer_out_pos[r] * video_width,
+                static_cast<size_t>(video_width) * sizeof(float));
+  }
+  out.audio_logits.resize(static_cast<size_t>(inputs.num_audio_pos * audio_width));
+  for (int64_t r = 0; r < inputs.num_audio_pos; ++r) {
+    std::memcpy(out.audio_logits.data() + r * audio_width,
+                audio_all.data() + inputs.audio_pos[r] * audio_width,
+                static_cast<size_t>(audio_width) * sizeof(float));
+  }
+  if (!inputs.skip_mask_out_condition) {
+    VT_CHECK(inputs.update_mask != nullptr, "minimax_h3: update_mask is required");
+    for (int64_t r = 0; r < inputs.num_infer_out_pos; ++r) {
+      if (inputs.update_mask[r]) continue;
+      std::fill_n(out.video_logits.data() + r * video_width, video_width, 0.0f);
+    }
+    if (inputs.audio_update_mask != nullptr) {
+      for (int64_t r = 0; r < inputs.num_audio_pos; ++r) {
+        if (inputs.audio_update_mask[r]) continue;
+        std::fill_n(out.audio_logits.data() + r * audio_width, audio_width, 0.0f);
+      }
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Denoise loop (denoise_loop.py:129-239)
+// ---------------------------------------------------------------------------
+
+MiniMaxH3DenoiseResult MiniMaxH3DenoiseLoop(
+    vt::Device device, const MiniMaxH3DitParams& params, const MiniMaxH3DitWeights& weights,
+    const MiniMaxH3DenoiseBranch& branch, const std::vector<float>& initial_video_rows,
+    const std::vector<float>& initial_audio_rows, const std::vector<float>& keyframe_cond_rows,
+    const std::vector<float>& audio_ref_rows, const std::vector<double>& sigmas_video,
+    const std::vector<double>& sigmas_audio, DType compute_dtype,
+    const MiniMaxH3DitDeviceWeights* prestaged) {
+  VT_CHECK(sigmas_video.size() == sigmas_audio.size(),
+           "minimax_h3 denoise: video/audio sigma schedules must have equal length");
+  VT_CHECK(sigmas_video.size() >= 2, "minimax_h3 denoise: sigma schedules need at least 2 entries");
+
+  // DEVICE PATH. On a non-CPU device the per-step forward runs device-resident, and
+  // the weights are staged ONCE here rather than per step — a 50-step loop that
+  // re-uploaded ~16 GB every iteration would be dominated by the transfer. This is
+  // exactly what StageMiniMaxH3DitWeights exists for.
+  const bool on_device = device.type != vt::DeviceType::kCPU;
+  // VT_H3_PROGRESS=1 traces the phases to stderr. A 50-step loop over a real
+  // checkpoint spends minutes in ONE of {weight staging, per-step forward}, and
+  // guessing which is exactly the trap this avoids.
+  const bool trace = std::getenv("VT_H3_PROGRESS") != nullptr;
+  auto now = [] { return std::chrono::steady_clock::now(); };
+  vt::Queue device_queue{device, nullptr};
+  MiniMaxH3DitDeviceWeights staged;
+  if (on_device) {
+    vt::Backend& backend = vt::GetBackend(device.type);
+    device_queue = backend.CreateQueue();
+    const auto t0 = now();
+    if (prestaged == nullptr) {
+      staged = StageMiniMaxH3DitWeights(device_queue, params, weights, compute_dtype);
+    }
+    if (trace) {
+      std::fprintf(stderr, "[h3] staged weights to device in %.1f s\n",
+                   std::chrono::duration<double>(now() - t0).count());
+    }
+  } else if (trace) {
+    std::fprintf(stderr, "[h3] CPU reference forward (device.type == kCPU)\n");
+  }
+
+  const MiniMaxH3PackedSequence& packed = branch.packed;
+  const int64_t seq_len = packed.seq_len;
+  const int64_t video_width = params.video_row_width();
+  const int64_t audio_width = params.audio_latents_dim;
+  const int64_t num_img = static_cast<int64_t>(packed.img_pos.size());
+  const int64_t num_audio = static_cast<int64_t>(packed.audio_pos.size());
+
+  VT_CHECK(static_cast<int64_t>(initial_video_rows.size()) == num_img * video_width,
+           "minimax_h3 denoise: initial video rows do not match the layout");
+  VT_CHECK(static_cast<int64_t>(initial_audio_rows.size()) == num_audio * audio_width,
+           "minimax_h3 denoise: initial audio rows do not match the layout");
+
+  std::vector<uint8_t> audio_update = packed.audio_update_mask;
+  if (audio_update.empty()) audio_update.assign(static_cast<size_t>(num_audio), 1);
+
+  MiniMaxH3DenoiseResult result;
+  result.video_rows = initial_video_rows;
+  result.audio_rows = initial_audio_rows;
+
+  // Pin the conditioning anchors before the first step.
+  int64_t cond_index = 0;
+  for (int64_t r = 0; r < num_img; ++r) {
+    if (packed.update_mask[static_cast<size_t>(r)]) continue;
+    VT_CHECK(static_cast<int64_t>(keyframe_cond_rows.size()) >= (cond_index + 1) * video_width,
+             "minimax_h3 denoise: keyframe_cond_rows shorter than the layout's condition rows");
+    std::memcpy(result.video_rows.data() + r * video_width,
+                keyframe_cond_rows.data() + cond_index * video_width,
+                static_cast<size_t>(video_width) * sizeof(float));
+    ++cond_index;
+  }
+  int64_t audio_ref_index = 0;
+  for (int64_t r = 0; r < num_audio; ++r) {
+    if (audio_update[static_cast<size_t>(r)]) continue;
+    VT_CHECK(static_cast<int64_t>(audio_ref_rows.size()) >= (audio_ref_index + 1) * audio_width,
+             "minimax_h3 denoise: audio_ref_rows shorter than the layout's reference rows");
+    std::memcpy(result.audio_rows.data() + r * audio_width,
+                audio_ref_rows.data() + audio_ref_index * audio_width,
+                static_cast<size_t>(audio_width) * sizeof(float));
+    ++audio_ref_index;
+  }
+
+  const int64_t num_steps = static_cast<int64_t>(sigmas_video.size()) - 1;
+  for (int64_t step = 0; step < num_steps; ++step) {
+    const double s_v = sigmas_video[static_cast<size_t>(step)];
+    const double s_v_next = sigmas_video[static_cast<size_t>(step + 1)];
+    const double s_a = sigmas_audio[static_cast<size_t>(step)];
+    const double s_a_next = sigmas_audio[static_cast<size_t>(step + 1)];
+    const double t_v = 1.0 - s_v, t_a = 1.0 - s_a;
+    const double imgvid_cond_t = std::max(t_v, kMiniMaxH3ImgVidCondTimestep);
+    const double audio_ref_cond_t = std::max(t_a, kMiniMaxH3AudioRefCondTimestep);
+
+    // MiniMaxH3DenoiseBranch.forward_kwargs (denoise_loop.py:91-126): scatter the
+    // current rows back into the packed stream and rebuild the per-row timesteps.
+    std::vector<float> x(static_cast<size_t>(seq_len * video_width), 0.0f);
+    for (int64_t r = 0; r < num_img; ++r) {
+      std::memcpy(x.data() + packed.img_pos[static_cast<size_t>(r)] * video_width,
+                  result.video_rows.data() + r * video_width,
+                  static_cast<size_t>(video_width) * sizeof(float));
+    }
+    std::vector<float> audio_x(static_cast<size_t>(seq_len * audio_width), 0.0f);
+    for (int64_t r = 0; r < num_audio; ++r) {
+      std::memcpy(audio_x.data() + packed.audio_pos[static_cast<size_t>(r)] * audio_width,
+                  result.audio_rows.data() + r * audio_width,
+                  static_cast<size_t>(audio_width) * sizeof(float));
+    }
+
+    // Non-media rows (text and padding) inherit the current VIDEO timestep.
+    std::vector<float> timesteps(static_cast<size_t>(seq_len), static_cast<float>(t_v));
+    for (int64_t r = 0; r < num_img; ++r) {
+      timesteps[static_cast<size_t>(packed.img_pos[static_cast<size_t>(r)])] =
+          packed.update_mask[static_cast<size_t>(r)] ? static_cast<float>(t_v)
+                                                     : static_cast<float>(imgvid_cond_t);
+    }
+    for (int64_t r = 0; r < num_audio; ++r) {
+      timesteps[static_cast<size_t>(packed.audio_pos[static_cast<size_t>(r)])] =
+          audio_update[static_cast<size_t>(r)] ? static_cast<float>(t_a)
+                                               : static_cast<float>(audio_ref_cond_t);
+    }
+
+    // torch.unique(sorted=True, return_inverse=True).
+    std::vector<float> unique = timesteps;
+    std::sort(unique.begin(), unique.end());
+    unique.erase(std::unique(unique.begin(), unique.end()), unique.end());
+    std::vector<int64_t> inverse(static_cast<size_t>(seq_len));
+    for (int64_t i = 0; i < seq_len; ++i) {
+      inverse[static_cast<size_t>(i)] = static_cast<int64_t>(
+          std::lower_bound(unique.begin(), unique.end(), timesteps[static_cast<size_t>(i)]) -
+          unique.begin());
+    }
+
+    MiniMaxH3DitInputs in;
+    in.seq_len = seq_len;
+    in.x = x.data();
+    in.audio_x = audio_x.data();
+    in.img_position_ids = packed.img_position_ids.data();
+    in.unique_timesteps = unique.data();
+    in.num_unique_timesteps = static_cast<int64_t>(unique.size());
+    in.inverse_indices = inverse.data();
+    in.token_tags = branch.token_tags.data();
+    in.prompt_embeds = branch.text_embeddings.data();
+    in.img_pos = packed.img_pos.data();
+    in.num_img_pos = num_img;
+    in.audio_pos = packed.audio_pos.data();
+    in.num_audio_pos = num_audio;
+    in.text_pos = packed.text_pos.data();
+    in.num_text_pos = static_cast<int64_t>(packed.text_pos.size());
+    in.infer_out_pos = packed.img_pos.data();
+    in.num_infer_out_pos = num_img;
+    in.update_mask = packed.update_mask.data();
+    in.audio_update_mask = packed.audio_update_mask.empty() ? nullptr : audio_update.data();
+    in.cu_seqlens = packed.cu_seqlens.data();
+    in.num_cu_seqlens = static_cast<int64_t>(packed.cu_seqlens.size());
+    const int32_t text_len = static_cast<int32_t>(packed.text_pos.size());
+    const std::vector<int32_t> refiner_cu = {0, text_len, text_len};
+    in.refiner_cu_seqlens = refiner_cu.data();
+    in.num_refiner_cu_seqlens = static_cast<int64_t>(refiner_cu.size());
+
+    const auto step_t0 = now();
+    const MiniMaxH3DitOutputs velocity =
+        on_device ? MiniMaxH3DitForwardDevice(
+                        device_queue, params,
+                        prestaged != nullptr ? prestaged->weights : staged.weights, in,
+                        compute_dtype)
+                  : MiniMaxH3DitForward(device, params, weights, in, compute_dtype);
+    if (trace) {
+      std::fprintf(stderr, "[h3] step %d/%d forward %.2f s (seq_len=%lld)\n",
+                   static_cast<int>(step + 1), static_cast<int>(sigmas_video.size() - 1),
+                   std::chrono::duration<double>(now() - step_t0).count(),
+                   static_cast<long long>(seq_len));
+      std::fflush(stderr);
+    }
+
+    // Chain only the TARGET rows; pinned rows are reset to their anchors after
+    // every step (denoise_loop.py:210-235).
+    auto advance = [&](std::vector<float>& rows, const std::vector<float>& v,
+                       const std::vector<uint8_t>& mask, int64_t count, int64_t width, double t,
+                       double sigma_curr, double sigma_next) {
+      std::vector<float> target, target_v;
+      target.reserve(static_cast<size_t>(count * width));
+      target_v.reserve(static_cast<size_t>(count * width));
+      for (int64_t r = 0; r < count; ++r) {
+        if (!mask[static_cast<size_t>(r)]) continue;
+        target.insert(target.end(), rows.begin() + r * width, rows.begin() + (r + 1) * width);
+        target_v.insert(target_v.end(), v.begin() + r * width, v.begin() + (r + 1) * width);
+      }
+      const std::vector<float> x0 = MiniMaxH3RfVToX0(target, target_v, t);
+      const std::vector<float> stepped = MiniMaxH3EulerEta0Step(target, x0, sigma_curr, sigma_next);
+      int64_t k = 0;
+      for (int64_t r = 0; r < count; ++r) {
+        if (!mask[static_cast<size_t>(r)]) continue;
+        std::memcpy(rows.data() + r * width, stepped.data() + k * width,
+                    static_cast<size_t>(width) * sizeof(float));
+        ++k;
+      }
+    };
+
+    advance(result.video_rows, velocity.video_logits, packed.update_mask, num_img, video_width, t_v,
+            s_v, s_v_next);
+    cond_index = 0;
+    for (int64_t r = 0; r < num_img; ++r) {
+      if (packed.update_mask[static_cast<size_t>(r)]) continue;
+      std::memcpy(result.video_rows.data() + r * video_width,
+                  keyframe_cond_rows.data() + cond_index * video_width,
+                  static_cast<size_t>(video_width) * sizeof(float));
+      ++cond_index;
+    }
+
+    advance(result.audio_rows, velocity.audio_logits, audio_update, num_audio, audio_width, t_a,
+            s_a, s_a_next);
+    audio_ref_index = 0;
+    for (int64_t r = 0; r < num_audio; ++r) {
+      if (audio_update[static_cast<size_t>(r)]) continue;
+      std::memcpy(result.audio_rows.data() + r * audio_width,
+                  audio_ref_rows.data() + audio_ref_index * audio_width,
+                  static_cast<size_t>(audio_width) * sizeof(float));
+      ++audio_ref_index;
+    }
+  }
+  return result;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_audio_vae.cpp b/src/vllm/model_executor/models/minimax_h3_audio_vae.cpp
new file mode 100644
index 000000000..349bfd1ee
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_audio_vae.cpp
@@ -0,0 +1,994 @@
+// MiniMax-H3 AUDIO VAE — a DAC-lineage encoder + BigVGAN vocoder, REIMPLEMENTED.
+//
+// Two halves live here. The DECODER (synthesis) is what generation needs; the
+// ENCODER (analysis, at the bottom of this file) is what a REFERENCE AUDIO needs,
+// because ref2va conditions on rows produced from a supplied waveform.
+//
+// ─── WHY REIMPLEMENTED AND NOT ADAPTED ───────────────────────────────────────
+// H3's two VAEs are checkpoint REMOTE CODE: their implementations ship inside the
+// HF repo (`FL2VA/audio_vae/*.py`) and are loaded through
+// `get_class_from_dynamic_module` under `trust_remote_code`; vLLM-Omni's `vae.py`
+// only ADAPTS them (vae.py:41-53). A no-Python engine cannot do that, so this is a
+// from-scratch port of the checkpoint's own modules, gated against them by
+// scripts/gen-minimax-h3-audio-vae-goldens.py (which imports the remote code and
+// runs it at reduced dimensions as the oracle). The remote code is NOT vendored
+// here — it ships under the MiniMax H3 Community License with the checkpoint.
+//
+// ─── ARCHITECTURE (checkpoint config.yaml + metadata.json) ───────────────────
+//   decode(z[32, T]) = dec_in_proj (Conv1d 32 -> 2048, k=1) -> BigVGAN
+//   BigVGAN: conv_pre(2048 -> 1024, k=7)
+//            x7 [ ConvTranspose1d upsample (rates 5,5,2,2,2,2,2;
+//                                           kernels 9,9,4,4,4,4,4)
+//                 then 3 AMPBlock1 residual blocks (kernels 3,7,11,
+//                 dilations 1,3,5) whose outputs are AVERAGED ]
+//            anti-aliased SnakeBeta -> conv_post(-> 1 ch, k=7, no bias)
+//            -> clamp[-1, 1]   (use_tanh_at_final is false for H3)
+//   32 kHz, 2 channels; the DiT's audio rows are decoded per channel.
+//
+// Two details that are easy to get wrong and are gated explicitly:
+//   * Every conv is WEIGHT-NORMALIZED. The checkpoint stores (g, v) as
+//     `...parametrizations.weight.original0` / `original1`, and the effective
+//     weight is `g * v / ||v||` with the norm taken over every dim except dim 0.
+//   * The anti-aliased activation upsamples 2x, applies SnakeBeta, then
+//     downsamples 2x, both through a KAISER-SINC filter built at load time (never
+//     loaded from the checkpoint) with REPLICATE padding.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+
+const std::vector<float>& MiniMaxH3AudioVaeWeights::Get(const std::string& name) const {
+  const auto it = tensors.find(name);
+  VT_CHECK(it != tensors.end(), "minimax_h3 audio vae: missing checkpoint tensor");
+  return it->second;
+}
+
+namespace {
+
+// Zeroth-order modified Bessel function of the first kind, matching the series
+// torch.kaiser_window uses.
+double BesselI0(double x) {
+  double sum = 1.0, term = 1.0;
+  const double half_x_sq = (x / 2.0) * (x / 2.0);
+  for (int k = 1; k < 64; ++k) {
+    term *= half_x_sq / (static_cast<double>(k) * static_cast<double>(k));
+    sum += term;
+    if (term < sum * 1e-18) break;
+  }
+  return sum;
+}
+
+double Sinc(double x) {
+  if (x == 0.0) return 1.0;
+  const double pix = M_PI * x;
+  return std::sin(pix) / pix;
+}
+
+// torch.kaiser_window(n, periodic=false, beta).
+std::vector<double> KaiserWindow(int64_t length, double beta) {
+  std::vector<double> window(static_cast<size_t>(length));
+  const double denom = BesselI0(beta);
+  // periodic=false => the window spans [0, length-1] inclusive.
+  const double n_minus_1 = static_cast<double>(length - 1);
+  for (int64_t i = 0; i < length; ++i) {
+    const double ratio = (2.0 * static_cast<double>(i) - n_minus_1) / n_minus_1;
+    window[static_cast<size_t>(i)] = BesselI0(beta * std::sqrt(std::max(0.0, 1.0 - ratio * ratio))) / denom;
+  }
+  return window;
+}
+
+// One 1-D convolution over [C_in, T] with dilation/stride/groups.
+// Weight is [C_out, C_in/groups, K]; input is assumed ALREADY padded.
+std::vector<float> Conv1d(const std::vector<float>& in, int64_t in_channels, int64_t in_len,
+                          const std::vector<float>& weight, const std::vector<float>* bias,
+                          int64_t out_channels, int64_t kernel, int64_t stride, int64_t dilation,
+                          int64_t groups, int64_t* out_len) {
+  const int64_t effective = dilation * (kernel - 1) + 1;
+  const int64_t length = (in_len - effective) / stride + 1;
+  VT_CHECK(length > 0, "minimax_h3 audio vae: conv1d output length is empty");
+  const int64_t in_per_group = in_channels / groups;
+  const int64_t out_per_group = out_channels / groups;
+  std::vector<float> out(static_cast<size_t>(out_channels * length), 0.0f);
+  for (int64_t oc = 0; oc < out_channels; ++oc) {
+    const int64_t g = oc / out_per_group;
+    for (int64_t t = 0; t < length; ++t) {
+      double acc = bias != nullptr ? (*bias)[static_cast<size_t>(oc)] : 0.0;
+      for (int64_t ic = 0; ic < in_per_group; ++ic) {
+        const int64_t src_c = g * in_per_group + ic;
+        for (int64_t k = 0; k < kernel; ++k) {
+          const int64_t pos = t * stride + k * dilation;
+          acc += static_cast<double>(in[static_cast<size_t>(src_c * in_len + pos)]) *
+                 static_cast<double>(weight[static_cast<size_t>((oc * in_per_group + ic) * kernel + k)]);
+        }
+      }
+      out[static_cast<size_t>(oc * length + t)] = static_cast<float>(acc);
+    }
+  }
+  *out_len = length;
+  return out;
+}
+
+// torch.nn.functional.conv_transpose1d over [C_in, T].
+// Weight is [C_in, C_out/groups, K]; output length = (T-1)*stride - 2*padding + K.
+std::vector<float> ConvTranspose1d(const std::vector<float>& in, int64_t in_channels,
+                                   int64_t in_len, const std::vector<float>& weight,
+                                   const std::vector<float>* bias, int64_t out_channels,
+                                   int64_t kernel, int64_t stride, int64_t padding, int64_t groups,
+                                   int64_t* out_len) {
+  const int64_t full = (in_len - 1) * stride + kernel;
+  const int64_t length = full - 2 * padding;
+  VT_CHECK(length > 0, "minimax_h3 audio vae: conv_transpose1d output length is empty");
+  const int64_t in_per_group = in_channels / groups;
+  const int64_t out_per_group = out_channels / groups;
+  std::vector<double> acc(static_cast<size_t>(out_channels * full), 0.0);
+  for (int64_t ic = 0; ic < in_channels; ++ic) {
+    const int64_t g = ic / in_per_group;
+    for (int64_t t = 0; t < in_len; ++t) {
+      const double value = in[static_cast<size_t>(ic * in_len + t)];
+      if (value == 0.0) continue;
+      for (int64_t oc = 0; oc < out_per_group; ++oc) {
+        const int64_t dst_c = g * out_per_group + oc;
+        for (int64_t k = 0; k < kernel; ++k) {
+          acc[static_cast<size_t>(dst_c * full + t * stride + k)] +=
+              value * static_cast<double>(weight[static_cast<size_t>((ic * out_per_group + oc) * kernel + k)]);
+        }
+      }
+    }
+  }
+  std::vector<float> out(static_cast<size_t>(out_channels * length));
+  for (int64_t c = 0; c < out_channels; ++c) {
+    for (int64_t t = 0; t < length; ++t) {
+      double value = acc[static_cast<size_t>(c * full + t + padding)];
+      if (bias != nullptr) value += (*bias)[static_cast<size_t>(c)];
+      out[static_cast<size_t>(c * length + t)] = static_cast<float>(value);
+    }
+  }
+  *out_len = length;
+  return out;
+}
+
+// F.pad(..., mode="replicate") along the time axis.
+std::vector<float> PadReplicate(const std::vector<float>& in, int64_t channels, int64_t in_len,
+                                int64_t left, int64_t right, int64_t* out_len) {
+  const int64_t length = in_len + left + right;
+  std::vector<float> out(static_cast<size_t>(channels * length));
+  for (int64_t c = 0; c < channels; ++c) {
+    for (int64_t t = 0; t < length; ++t) {
+      int64_t src = t - left;
+      src = std::max<int64_t>(0, std::min<int64_t>(in_len - 1, src));
+      out[static_cast<size_t>(c * length + t)] = in[static_cast<size_t>(c * in_len + src)];
+    }
+  }
+  *out_len = length;
+  return out;
+}
+
+// SnakeBeta: x + (beta + 1e-9)^-1 * sin^2(alpha * x), with alpha/beta exponentiated
+// when the checkpoint stores them in log scale (H3 does).
+void SnakeBeta(std::vector<float>& x, int64_t channels, int64_t length,
+               const std::vector<float>& alpha, const std::vector<float>& beta, bool logscale) {
+  for (int64_t c = 0; c < channels; ++c) {
+    double a = alpha[static_cast<size_t>(c)];
+    double b = beta[static_cast<size_t>(c)];
+    if (logscale) {
+      a = std::exp(a);
+      b = std::exp(b);
+    }
+    const double inv_beta = 1.0 / (b + 1e-9);
+    for (int64_t t = 0; t < length; ++t) {
+      const double v = x[static_cast<size_t>(c * length + t)];
+      const double s = std::sin(a * v);
+      x[static_cast<size_t>(c * length + t)] = static_cast<float>(v + inv_beta * s * s);
+    }
+  }
+}
+
+}  // namespace
+
+// kaiser_sinc_filter1d (dac_alias_free_filter.py:26-60). Returns [kernel_size].
+std::vector<float> MiniMaxH3KaiserSincFilter1d(double cutoff, double half_width,
+                                               int64_t kernel_size) {
+  VT_CHECK(kernel_size > 0, "minimax_h3 audio vae: kernel_size must be positive");
+  VT_CHECK(cutoff >= 0.0 && cutoff <= 0.5, "minimax_h3 audio vae: cutoff must be in [0, 0.5]");
+  const bool even = (kernel_size % 2) == 0;
+  const int64_t half_size = kernel_size / 2;
+
+  const double delta_f = 4.0 * half_width;
+  const double a = 2.285 * (static_cast<double>(half_size) - 1.0) * M_PI * delta_f + 7.95;
+  double beta = 0.0;
+  if (a > 50.0) {
+    beta = 0.1102 * (a - 8.7);
+  } else if (a >= 21.0) {
+    beta = 0.5842 * std::pow(a - 21.0, 0.4) + 0.07886 * (a - 21.0);
+  }
+  const std::vector<double> window = KaiserWindow(kernel_size, beta);
+
+  std::vector<double> time(static_cast<size_t>(kernel_size));
+  for (int64_t i = 0; i < kernel_size; ++i) {
+    time[static_cast<size_t>(i)] = even ? (static_cast<double>(-half_size + i) + 0.5)
+                                        : static_cast<double>(i - half_size);
+  }
+
+  std::vector<double> filter(static_cast<size_t>(kernel_size), 0.0);
+  if (cutoff == 0.0) {
+    return std::vector<float>(static_cast<size_t>(kernel_size), 0.0f);
+  }
+  double sum = 0.0;
+  for (int64_t i = 0; i < kernel_size; ++i) {
+    filter[static_cast<size_t>(i)] =
+        2.0 * cutoff * window[static_cast<size_t>(i)] * Sinc(2.0 * cutoff * time[static_cast<size_t>(i)]);
+    sum += filter[static_cast<size_t>(i)];
+  }
+  // Normalized to sum 1 so a constant input does not leak.
+  std::vector<float> out(static_cast<size_t>(kernel_size));
+  for (int64_t i = 0; i < kernel_size; ++i) {
+    out[static_cast<size_t>(i)] = static_cast<float>(filter[static_cast<size_t>(i)] / sum);
+  }
+  return out;
+}
+
+// torch weight_norm: w = g * v / ||v||, norm over every dim except dim 0.
+std::vector<float> MiniMaxH3MaterializeWeightNorm(const std::vector<float>& g,
+                                                  const std::vector<float>& v,
+                                                  int64_t out_channels) {
+  VT_CHECK(out_channels > 0 && v.size() % static_cast<size_t>(out_channels) == 0,
+           "minimax_h3 audio vae: weight-norm direction does not divide by out_channels");
+  const int64_t per_out = static_cast<int64_t>(v.size()) / out_channels;
+  VT_CHECK(static_cast<int64_t>(g.size()) == out_channels,
+           "minimax_h3 audio vae: weight-norm magnitude must have one value per output channel");
+  std::vector<float> out(v.size());
+  for (int64_t c = 0; c < out_channels; ++c) {
+    double norm = 0.0;
+    for (int64_t i = 0; i < per_out; ++i) {
+      const double value = v[static_cast<size_t>(c * per_out + i)];
+      norm += value * value;
+    }
+    norm = std::sqrt(norm);
+    const double scale = norm > 0.0 ? static_cast<double>(g[static_cast<size_t>(c)]) / norm : 0.0;
+    for (int64_t i = 0; i < per_out; ++i) {
+      out[static_cast<size_t>(c * per_out + i)] =
+          static_cast<float>(v[static_cast<size_t>(c * per_out + i)] * scale);
+    }
+  }
+  return out;
+}
+
+namespace {
+
+// The anti-aliased activation: upsample 2x -> SnakeBeta -> downsample 2x
+// (dac_alias_free_act.py + dac_alias_free_resample.py).
+struct AliasFreeActivation {
+  int64_t ratio = 2;
+  int64_t kernel_size = 12;
+  std::vector<float> up_filter;
+  std::vector<float> down_filter;
+
+  void Build() {
+    up_filter = MiniMaxH3KaiserSincFilter1d(0.5 / static_cast<double>(ratio),
+                                            0.6 / static_cast<double>(ratio), kernel_size);
+    down_filter = up_filter;  // same cutoff/half_width/kernel for ratio 2
+  }
+
+  std::vector<float> Apply(const std::vector<float>& in, int64_t channels, int64_t in_len,
+                           const std::vector<float>& alpha, const std::vector<float>& beta,
+                           bool logscale, int64_t* out_len) const {
+    // --- UpSample1d ---
+    const int64_t pad = kernel_size / ratio - 1;
+    const int64_t pad_left = pad * ratio + (kernel_size - ratio) / 2;
+    const int64_t pad_right = pad * ratio + (kernel_size - ratio + 1) / 2;
+    int64_t padded_len = 0;
+    const std::vector<float> padded = PadReplicate(in, channels, in_len, pad, pad, &padded_len);
+    // Depthwise transposed conv: filter.expand(C, -1, -1) => weight [C, 1, K].
+    std::vector<float> up_weight(static_cast<size_t>(channels * kernel_size));
+    for (int64_t c = 0; c < channels; ++c) {
+      for (int64_t k = 0; k < kernel_size; ++k) {
+        up_weight[static_cast<size_t>(c * kernel_size + k)] = up_filter[static_cast<size_t>(k)];
+      }
+    }
+    int64_t up_len = 0;
+    std::vector<float> up = ConvTranspose1d(padded, channels, padded_len, up_weight, nullptr,
+                                            channels, kernel_size, ratio, /*padding=*/0,
+                                            /*groups=*/channels, &up_len);
+    for (float& value : up) value *= static_cast<float>(ratio);
+    // x[..., pad_left : -pad_right]
+    const int64_t trimmed_len = up_len - pad_left - pad_right;
+    VT_CHECK(trimmed_len > 0, "minimax_h3 audio vae: upsample trim emptied the signal");
+    std::vector<float> trimmed(static_cast<size_t>(channels * trimmed_len));
+    for (int64_t c = 0; c < channels; ++c) {
+      for (int64_t t = 0; t < trimmed_len; ++t) {
+        trimmed[static_cast<size_t>(c * trimmed_len + t)] =
+            up[static_cast<size_t>(c * up_len + pad_left + t)];
+      }
+    }
+
+    // --- SnakeBeta ---
+    SnakeBeta(trimmed, channels, trimmed_len, alpha, beta, logscale);
+
+    // --- DownSample1d (LowPassFilter1d, stride = ratio, replicate padding) ---
+    const bool even = (kernel_size % 2) == 0;
+    const int64_t lp_left = kernel_size / 2 - (even ? 1 : 0);
+    const int64_t lp_right = kernel_size / 2;
+    int64_t lp_padded_len = 0;
+    const std::vector<float> lp_padded =
+        PadReplicate(trimmed, channels, trimmed_len, lp_left, lp_right, &lp_padded_len);
+    std::vector<float> down_weight(static_cast<size_t>(channels * kernel_size));
+    for (int64_t c = 0; c < channels; ++c) {
+      for (int64_t k = 0; k < kernel_size; ++k) {
+        down_weight[static_cast<size_t>(c * kernel_size + k)] = down_filter[static_cast<size_t>(k)];
+      }
+    }
+    return Conv1d(lp_padded, channels, lp_padded_len, down_weight, nullptr, channels, kernel_size,
+                  /*stride=*/ratio, /*dilation=*/1, /*groups=*/channels, out_len);
+  }
+};
+
+int64_t GetPadding(int64_t kernel_size, int64_t dilation) {
+  return (kernel_size * dilation - dilation) / 2;
+}
+
+}  // namespace
+
+// BigVGAN.forward (dac_bigvgan.py:170-195) preceded by DacAudioVAE.dec_in_proj.
+std::vector<float> MiniMaxH3AudioVaeDecode(const MiniMaxH3AudioVaeConfig& config,
+                                           const MiniMaxH3AudioVaeWeights& weights,
+                                           const std::vector<float>& latent, int64_t frames,
+                                           int64_t* out_samples) {
+  const int64_t num_upsamples = static_cast<int64_t>(config.upsample_rates.size());
+  const int64_t num_kernels = static_cast<int64_t>(config.resblock_kernel_sizes.size());
+  VT_CHECK(num_upsamples > 0 && num_kernels > 0, "minimax_h3 audio vae: empty decoder config");
+  VT_CHECK(static_cast<int64_t>(config.upsample_kernel_sizes.size()) == num_upsamples,
+           "minimax_h3 audio vae: upsample rates/kernels length mismatch");
+  VT_CHECK(static_cast<int64_t>(config.resblock_dilation_sizes.size()) == num_kernels,
+           "minimax_h3 audio vae: resblock kernels/dilations length mismatch");
+  AliasFreeActivation act;
+  act.Build();
+
+  auto conv_weight = [&](const std::string& prefix, int64_t out_channels) {
+    return MiniMaxH3MaterializeWeightNorm(weights.Get(prefix + ".parametrizations.weight.original0"),
+                                          weights.Get(prefix + ".parametrizations.weight.original1"),
+                                          out_channels);
+  };
+
+  // --- dec_in_proj: Conv1d(vae_latent_channels -> num_mels, k=1) ---
+  // DacAudioVAE.decode applies this BEFORE BigVGAN (dac_audio_vae.py:218-231). It
+  // is absent when the caller already supplies a num_mels-wide tensor, which is
+  // what the standalone BigVGAN gate does.
+  std::vector<float> mels;
+  const float* mel_source = latent.data();
+  if (weights.Has("dec_in_proj.weight")) {
+    const std::vector<float>& w = weights.Get("dec_in_proj.weight");
+    VT_CHECK(static_cast<int64_t>(w.size()) % config.num_mels == 0,
+             "minimax_h3 audio vae: dec_in_proj weight does not divide by num_mels");
+    const int64_t in_channels = static_cast<int64_t>(w.size()) / config.num_mels;
+    VT_CHECK(static_cast<int64_t>(latent.size()) == in_channels * frames,
+             "minimax_h3 audio vae: latent does not match dec_in_proj input channels");
+    int64_t projected_len = 0;
+    const std::vector<float>* bias =
+        weights.Has("dec_in_proj.bias") ? &weights.Get("dec_in_proj.bias") : nullptr;
+    mels = Conv1d(latent, in_channels, frames, w, bias, config.num_mels, 1, 1, 1, 1, &projected_len);
+    VT_CHECK(projected_len == frames, "minimax_h3 audio vae: dec_in_proj changed the length");
+    mel_source = mels.data();
+  } else {
+    VT_CHECK(static_cast<int64_t>(latent.size()) == config.num_mels * frames,
+             "minimax_h3 audio vae: latent size does not match [num_mels, frames]");
+  }
+
+  // --- conv_pre: Conv1d(num_mels -> upsample_initial_channel, k=7, padding=3) ---
+  int64_t channels = config.upsample_initial_channel;
+  int64_t length = 0;
+  std::vector<float> x;
+  {
+    std::vector<float> padded(static_cast<size_t>(config.num_mels * (frames + 6)), 0.0f);
+    for (int64_t c = 0; c < config.num_mels; ++c) {
+      for (int64_t t = 0; t < frames; ++t) {
+        padded[static_cast<size_t>(c * (frames + 6) + 3 + t)] = mel_source[c * frames + t];
+      }
+    }
+    const int64_t padded_len = frames + 6;  // zero padding 3 on each side
+    const std::vector<float> w = conv_weight("conv_pre", channels);
+    const std::vector<float>& b = weights.Get("conv_pre.bias");
+    x = Conv1d(padded, config.num_mels, padded_len, w, &b, channels, 7, 1, 1, 1, &length);
+  }
+
+  // --- upsample stages ---
+  for (int64_t i = 0; i < num_upsamples; ++i) {
+    const int64_t rate = config.upsample_rates[static_cast<size_t>(i)];
+    const int64_t kernel = config.upsample_kernel_sizes[static_cast<size_t>(i)];
+    const int64_t out_channels = config.upsample_initial_channel / (int64_t{1} << (i + 1));
+    const std::string prefix = "ups." + std::to_string(i) + ".0";
+    // ConvTranspose1d weight is [in, out/groups, k] -> weight-norm dim 0 is IN.
+    const std::vector<float> w = conv_weight(prefix, channels);
+    const std::vector<float>& b = weights.Get(prefix + ".bias");
+    int64_t up_len = 0;
+    x = ConvTranspose1d(x, channels, length, w, &b, out_channels, kernel, rate,
+                        /*padding=*/(kernel - rate) / 2, /*groups=*/1, &up_len);
+    channels = out_channels;
+    length = up_len;
+
+    // --- the num_kernels AMPBlock1s, AVERAGED ---
+    std::vector<float> sum(static_cast<size_t>(channels * length), 0.0f);
+    for (int64_t j = 0; j < num_kernels; ++j) {
+      const int64_t kernel_size = config.resblock_kernel_sizes[static_cast<size_t>(j)];
+      const std::vector<int64_t>& dilations = config.resblock_dilation_sizes[static_cast<size_t>(j)];
+      const std::string block = "resblocks." + std::to_string(i * num_kernels + j);
+      std::vector<float> h = x;
+      for (size_t d = 0; d < dilations.size(); ++d) {
+        const int64_t dilation = dilations[d];
+        const std::string c1 = block + ".convs1." + std::to_string(d);
+        const std::string c2 = block + ".convs2." + std::to_string(d);
+        const std::string a1 = block + ".activations." + std::to_string(2 * d);
+        const std::string a2 = block + ".activations." + std::to_string(2 * d + 1);
+
+        int64_t act_len = 0;
+        std::vector<float> xt = act.Apply(h, channels, length, weights.Get(a1 + ".act.alpha"),
+                                          weights.Get(a1 + ".act.beta"), config.snake_logscale,
+                                          &act_len);
+        VT_CHECK(act_len == length, "minimax_h3 audio vae: anti-aliased activation changed length");
+        int64_t padded_len = 0;
+        const int64_t pad1 = GetPadding(kernel_size, dilation);
+        std::vector<float> padded(static_cast<size_t>(channels * (length + 2 * pad1)), 0.0f);
+        for (int64_t c = 0; c < channels; ++c) {
+          for (int64_t t = 0; t < length; ++t) {
+            padded[static_cast<size_t>(c * (length + 2 * pad1) + pad1 + t)] =
+                xt[static_cast<size_t>(c * length + t)];
+          }
+        }
+        padded_len = length + 2 * pad1;
+        int64_t conv_len = 0;
+        xt = Conv1d(padded, channels, padded_len, conv_weight(c1, channels),
+                    &weights.Get(c1 + ".bias"), channels, kernel_size, 1, dilation, 1, &conv_len);
+
+        xt = act.Apply(xt, channels, conv_len, weights.Get(a2 + ".act.alpha"),
+                       weights.Get(a2 + ".act.beta"), config.snake_logscale, &act_len);
+        const int64_t pad2 = GetPadding(kernel_size, 1);
+        std::vector<float> padded2(static_cast<size_t>(channels * (act_len + 2 * pad2)), 0.0f);
+        for (int64_t c = 0; c < channels; ++c) {
+          for (int64_t t = 0; t < act_len; ++t) {
+            padded2[static_cast<size_t>(c * (act_len + 2 * pad2) + pad2 + t)] =
+                xt[static_cast<size_t>(c * act_len + t)];
+          }
+        }
+        int64_t conv2_len = 0;
+        xt = Conv1d(padded2, channels, act_len + 2 * pad2, conv_weight(c2, channels),
+                    &weights.Get(c2 + ".bias"), channels, kernel_size, 1, 1, 1, &conv2_len);
+        VT_CHECK(conv2_len == length, "minimax_h3 audio vae: resblock changed the sequence length");
+        for (size_t n = 0; n < h.size(); ++n) h[n] += xt[n];
+      }
+      for (size_t n = 0; n < sum.size(); ++n) sum[n] += h[n];
+    }
+    for (float& value : sum) value /= static_cast<float>(num_kernels);
+    x.swap(sum);
+  }
+
+  // --- post activation + conv_post + bound ---
+  {
+    int64_t act_len = 0;
+    x = act.Apply(x, channels, length, weights.Get("activation_post.act.alpha"),
+                  weights.Get("activation_post.act.beta"), config.snake_logscale, &act_len);
+    length = act_len;
+  }
+  {
+    const int64_t pad = 3;
+    std::vector<float> padded(static_cast<size_t>(channels * (length + 2 * pad)), 0.0f);
+    for (int64_t c = 0; c < channels; ++c) {
+      for (int64_t t = 0; t < length; ++t) {
+        padded[static_cast<size_t>(c * (length + 2 * pad) + pad + t)] =
+            x[static_cast<size_t>(c * length + t)];
+      }
+    }
+    const std::vector<float> w = conv_weight("conv_post", 1);
+    const std::vector<float>* b = nullptr;
+    std::vector<float> bias_storage;
+    if (config.use_bias_at_final) {
+      bias_storage = weights.Get("conv_post.bias");
+      b = &bias_storage;
+    }
+    int64_t final_len = 0;
+    x = Conv1d(padded, channels, length + 2 * pad, w, b, 1, 7, 1, 1, 1, &final_len);
+    length = final_len;
+  }
+  // H3 sets use_tanh_at_final=false, so the output is CLAMPED, not squashed.
+  for (float& value : x) {
+    value = config.use_tanh_at_final ? std::tanh(value) : std::min(1.0f, std::max(-1.0f, value));
+  }
+  *out_samples = length;
+  return x;
+}
+
+// ===========================================================================
+// AUDIO VAE ENCODER — the analysis half (dac_audio_vae.py:25-117)
+//
+// A DAC encoder: one wide input conv, then one strided EncoderBlock per rate
+// (each three dilated ResidualUnits followed by a Snake1d and the downsampling
+// conv), then a final Snake1d + conv to the latent width. Every conv is
+// weight-normalized, exactly like the decoder's.
+//
+// After it, the reference-audio path runs `pre_block` (an AttnProjection) and
+// `mean_proj`, which is how vLLM-Omni composes an encode the shipped module does
+// not expose (vae.py:317-325).
+// ===========================================================================
+
+namespace {
+
+// Snake1d (dac_audio_vae.py:25-40):  x + (alpha + 1e-9)^-1 * sin(alpha * x)^2.
+// NOT the decoder's SnakeBeta: there is one parameter, it is NEVER log-scaled
+// (upstream initializes it to ones), and it both scales the sine and forms the
+// reciprocal.
+void Snake1d(std::vector<float>& x, int64_t channels, int64_t length,
+             const std::vector<float>& alpha) {
+  VT_CHECK(static_cast<int64_t>(alpha.size()) == channels,
+           "minimax_h3 audio encoder: Snake1d alpha must have one value per channel");
+  for (int64_t c = 0; c < channels; ++c) {
+    const double a = alpha[static_cast<size_t>(c)];
+    const double inv = 1.0 / (a + 1e-9);
+    for (int64_t t = 0; t < length; ++t) {
+      const double v = x[static_cast<size_t>(c * length + t)];
+      const double s = std::sin(a * v);
+      x[static_cast<size_t>(c * length + t)] = static_cast<float>(v + inv * s * s);
+    }
+  }
+}
+
+// Zero-pad `left`/`right` along time, which is what nn.Conv1d's `padding=` does.
+std::vector<float> PadZero(const std::vector<float>& in, int64_t channels, int64_t in_len,
+                           int64_t left, int64_t right, int64_t* out_len) {
+  const int64_t length = in_len + left + right;
+  std::vector<float> out(static_cast<size_t>(channels * length), 0.0f);
+  for (int64_t c = 0; c < channels; ++c) {
+    for (int64_t t = 0; t < in_len; ++t) {
+      out[static_cast<size_t>(c * length + left + t)] = in[static_cast<size_t>(c * in_len + t)];
+    }
+  }
+  *out_len = length;
+  return out;
+}
+
+// One weight-normalized Conv1d, materializing (g, v) the way the decoder does.
+std::vector<float> WnConv1d(const MiniMaxH3AudioVaeWeights& weights, const std::string& prefix,
+                            const std::vector<float>& in, int64_t in_channels, int64_t in_len,
+                            int64_t out_channels, int64_t kernel, int64_t stride, int64_t dilation,
+                            int64_t padding, int64_t* out_len) {
+  const std::vector<float> w =
+      MiniMaxH3MaterializeWeightNorm(weights.Get(prefix + ".parametrizations.weight.original0"),
+                                     weights.Get(prefix + ".parametrizations.weight.original1"),
+                                     out_channels);
+  VT_CHECK(static_cast<int64_t>(w.size()) == out_channels * in_channels * kernel,
+           "minimax_h3 audio encoder: conv weight does not match [out, in, k]");
+  const std::vector<float>& bias = weights.Get(prefix + ".bias");
+  int64_t padded_len = 0;
+  const std::vector<float> padded = PadZero(in, in_channels, in_len, padding, padding, &padded_len);
+  return Conv1d(padded, in_channels, padded_len, w, &bias, out_channels, kernel, stride, dilation,
+                /*groups=*/1, out_len);
+}
+
+// ResidualUnit (dac_audio_vae.py:50-66). The k=7 conv's `padding` keeps the
+// length, so the trim upstream performs is a no-op here — it is still written out,
+// because a config where it is NOT a no-op would otherwise silently misalign.
+std::vector<float> ResidualUnit(const MiniMaxH3AudioVaeWeights& weights, const std::string& prefix,
+                                const std::vector<float>& x, int64_t dim, int64_t length,
+                                int64_t dilation, int64_t* out_len) {
+  const int64_t pad = ((7 - 1) * dilation) / 2;
+  std::vector<float> y = x;
+  Snake1d(y, dim, length, weights.Get(prefix + ".block.0.alpha"));
+  int64_t len1 = 0;
+  y = WnConv1d(weights, prefix + ".block.1", y, dim, length, dim, /*kernel=*/7, /*stride=*/1,
+               dilation, pad, &len1);
+  Snake1d(y, dim, len1, weights.Get(prefix + ".block.2.alpha"));
+  int64_t len2 = 0;
+  y = WnConv1d(weights, prefix + ".block.3", y, dim, len1, dim, /*kernel=*/1, /*stride=*/1,
+               /*dilation=*/1, /*padding=*/0, &len2);
+
+  const int64_t trim = (length - len2) / 2;
+  VT_CHECK(trim >= 0, "minimax_h3 audio encoder: residual unit grew the sequence");
+  std::vector<float> out(static_cast<size_t>(dim * len2));
+  for (int64_t c = 0; c < dim; ++c) {
+    for (int64_t t = 0; t < len2; ++t) {
+      out[static_cast<size_t>(c * len2 + t)] =
+          x[static_cast<size_t>(c * length + trim + t)] + y[static_cast<size_t>(c * len2 + t)];
+    }
+  }
+  *out_len = len2;
+  return out;
+}
+
+int64_t CeilDiv2(int64_t stride) {  // math.ceil(stride / 2)
+  return (stride + 1) / 2;
+}
+
+// EncoderBlock (dac_audio_vae.py:69-87): three dilated residual units at dim/2,
+// then Snake1d, then the strided conv that doubles the channel count.
+std::vector<float> EncoderBlock(const MiniMaxH3AudioVaeWeights& weights, const std::string& prefix,
+                                const std::vector<float>& x, int64_t dim, int64_t length,
+                                int64_t stride, int64_t* out_len) {
+  VT_CHECK(dim % 2 == 0, "minimax_h3 audio encoder: EncoderBlock dim must be even");
+  const int64_t half = dim / 2;
+  std::vector<float> h = x;
+  int64_t len = length;
+  static const int64_t kDilations[3] = {1, 3, 9};
+  for (int64_t u = 0; u < 3; ++u) {
+    int64_t next = 0;
+    h = ResidualUnit(weights, prefix + ".block." + std::to_string(u), h, half, len, kDilations[u],
+                     &next);
+    len = next;
+  }
+  Snake1d(h, half, len, weights.Get(prefix + ".block.3.alpha"));
+  return WnConv1d(weights, prefix + ".block.4", h, half, len, dim, /*kernel=*/2 * stride, stride,
+                  /*dilation=*/1, CeilDiv2(stride), out_len);
+}
+
+// nn.LayerNorm over the LAST dimension of [rows, dim].
+void LayerNorm(std::vector<float>& x, int64_t rows, int64_t dim, const std::vector<float>& gamma,
+               const std::vector<float>& beta, double eps) {
+  VT_CHECK(static_cast<int64_t>(gamma.size()) == dim && static_cast<int64_t>(beta.size()) == dim,
+           "minimax_h3 audio encoder: LayerNorm weight/bias width mismatch");
+  for (int64_t r = 0; r < rows; ++r) {
+    float* row = x.data() + r * dim;
+    double sum = 0.0;
+    for (int64_t i = 0; i < dim; ++i) sum += row[i];
+    const double mean = sum / static_cast<double>(dim);
+    double var = 0.0;
+    for (int64_t i = 0; i < dim; ++i) {
+      const double d = row[i] - mean;
+      var += d * d;
+    }
+    // torch normalizes by N (biased), not N-1.
+    const double inv = 1.0 / std::sqrt(var / static_cast<double>(dim) + eps);
+    for (int64_t i = 0; i < dim; ++i) {
+      row[i] = static_cast<float>((row[i] - mean) * inv * gamma[static_cast<size_t>(i)] +
+                                  beta[static_cast<size_t>(i)]);
+    }
+  }
+}
+
+// y[r, o] = sum_i x[r, i] * w[o, i] + b[o]  — torch's nn.Linear layout.
+std::vector<float> Linear(const std::vector<float>& x, int64_t rows, int64_t in_dim,
+                          const std::vector<float>& w, const std::vector<float>* b,
+                          int64_t out_dim) {
+  VT_CHECK(static_cast<int64_t>(w.size()) == out_dim * in_dim,
+           "minimax_h3 audio encoder: linear weight is not [out, in]");
+  std::vector<float> out(static_cast<size_t>(rows * out_dim));
+  for (int64_t r = 0; r < rows; ++r) {
+    for (int64_t o = 0; o < out_dim; ++o) {
+      double acc = b != nullptr ? (*b)[static_cast<size_t>(o)] : 0.0;
+      for (int64_t i = 0; i < in_dim; ++i) {
+        acc += static_cast<double>(x[static_cast<size_t>(r * in_dim + i)]) *
+               static_cast<double>(w[static_cast<size_t>(o * in_dim + i)]);
+      }
+      out[static_cast<size_t>(r * out_dim + o)] = static_cast<float>(acc);
+    }
+  }
+  return out;
+}
+
+// nn.GELU(approximate="tanh").
+float GeluTanh(float x) {
+  const double v = x;
+  const double inner = 0.7978845608028654 * (v + 0.044715 * v * v * v);
+  return static_cast<float>(0.5 * v * (1.0 + std::tanh(inner)));
+}
+
+// F.adaptive_avg_pool1d over the last dimension of [rows, in_dim].
+std::vector<float> AdaptiveAvgPool1d(const std::vector<float>& x, int64_t rows, int64_t in_dim,
+                                     int64_t out_dim) {
+  VT_CHECK(out_dim > 0 && in_dim > 0, "minimax_h3 audio encoder: adaptive pool needs positive dims");
+  std::vector<float> out(static_cast<size_t>(rows * out_dim));
+  for (int64_t o = 0; o < out_dim; ++o) {
+    // torch's bin bounds: start = floor(o * in / out), end = ceil((o+1) * in / out).
+    const int64_t start = (o * in_dim) / out_dim;
+    const int64_t end = ((o + 1) * in_dim + out_dim - 1) / out_dim;
+    const int64_t count = end - start;
+    for (int64_t r = 0; r < rows; ++r) {
+      double acc = 0.0;
+      for (int64_t i = start; i < end; ++i) acc += x[static_cast<size_t>(r * in_dim + i)];
+      out[static_cast<size_t>(r * out_dim + o)] = static_cast<float>(acc / static_cast<double>(count));
+    }
+  }
+  return out;
+}
+
+}  // namespace
+
+int64_t MiniMaxH3AudioVaeEncoderConfig::hop_length() const {
+  int64_t hop = 1;
+  for (int64_t rate : encoder_rates) {
+    VT_CHECK(rate > 0, "minimax_h3 audio encoder: encoder rates must be positive");
+    hop *= rate;
+  }
+  return hop;
+}
+
+int64_t MiniMaxH3AudioVaeEncoderConfig::attn_proj_dim() const {
+  VT_CHECK(vae_latent_channels > 0, "minimax_h3 audio encoder: vae_latent_channels must be > 0");
+  if (latent_dim % vae_latent_channels == 0) return vae_latent_channels;
+  // "smallest power of two >= vae_latent_channels" (dac_audio_vae.py:155).
+  int64_t pow2 = 1;
+  while (pow2 < vae_latent_channels) pow2 *= 2;
+  return pow2;
+}
+
+std::vector<float> MiniMaxH3AudioVaeEncoderForward(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& samples,
+                                                   int64_t sample_count, int64_t* out_frames) {
+  VT_CHECK(sample_count > 0, "minimax_h3 audio encoder: an empty waveform has nothing to encode");
+  VT_CHECK(static_cast<int64_t>(samples.size()) >= sample_count,
+           "minimax_h3 audio encoder: sample_count exceeds the supplied waveform");
+  VT_CHECK(!config.encoder_rates.empty(), "minimax_h3 audio encoder: encoder_rates is empty");
+
+  // --- preprocess: right-pad to a whole number of hops (dac_audio_vae.py:201-209).
+  const int64_t hop = config.hop_length();
+  const int64_t padded_samples = ((sample_count + hop - 1) / hop) * hop;
+  std::vector<float> x(static_cast<size_t>(padded_samples), 0.0f);
+  std::copy(samples.begin(), samples.begin() + sample_count, x.begin());
+  int64_t length = padded_samples;
+
+  // --- block.0: WNConv1d(1, d_model, k=7, padding=3) (dac_audio_vae.py:99).
+  int64_t channels = config.encoder_dim;
+  {
+    int64_t next = 0;
+    x = WnConv1d(weights, "block.0", x, /*in_channels=*/1, length, channels, /*kernel=*/7,
+                 /*stride=*/1, /*dilation=*/1, /*padding=*/3, &next);
+    length = next;
+  }
+
+  // --- one EncoderBlock per rate, doubling channels as it downsamples
+  // (dac_audio_vae.py:102-104).
+  for (size_t i = 0; i < config.encoder_rates.size(); ++i) {
+    channels *= 2;
+    int64_t next = 0;
+    x = EncoderBlock(weights, "block." + std::to_string(i + 1), x, channels, length,
+                     config.encoder_rates[i], &next);
+    length = next;
+  }
+
+  // --- Snake1d + WNConv1d(d_model, d_latent, k=3, padding=1)
+  // (dac_audio_vae.py:107-110).
+  const std::string tail = "block." + std::to_string(config.encoder_rates.size() + 1);
+  Snake1d(x, channels, length, weights.Get(tail + ".alpha"));
+  {
+    int64_t next = 0;
+    x = WnConv1d(weights, "block." + std::to_string(config.encoder_rates.size() + 2), x, channels,
+                 length, config.latent_dim, /*kernel=*/3, /*stride=*/1, /*dilation=*/1,
+                 /*padding=*/1, &next);
+    length = next;
+  }
+
+  VT_CHECK(length == padded_samples / hop,
+           "minimax_h3 audio encoder: the strided stack did not downsample by hop_length");
+  if (out_frames != nullptr) *out_frames = length;
+  return x;
+}
+
+std::vector<float> MiniMaxH3AudioVaeAttnProjection(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& tokens,
+                                                   int64_t token_count) {
+  const int64_t in_dim = config.latent_dim;
+  const int64_t out_dim = config.attn_proj_dim();
+  const int64_t heads = config.attn_proj_heads;
+  VT_CHECK(token_count > 0 && heads > 0, "minimax_h3 audio encoder: attn projection needs tokens");
+  VT_CHECK(static_cast<int64_t>(tokens.size()) == token_count * in_dim,
+           "minimax_h3 audio encoder: attn projection input is not [tokens, latent_dim]");
+  // The checkpoint's AttnProjection NARROWS (2048 -> 32). The widening branch
+  // (dac_attn_proj.py:38-44, 63-64) is a different qkv shape and a different
+  // head_dim, and no shipped H3 config selects it; refusing beats running an
+  // untested second path.
+  VT_CHECK(in_dim > out_dim,
+           "minimax_h3 audio encoder: only the narrowing AttnProjection branch (in_dim > out_dim) "
+           "is ported, which is the one the checkpoint ships");
+  VT_CHECK(in_dim % heads == 0,
+           "minimax_h3 audio encoder: latent_dim must divide by the attn head count");
+  const int64_t head_dim = in_dim / heads;
+
+  // --- x = proj(norm3(x)) + attn(norm1(x))  (dac_attn_proj.py:86) ---
+  std::vector<float> h1 = tokens;
+  LayerNorm(h1, token_count, in_dim, weights.Get("pre_block.norm1.weight"),
+            weights.Get("pre_block.norm1.bias"), config.layer_norm_eps);
+
+  // CausalAttention.forward (dac_attn_proj.py:52-66). The qkv bias is ASSEMBLED,
+  // not stored: [q_bias | zero_k_bias | v_bias], so keys carry no bias at all.
+  const std::vector<float>& q_bias = weights.Get("pre_block.attn.q_bias");
+  const std::vector<float>& v_bias = weights.Get("pre_block.attn.v_bias");
+  VT_CHECK(static_cast<int64_t>(q_bias.size()) == in_dim &&
+               static_cast<int64_t>(v_bias.size()) == in_dim,
+           "minimax_h3 audio encoder: q_bias/v_bias must be latent_dim wide");
+  std::vector<float> qkv_bias(static_cast<size_t>(3 * in_dim), 0.0f);
+  std::copy(q_bias.begin(), q_bias.end(), qkv_bias.begin());
+  if (weights.Has("pre_block.attn.zero_k_bias")) {
+    // A registered BUFFER that is zero by construction, but it is serialized, so
+    // the checkpoint's own bytes are used rather than assumed.
+    const std::vector<float>& zk = weights.Get("pre_block.attn.zero_k_bias");
+    VT_CHECK(static_cast<int64_t>(zk.size()) == in_dim,
+             "minimax_h3 audio encoder: zero_k_bias must be latent_dim wide");
+    std::copy(zk.begin(), zk.end(), qkv_bias.begin() + in_dim);
+  }
+  std::copy(v_bias.begin(), v_bias.end(), qkv_bias.begin() + 2 * in_dim);
+  const std::vector<float> qkv = Linear(h1, token_count, in_dim,
+                                        weights.Get("pre_block.attn.qkv.weight"), &qkv_bias,
+                                        3 * in_dim);
+
+  // qkv.reshape(B, N, 3, heads, head_dim).permute(2, 0, 3, 1, 4): the head axis is
+  // the SLOWEST inside each of q/k/v, and q/k/v are the OUTER split of the row.
+  auto at = [&](int64_t which, int64_t token, int64_t head, int64_t d) {
+    return static_cast<double>(
+        qkv[static_cast<size_t>(token * 3 * in_dim + which * in_dim + head * head_dim + d)]);
+  };
+
+  const double scale = 1.0 / std::sqrt(static_cast<double>(head_dim));
+  // scaled_dot_product_attention(..., is_causal=True), then MEAN over heads.
+  std::vector<double> pooled(static_cast<size_t>(token_count * head_dim), 0.0);
+  std::vector<double> logits(static_cast<size_t>(token_count));
+  for (int64_t head = 0; head < heads; ++head) {
+    for (int64_t i = 0; i < token_count; ++i) {
+      double max_logit = -std::numeric_limits<double>::infinity();
+      for (int64_t j = 0; j <= i; ++j) {  // causal: keys 0..i only
+        double dot = 0.0;
+        for (int64_t d = 0; d < head_dim; ++d) dot += at(0, i, head, d) * at(1, j, head, d);
+        dot *= scale;
+        logits[static_cast<size_t>(j)] = dot;
+        max_logit = std::max(max_logit, dot);
+      }
+      double denom = 0.0;
+      for (int64_t j = 0; j <= i; ++j) {
+        const double e = std::exp(logits[static_cast<size_t>(j)] - max_logit);
+        logits[static_cast<size_t>(j)] = e;
+        denom += e;
+      }
+      for (int64_t j = 0; j <= i; ++j) {
+        const double p = logits[static_cast<size_t>(j)] / denom;
+        for (int64_t d = 0; d < head_dim; ++d) {
+          pooled[static_cast<size_t>(i * head_dim + d)] += p * at(2, j, head, d);
+        }
+      }
+    }
+  }
+  std::vector<float> head_mean(static_cast<size_t>(token_count * head_dim));
+  for (size_t n = 0; n < head_mean.size(); ++n) {
+    head_mean[n] = static_cast<float>(pooled[n] / static_cast<double>(heads));
+  }
+
+  // in_dim // num_heads != out_dim => adaptive average pool down to out_dim
+  // (dac_attn_proj.py:61-62).
+  std::vector<float> narrowed = head_dim == out_dim
+                                    ? head_mean
+                                    : AdaptiveAvgPool1d(head_mean, token_count, head_dim, out_dim);
+  const std::vector<float> attn_out =
+      Linear(narrowed, token_count, out_dim, weights.Get("pre_block.attn.proj.weight"),
+             &weights.Get("pre_block.attn.proj.bias"), out_dim);
+
+  std::vector<float> h3 = tokens;
+  LayerNorm(h3, token_count, in_dim, weights.Get("pre_block.norm3.weight"),
+            weights.Get("pre_block.norm3.bias"), config.layer_norm_eps);
+  std::vector<float> x = Linear(h3, token_count, in_dim, weights.Get("pre_block.proj.weight"),
+                                &weights.Get("pre_block.proj.bias"), out_dim);
+  for (size_t n = 0; n < x.size(); ++n) x[n] += attn_out[n];
+
+  // --- x = x + mlp(norm2(x))  (dac_attn_proj.py:87) ---
+  std::vector<float> h2 = x;
+  LayerNorm(h2, token_count, out_dim, weights.Get("pre_block.norm2.weight"),
+            weights.Get("pre_block.norm2.bias"), config.layer_norm_eps);
+  // GeGluMlp (dac_attn_proj.py:8-25): another LayerNorm, then gelu(w0) * w1 -> w2.
+  LayerNorm(h2, token_count, out_dim, weights.Get("pre_block.mlp.norm.weight"),
+            weights.Get("pre_block.mlp.norm.bias"), config.layer_norm_eps);
+  const std::vector<float>& w0 = weights.Get("pre_block.mlp.w0.weight");
+  VT_CHECK(static_cast<int64_t>(w0.size()) % out_dim == 0,
+           "minimax_h3 audio encoder: mlp.w0 does not divide by the projection width");
+  const int64_t hidden = static_cast<int64_t>(w0.size()) / out_dim;
+  std::vector<float> gate = Linear(h2, token_count, out_dim, w0,
+                                   &weights.Get("pre_block.mlp.w0.bias"), hidden);
+  const std::vector<float> up = Linear(h2, token_count, out_dim,
+                                       weights.Get("pre_block.mlp.w1.weight"),
+                                       &weights.Get("pre_block.mlp.w1.bias"), hidden);
+  for (size_t n = 0; n < gate.size(); ++n) gate[n] = GeluTanh(gate[n]) * up[n];
+  const std::vector<float> mlp = Linear(gate, token_count, hidden,
+                                        weights.Get("pre_block.mlp.w2.weight"),
+                                        &weights.Get("pre_block.mlp.w2.bias"), out_dim);
+  for (size_t n = 0; n < x.size(); ++n) x[n] += mlp[n];
+  return x;
+}
+
+std::vector<float> MiniMaxH3AudioVaeEncodeToLatent(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& samples,
+                                                   int64_t sample_count, int64_t* out_frames) {
+  int64_t frames = 0;
+  std::vector<float> latent =
+      MiniMaxH3AudioVaeEncoderForward(config, weights, samples, sample_count, &frames);
+  int64_t width = config.latent_dim;
+
+  if (config.attn_proj) {
+    // latent.transpose(1, 2) -> [frames, latent_dim] -> AttnProjection -> transpose back.
+    std::vector<float> tokens(static_cast<size_t>(frames * width));
+    for (int64_t c = 0; c < width; ++c) {
+      for (int64_t t = 0; t < frames; ++t) {
+        tokens[static_cast<size_t>(t * width + c)] = latent[static_cast<size_t>(c * frames + t)];
+      }
+    }
+    const int64_t projected = config.attn_proj_dim();
+    const std::vector<float> rows = MiniMaxH3AudioVaeAttnProjection(config, weights, tokens, frames);
+    latent.assign(static_cast<size_t>(projected * frames), 0.0f);
+    for (int64_t c = 0; c < projected; ++c) {
+      for (int64_t t = 0; t < frames; ++t) {
+        latent[static_cast<size_t>(c * frames + t)] = rows[static_cast<size_t>(t * projected + c)];
+      }
+    }
+    width = projected;
+  }
+
+  // mean_proj: a PLAIN Conv1d(attn_proj_dim -> vae_latent_channels, k=1); the VAE's
+  // distribution MEAN. `logs_proj` is never evaluated — a reference must be
+  // deterministic, so nothing is sampled.
+  const std::vector<float>& w = weights.Get("mean_proj.weight");
+  const std::vector<float>& b = weights.Get("mean_proj.bias");
+  VT_CHECK(static_cast<int64_t>(w.size()) == config.vae_latent_channels * width,
+           "minimax_h3 audio encoder: mean_proj is not [vae_latent_channels, attn_proj_dim, 1]");
+  int64_t out_len = 0;
+  std::vector<float> mean = Conv1d(latent, width, frames, w, &b, config.vae_latent_channels,
+                                   /*kernel=*/1, /*stride=*/1, /*dilation=*/1, /*groups=*/1,
+                                   &out_len);
+  VT_CHECK(out_len == frames, "minimax_h3 audio encoder: mean_proj changed the frame count");
+  if (out_frames != nullptr) *out_frames = frames;
+  return mean;
+}
+
+std::vector<float> MiniMaxH3AudioVaeEncodeToRows(const MiniMaxH3AudioVaeEncoderConfig& config,
+                                                 const MiniMaxH3AudioVaeWeights& weights,
+                                                 const std::vector<float>& waveform,
+                                                 int64_t channels, int64_t samples_per_channel,
+                                                 const std::vector<float>& latents_mean,
+                                                 const std::vector<float>& latents_std,
+                                                 int64_t* out_audio_t) {
+  VT_CHECK(channels > 0 && samples_per_channel > 0,
+           "minimax_h3 audio encoder: a reference waveform needs channels and samples");
+  VT_CHECK(static_cast<int64_t>(waveform.size()) == channels * samples_per_channel,
+           "minimax_h3 audio encoder: waveform is not [channels, samples_per_channel]");
+  const int64_t width = config.vae_latent_channels;
+  const bool normalize = !latents_mean.empty() || !latents_std.empty();
+  if (normalize) {
+    VT_CHECK(static_cast<int64_t>(latents_mean.size()) == width &&
+                 static_cast<int64_t>(latents_std.size()) == width,
+             "minimax_h3 audio encoder: latents_mean/std must have vae_latent_channels values");
+  }
+
+  // Channels encode INDEPENDENTLY: upstream hands the VAE a [C, 1, T] batch, so
+  // each channel is its own [1, T] clip (vae.py:317-322).
+  std::vector<float> rows;
+  int64_t frames = 0;
+  for (int64_t c = 0; c < channels; ++c) {
+    const std::vector<float> channel(waveform.begin() + c * samples_per_channel,
+                                     waveform.begin() + (c + 1) * samples_per_channel);
+    int64_t f = 0;
+    const std::vector<float> latent =
+        MiniMaxH3AudioVaeEncodeToLatent(config, weights, channel, samples_per_channel, &f);
+    if (c == 0) {
+      frames = f;
+      rows.assign(static_cast<size_t>(channels * frames * width), 0.0f);
+    } else {
+      VT_CHECK(f == frames, "minimax_h3 audio encoder: channels produced different frame counts");
+    }
+    // [vae_latent_channels, frames] -> the packed row layout [frames,
+    // vae_latent_channels], normalized per channel-of-the-latent (vae.py:327-341).
+    for (int64_t t = 0; t < frames; ++t) {
+      for (int64_t d = 0; d < width; ++d) {
+        double v = latent[static_cast<size_t>(d * frames + t)];
+        if (normalize) {
+          v = (v - latents_mean[static_cast<size_t>(d)]) / latents_std[static_cast<size_t>(d)];
+        }
+        rows[static_cast<size_t>(((c * frames) + t) * width + d)] = static_cast<float>(v);
+      }
+    }
+  }
+  if (out_audio_t != nullptr) *out_audio_t = frames;
+  return rows;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_device.cpp b/src/vllm/model_executor/models/minimax_h3_device.cpp
new file mode 100644
index 000000000..9cc70c4fd
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_device.cpp
@@ -0,0 +1,1046 @@
+// MiniMax-H3 DiT — the DEVICE-RESIDENT forward (brick H3-2b).
+//
+// `MiniMaxH3DitForward` (minimax_h3.cpp) is the portable reference: it computes
+// into host `std::vector<float>` buffers and only reaches for `vt::` at the two
+// big ops. This file runs the SAME graph with every activation in device memory,
+// so the block stack — and, above it, the 50-step denoise loop — never round-trips
+// through the host.
+//
+// ─── WHAT IS PORTED, AND FROM WHERE ──────────────────────────────────────────
+// Structure is 1:1 with the reference; each step below names the reference helper
+// it replaces and the upstream line it came from. The port REUSES tuned shared
+// ops wherever one exists, which is why only three H3-specific kernels were added
+// (minimax_h3_device.h):
+//
+//   Linear                  -> vt::MatmulBT + vt::Add (rank-1 row-broadcast bias)
+//   RmsNormRows             -> vt::RmsNorm
+//   qkv split               -> vt::QkvSplit
+//   ApplyRope (3-axis)      -> vt::RopeFromCache over a prebuilt per-row cache
+//   MLP silu(gate)*up       -> vt::SiluAndMul
+//   residual add            -> vt::Add
+//   row gather / scatter    -> vt::IndexSelect / vt::IndexCopy
+//   packed varlen attention -> vt::DFlashBlockAttention(causal=false)
+//   ModulateScaleShift/Gate -> kMiniMaxH3 glue table
+//   Silu (ungated)          -> kMiniMaxH3 glue table
+//
+// ─── NUMERICS: CLOSE, NOT BIT-IDENTICAL ──────────────────────────────────────
+// This path is NOT bit-identical to the CPU reference and does not claim to be.
+// The divergence is in the SHARED ops, not the H3 kernels: vt::RmsNorm reduces in
+// f32 where RmsNormRows accumulates in double, and MatmulBT/attention use their
+// own accumulation orders. f32 is what upstream torch RMSNorm does, so the device
+// path is arguably the closer mirror. It is gated against the SAME upstream
+// goldens at the SAME tolerance as the CPU forward.
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "vllm/model_executor/models/dense_device_glue.h"
+#include "vllm/model_executor/model_loader/gguf_dequant.h"
+#include "vllm/model_executor/model_loader/gguf_reader.h"
+#include "vllm/model_executor/model_loader/nvfp4_dequant.h"
+#include "vllm/model_executor/model_loader/safetensors_reader.h"
+#include "vllm/model_executor/models/minimax_h3.h"
+#include "vllm/model_executor/models/minimax_h3_device.h"
+#include "vt/backend.h"
+#include "vt/dtype.h"
+#include "vt/ops.h"
+#include "vt/recipes.h"
+
+namespace vllm {
+namespace {
+
+using dense_attn::DBuf;
+using dense_attn::Dev;
+using dense_attn::MakeTensor;
+using vt::DType;
+using vt::Tensor;
+
+// The device twin of the reference's StreamDtype -- but where the reference rounds
+// f32 buffers in place, this path gives the stream REAL bf16 STORAGE. The rounding
+// then happens where upstream's happens (on every store), the activations are half
+// the bytes, and the tuned shared ops (RmsNorm / MatmulBT / SiluAndMul / attention)
+// run their native bf16 paths instead of an f32 path plus a rounding pass.
+//
+// `S()` is the stream dtype; the fp32 ISLANDS (both patch projections, the time
+// embedder, both output heads) allocate kF32 explicitly and are converted at the
+// boundary with vt::CastBf16 / vt::CastF32.
+struct DeviceStreamDtype {
+  bool bf16 = false;
+  DType S() const { return bf16 ? DType::kBF16 : DType::kF32; }
+};
+
+// Convert between the f32 ISLANDS and the stream dtype. A same-dtype call is a
+// straight copy, so the f32 path costs one memcpy and stays byte-identical.
+void CastTo(Dev d, Tensor& out, const Tensor& in) {
+  if (out.dtype == in.dtype) {
+    vt::GetBackend(d.q.device.type).Copy(d.q, out.data, in.data, in.Bytes());
+  } else if (out.dtype == DType::kBF16) {
+    vt::CastBf16(d.q, out, in);
+  } else {
+    vt::CastF32(d.q, out, in);
+  }
+}
+
+const minimax_h3::MiniMaxH3DeviceKernels* Glue(const Dev& d) {
+  VT_CHECK(minimax_h3::MiniMaxH3DeviceKernelsAvailable(d.q.device.type),
+           "minimax_h3: no device glue table registered for this backend");
+  return minimax_h3::MiniMaxH3Device(d.q.device.type);
+}
+
+// vt::MatmulBT + optional rank-1 bias, the device twin of the reference `Linear`.
+// Weight is [out_features, in_features] — every {Column,Row,QKV,MergedColumn}
+// ParallelLinear at TP=1.
+void LinearDev(Dev d, const Tensor& in, int64_t rows, int64_t in_features, const Tensor& weight,
+               const Tensor* bias, Tensor& out) {
+  VT_CHECK(weight.rank == 2 && weight.shape[1] == in_features,
+           "minimax_h3 device linear: weight shape does not match input width");
+  Tensor a = dense_attn::Reshape(in, {rows, in_features});
+  Tensor o = dense_attn::Reshape(out, {rows, weight.shape[0]});
+  vt::MatmulBT(d.q, o, a, weight);
+  if (bias != nullptr && bias->data != nullptr) {
+    vt::Add(d.q, o, o, *bias);  // rank-1 row-broadcast == a nn.Linear bias term
+  }
+}
+
+// MiniMaxH3Rope.forward + _apply_rope (minimax_h3_transformer.py:222-244) as a
+// cos/sin CACHE.
+//
+// H3's rope is plain NeoX rotate_half over the leading rot_dim head dims; only the
+// ANGLES are unusual (three axes t/h/w off the fp64 position grid rather than one
+// scalar position). vt::RopeFromCache consumes exactly a [S, rot_dim] cache laid
+// out as [cos(half) | sin(half)] and indexes it by position, so building that
+// cache here reproduces ApplyRope with NO bespoke rope kernel.
+//
+// The reference duplicates the half-angle block (`memcpy(dst + half, dst, ...)`)
+// so its cos_lo/cos_hi are equal; that duplication is exactly what makes the
+// rotation NeoX-shaped, and it is why one [S, rot_dim] cache suffices.
+std::vector<float> BuildRopeCosSin(const double* position_ids, int64_t seq_len,
+                                   const float* inv_freq, int64_t inv_freq_len) {
+  const int64_t half = 3 * inv_freq_len;  // rot_dim / 2
+  const int64_t rot_dim = 2 * half;
+  std::vector<float> cache(static_cast<size_t>(seq_len * rot_dim));
+  for (int64_t s = 0; s < seq_len; ++s) {
+    float* dst = cache.data() + s * rot_dim;
+    for (int64_t axis = 0; axis < 3; ++axis) {
+      const float pos = static_cast<float>(position_ids[s * 3 + axis]);
+      for (int64_t i = 0; i < inv_freq_len; ++i) {
+        const float angle = pos * inv_freq[i];
+        dst[axis * inv_freq_len + i] = std::cos(angle);
+        dst[half + axis * inv_freq_len + i] = std::sin(angle);
+      }
+    }
+  }
+  return cache;
+}
+
+struct AttnWeightsDev {
+  const Tensor* qkv;
+  const Tensor* q_norm;
+  const Tensor* k_norm;
+  const Tensor* out_proj;
+};
+
+// MiniMaxH3Attention.forward (minimax_h3_transformer.py:421-467).
+void AttentionDev(Dev d, const MiniMaxH3DitParams& params, const AttnWeightsDev& w,
+                  const Tensor& in, int64_t rows, const Tensor* rope_cache,
+                  const Tensor* rope_positions, const int32_t* cu_seqlens, int num_reqs,
+                  const DeviceStreamDtype& dt, Tensor& out) {
+  const int64_t heads = params.num_attention_heads;
+  const int64_t head_dim = params.attention_head_dim;
+  const int64_t inner = heads * head_dim;
+
+  DBuf qkv(d, dt.S(), {rows, 3 * inner});
+  LinearDev(d, in, rows, params.hidden_size, *w.qkv, nullptr, qkv.t());
+
+  DBuf qb(d, dt.S(), {rows, inner});
+  DBuf kb(d, dt.S(), {rows, inner});
+  DBuf vb(d, dt.S(), {rows, inner});
+  vt::QkvSplit(d.q, qb.t(), kb.t(), vb.t(), qkv.t());
+
+  // Per-head RMSNorm over head_dim: [rows, heads, head_dim] -> [rows*heads, head_dim].
+  Tensor qn = dense_attn::Reshape(qb.t(), {rows * heads, head_dim});
+  Tensor kn = dense_attn::Reshape(kb.t(), {rows * heads, head_dim});
+  vt::RmsNormArgs norm_args;
+  norm_args.eps = static_cast<float>(params.qk_norm_eps);
+  vt::RmsNorm(d.q, qn, qn, *w.q_norm, norm_args);
+  vt::RmsNorm(d.q, kn, kn, *w.k_norm, norm_args);
+
+  if (rope_cache != nullptr) {
+    Tensor q3 = dense_attn::Reshape(qb.t(), {rows, heads, head_dim});
+    Tensor k3 = dense_attn::Reshape(kb.t(), {rows, heads, head_dim});
+    vt::RopeArgs rope;
+    rope.rotary_dim = static_cast<int>(params.rope_rot_dim());
+    rope.is_neox_style = true;
+    vt::RopeFromCache(d.q, q3, &k3, *rope_positions, *rope_cache, rope);
+  }
+
+  Tensor tq = dense_attn::Reshape(qb.t(), {rows, heads, head_dim});
+  Tensor tk = dense_attn::Reshape(kb.t(), {rows, heads, head_dim});
+  Tensor tv = dense_attn::Reshape(vb.t(), {rows, heads, head_dim});
+  DBuf attn(d, dt.S(), {rows, heads, head_dim});
+  vt::DFlashBlockAttentionArgs args;
+  args.scale = static_cast<float>(1.0 / std::sqrt(static_cast<double>(head_dim)));
+  args.causal = false;  // bidirectional within each packed document
+  args.sliding_window = 0;
+  args.cu_seqlens = cu_seqlens;
+  args.num_reqs = num_reqs;
+  vt::DFlashBlockAttention(d.q, attn.t(), tq, tk, tv, args);
+
+  Tensor flat = dense_attn::Reshape(attn.t(), {rows, inner});
+  LinearDev(d, flat, rows, inner, *w.out_proj, nullptr, out);
+}
+
+// MiniMaxH3MLP.forward (minimax_h3_transformer.py:512-517): silu(gate) * up.
+// fc1 emits [gate; up] per row, which is exactly vt::SiluAndMul's input layout.
+void MlpDev(Dev d, const MiniMaxH3DitParams& params, const Tensor& fc1, const Tensor& fc2,
+            const Tensor& in, int64_t rows, const DeviceStreamDtype& dt, Tensor& out) {
+  const int64_t ffn = params.ffn_hidden_size;
+  DBuf hidden(d, dt.S(), {rows, 2 * ffn});
+  LinearDev(d, in, rows, params.hidden_size, fc1, nullptr, hidden.t());
+  DBuf act(d, dt.S(), {rows, ffn});
+  vt::SiluAndMul(d.q, act.t(), hidden.t());
+  LinearDev(d, act.t(), rows, ffn, fc2, nullptr, out);
+}
+
+// MiniMaxH3AdalnProj.forward (minimax_h3_transformer.py:555-561):
+// silu(t_emb) -> linear. `activated` is the ALREADY-silu'd t_emb, hoisted out of
+// the block loop by the caller: t_emb does not change across blocks, so the
+// reference's per-block silu is redundant work the device path simply does once.
+void AdalnProjectDev(Dev d, const Tensor& activated, int64_t m, int64_t time_embed_dim,
+                     const Tensor& weight, const Tensor& bias, Tensor& out) {
+  LinearDev(d, activated, m, time_embed_dim, weight, &bias, out);
+}
+
+}  // namespace
+
+MiniMaxH3DitDeviceWeights StageMiniMaxH3DitWeights(vt::Queue& queue,
+                                                   const MiniMaxH3DitParams& params,
+                                                   const MiniMaxH3DitWeights& host,
+                                                   DType compute_dtype) {
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  MiniMaxH3DitDeviceWeights staged;
+  staged.weights = host;  // shapes carry over; every view is rebound below
+  const bool bf16 = compute_dtype == DType::kBF16;
+
+  // `as_bf16` marks a weight that upstream STORES in bf16. The fp32 islands pass
+  // false and stay f32 even in the bf16 stream -- that split IS the dtype policy
+  // (MINIMAX_H3_FP32_PARAM_NAMES, minimax_h3_transformer.py:85-101), and getting it
+  // backwards would round tensors upstream deliberately keeps at full precision.
+  auto upload = [&](const Tensor& src, Tensor& dst, bool as_bf16) {
+    if (src.data == nullptr) {
+      dst = src;
+      return;
+    }
+    const std::vector<int64_t> shape(src.shape, src.shape + src.rank);
+    const int64_t n = src.Numel();
+
+    // KEEP-QUANT: a block-encoded weight is uploaded VERBATIM and keeps its block
+    // dtype -- never dequantized, and never rounded to the stream dtype (its
+    // scales already carry the precision). vt::MatmulBT routes it to
+    // kMatmulBTQuant on its own, so the forward is unchanged.
+    //
+    // The upload is the load-bearing part: a keep-quant slice feeding a DEVICE
+    // GEMM must point at DEVICE memory. Handing the GEMM a raw host-byte view
+    // reads as ALL ZEROS on the GPU, and a CPU-only gate cannot catch it because
+    // there the host pointer is valid.
+    if (vt::IsBlockQuant(src.dtype)) {
+      VT_CHECK(src.rank == 2, "minimax_h3 stage: keep-quant weights must be rank 2");
+      const size_t bytes =
+          static_cast<size_t>(shape[0]) * vt::RowSizeBytes(src.dtype, shape[1]);
+      void* p = backend.Alloc(bytes);
+      std::shared_ptr<void> owner(p, [&backend](void* q) { backend.Free(q); });
+      backend.Copy(queue, p, src.data, bytes);
+      dst = dense_attn::MakeTensor(p, src.dtype, queue.device, shape);
+      staged.storage.push_back(std::move(owner));
+      return;
+    }
+
+    // Already bf16 (the throughput loader): upload verbatim, no conversion.
+    if (src.dtype == DType::kBF16) {
+      const size_t bytes = static_cast<size_t>(n) * vt::SizeOf(DType::kBF16);
+      void* p = backend.Alloc(bytes);
+      std::shared_ptr<void> owner(p, [&backend](void* q) { backend.Free(q); });
+      backend.Copy(queue, p, src.data, bytes);
+      dst = dense_attn::MakeTensor(p, DType::kBF16, queue.device, shape);
+      staged.storage.push_back(std::move(owner));
+      return;
+    }
+    VT_CHECK(src.dtype == DType::kF32, "minimax_h3 stage: host weights must be f32, bf16 or block-quant");
+    const DType want = (bf16 && as_bf16) ? DType::kBF16 : DType::kF32;
+    const size_t bytes = static_cast<size_t>(n) * vt::SizeOf(want);
+    void* p = backend.Alloc(bytes);
+    std::shared_ptr<void> owner(p, [&backend](void* q) { backend.Free(q); });
+    if (want == DType::kF32) {
+      backend.Copy(queue, p, src.data, bytes);
+    } else {
+      // Round on the HOST, then upload: the same round-to-nearest-even the stream
+      // uses, so a bf16 weight and a bf16 activation agree bit-for-bit on the rule.
+      std::vector<uint16_t> packed(static_cast<size_t>(n));
+      const float* in = src.Ptr<float>();
+      for (int64_t i = 0; i < n; ++i) {
+        uint32_t bits;
+        std::memcpy(&bits, &in[i], sizeof(bits));
+        if ((bits & 0x7F800000u) == 0x7F800000u) {
+          bits &= 0xFFFF0000u;
+        } else {
+          const uint32_t lsb = (bits >> 16) & 1u;
+          bits = (bits + 0x7FFFu + lsb) & 0xFFFF0000u;
+        }
+        packed[static_cast<size_t>(i)] = static_cast<uint16_t>(bits >> 16);
+      }
+      backend.Copy(queue, p, packed.data(), bytes);
+      backend.Synchronize(queue);  // `packed` dies at the end of this scope
+    }
+    dst = dense_attn::MakeTensor(p, want, queue.device, shape);
+    staged.storage.push_back(std::move(owner));
+  };
+
+  auto upload_block = [&](const MiniMaxH3DitBlockWeights& src, MiniMaxH3DitBlockWeights& dst) {
+    // Every tensor in a refiner/DiT block is bf16-stored upstream.
+    upload(src.norm1, dst.norm1, true);
+    upload(src.norm2, dst.norm2, true);
+    upload(src.qkv_proj, dst.qkv_proj, true);
+    upload(src.q_norm, dst.q_norm, true);
+    upload(src.k_norm, dst.k_norm, true);
+    upload(src.out_proj, dst.out_proj, true);
+    upload(src.fc1, dst.fc1, true);
+    upload(src.fc2, dst.fc2, true);
+    upload(src.adaln_w, dst.adaln_w, true);
+    upload(src.adaln_b, dst.adaln_b, true);
+  };
+
+  // --- fp32 ISLANDS (never rounded, even in the bf16 stream) ---
+  upload(host.video_patch_proj_w, staged.weights.video_patch_proj_w, false);
+  upload(host.video_patch_proj_b, staged.weights.video_patch_proj_b, false);
+  upload(host.audio_patch_proj_w, staged.weights.audio_patch_proj_w, false);
+  upload(host.audio_patch_proj_b, staged.weights.audio_patch_proj_b, false);
+  upload(host.time_proj_in_w, staged.weights.time_proj_in_w, false);
+  upload(host.time_proj_in_b, staged.weights.time_proj_in_b, false);
+  upload(host.time_proj_out_w, staged.weights.time_proj_out_w, false);
+  upload(host.time_proj_out_b, staged.weights.time_proj_out_b, false);
+  upload(host.video_out_w, staged.weights.video_out_w, false);
+  upload(host.video_out_b, staged.weights.video_out_b, false);
+  upload(host.audio_out_w, staged.weights.audio_out_w, false);
+  upload(host.audio_out_b, staged.weights.audio_out_b, false);
+  // rope.inv_freq is consumed on the HOST (it builds the cos/sin cache), so it is
+  // deliberately left as the caller's host view rather than uploaded. It is also an
+  // fp32 buffer upstream, so no rounding question arises.
+  staged.weights.rope_inv_freq = host.rope_inv_freq;
+
+  // --- bf16-STORED modules ---
+  upload(host.condition_proj_w, staged.weights.condition_proj_w, true);
+  upload(host.condition_proj_b, staged.weights.condition_proj_b, true);
+  for (size_t i = 0; i < host.refiner.size(); ++i) {
+    upload_block(host.refiner[i], staged.weights.refiner[i]);
+  }
+  upload(host.refiner_final_norm, staged.weights.refiner_final_norm, true);
+  for (size_t i = 0; i < host.blocks.size(); ++i) {
+    upload_block(host.blocks[i], staged.weights.blocks[i]);
+  }
+  upload(host.final_norm, staged.weights.final_norm, true);
+  upload(host.final_adaln_w, staged.weights.final_adaln_w, true);
+  upload(host.final_adaln_b, staged.weights.final_adaln_b, true);
+  (void)params;
+  backend.Synchronize(queue);
+  return staged;
+}
+
+MiniMaxH3DitDeviceWeights StageMiniMaxH3DitWeightsDequantBf16(
+    vt::Queue& queue, const MiniMaxH3DitParams& params, const MiniMaxH3GgufDit& gguf) {
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  MiniMaxH3DitDeviceWeights staged;
+  staged.weights = gguf.weights;
+
+  // Reverse of the loader's own name->view binding: find which checkpoint name a
+  // given view came from, so its ggml type id can be recovered.
+  auto ggml_type_of = [&](const Tensor& t) -> const uint32_t* {
+    for (const auto& kv : gguf.quant_storage) {
+      if (kv.second.data() == static_cast<const uint8_t*>(t.data)) {
+        const auto it = gguf.quant_ggml_type.find(kv.first);
+        return it == gguf.quant_ggml_type.end() ? nullptr : &it->second;
+      }
+    }
+    return nullptr;
+  };
+
+  auto upload = [&](const Tensor& src, Tensor& dst) {
+    if (src.data == nullptr) {
+      dst = src;
+      return;
+    }
+    const std::vector<int64_t> shape(src.shape, src.shape + src.rank);
+    std::vector<uint16_t> bf16;
+    if (vt::IsBlockQuant(src.dtype)) {
+      const uint32_t* type = ggml_type_of(src);
+      VT_CHECK(type != nullptr,
+               "minimax_h3 stage-dequant: a block-quant weight has no recorded ggml type");
+      // Straight to bf16: dequantizing to f32 first would double the peak and buy
+      // nothing, since bf16 is what the GEMM will consume.
+      bf16 = DequantGgufRowToBf16(*type, static_cast<const uint8_t*>(src.data),
+                                  src.shape[0] * src.shape[1]);
+    } else {
+      VT_CHECK(src.dtype == DType::kF32, "minimax_h3 stage-dequant: expected f32 or block-quant");
+      const int64_t n = src.Numel();
+      bf16.resize(static_cast<size_t>(n));
+      const float* in = src.Ptr<float>();
+      for (int64_t i = 0; i < n; ++i) {
+        uint32_t bits;
+        std::memcpy(&bits, &in[i], sizeof(bits));
+        if ((bits & 0x7F800000u) == 0x7F800000u) {
+          bits &= 0xFFFF0000u;
+        } else {
+          const uint32_t lsb = (bits >> 16) & 1u;
+          bits = (bits + 0x7FFFu + lsb) & 0xFFFF0000u;
+        }
+        bf16[static_cast<size_t>(i)] = static_cast<uint16_t>(bits >> 16);
+      }
+    }
+    const size_t bytes = bf16.size() * sizeof(uint16_t);
+    void* p = backend.Alloc(bytes);
+    std::shared_ptr<void> owner(p, [&backend](void* q) { backend.Free(q); });
+    backend.Copy(queue, p, bf16.data(), bytes);
+    backend.Synchronize(queue);  // `bf16` dies at the end of this scope
+    dst = dense_attn::MakeTensor(p, DType::kBF16, queue.device, shape);
+    staged.storage.push_back(std::move(owner));
+  };
+
+  auto upload_block = [&](const MiniMaxH3DitBlockWeights& src, MiniMaxH3DitBlockWeights& dst) {
+    upload(src.norm1, dst.norm1);
+    upload(src.norm2, dst.norm2);
+    upload(src.qkv_proj, dst.qkv_proj);
+    upload(src.q_norm, dst.q_norm);
+    upload(src.k_norm, dst.k_norm);
+    upload(src.out_proj, dst.out_proj);
+    upload(src.fc1, dst.fc1);
+    upload(src.fc2, dst.fc2);
+    upload(src.adaln_w, dst.adaln_w);
+    upload(src.adaln_b, dst.adaln_b);
+  };
+
+  const MiniMaxH3DitWeights& host = gguf.weights;
+  upload(host.video_patch_proj_w, staged.weights.video_patch_proj_w);
+  upload(host.video_patch_proj_b, staged.weights.video_patch_proj_b);
+  upload(host.audio_patch_proj_w, staged.weights.audio_patch_proj_w);
+  upload(host.audio_patch_proj_b, staged.weights.audio_patch_proj_b);
+  upload(host.condition_proj_w, staged.weights.condition_proj_w);
+  upload(host.condition_proj_b, staged.weights.condition_proj_b);
+  upload(host.time_proj_in_w, staged.weights.time_proj_in_w);
+  upload(host.time_proj_in_b, staged.weights.time_proj_in_b);
+  upload(host.time_proj_out_w, staged.weights.time_proj_out_w);
+  upload(host.time_proj_out_b, staged.weights.time_proj_out_b);
+  staged.weights.rope_inv_freq = host.rope_inv_freq;  // consumed on the host
+  for (size_t i = 0; i < host.refiner.size(); ++i) {
+    upload_block(host.refiner[i], staged.weights.refiner[i]);
+  }
+  upload(host.refiner_final_norm, staged.weights.refiner_final_norm);
+  for (size_t i = 0; i < host.blocks.size(); ++i) {
+    upload_block(host.blocks[i], staged.weights.blocks[i]);
+  }
+  upload(host.final_norm, staged.weights.final_norm);
+  upload(host.final_adaln_w, staged.weights.final_adaln_w);
+  upload(host.final_adaln_b, staged.weights.final_adaln_b);
+  upload(host.video_out_w, staged.weights.video_out_w);
+  upload(host.video_out_b, staged.weights.video_out_b);
+  upload(host.audio_out_w, staged.weights.audio_out_w);
+  upload(host.audio_out_b, staged.weights.audio_out_b);
+  (void)params;
+  backend.Synchronize(queue);
+  return staged;
+}
+
+MiniMaxH3DitOutputs MiniMaxH3DitForwardDevice(vt::Queue& queue,
+                                              const MiniMaxH3DitParams& params,
+                                              const MiniMaxH3DitWeights& weights,
+                                              const MiniMaxH3DitInputs& inputs,
+                                              DType compute_dtype) {
+  VT_CHECK(compute_dtype == DType::kF32 || compute_dtype == DType::kBF16,
+           "minimax_h3: the device forward computes in f32 (parity) or bf16 (the "
+           "production stream policy)");
+  VT_CHECK(static_cast<int64_t>(weights.blocks.size()) == params.num_layers,
+           "minimax_h3: block weight count does not match num_layers");
+  VT_CHECK(static_cast<int64_t>(weights.refiner.size()) == params.token_refiner_num_layers,
+           "minimax_h3: refiner weight count does not match token_refiner_num_layers");
+  VT_CHECK(inputs.num_cu_seqlens >= 2, "minimax_h3: packed_seq_params.cu_seqlens is required");
+
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  Dev d{backend, queue};
+  const auto* glue = Glue(d);
+  // kBF16 reproduces upstream's PRODUCTION dtype policy: the block stream is bf16
+  // while the patch projections, the time embedder and both output heads stay fp32
+  // islands (minimax_h3_transformer.py:85-101). Both dtypes run the SAME code; only
+  // the rounding points differ -- exactly as in the CPU reference.
+  const DeviceStreamDtype dt{compute_dtype == DType::kBF16};
+
+  const int64_t seq_len = inputs.seq_len;
+  const int64_t hidden = params.hidden_size;
+  const int64_t video_width = params.video_row_width();
+  const int64_t audio_width = params.audio_latents_dim;
+  const int64_t m = inputs.num_unique_timesteps;
+
+  // --- indices, uploaded once (i32: what IndexSelect/IndexCopy and the glue take) ---
+  auto to_i32 = [](const int64_t* src, int64_t n) {
+    std::vector<int32_t> out(static_cast<size_t>(n));
+    for (int64_t i = 0; i < n; ++i) out[static_cast<size_t>(i)] = static_cast<int32_t>(src[i]);
+    return out;
+  };
+  const std::vector<int32_t> img_pos = to_i32(inputs.img_pos, inputs.num_img_pos);
+  const std::vector<int32_t> audio_pos = to_i32(inputs.audio_pos, inputs.num_audio_pos);
+  const std::vector<int32_t> text_pos = to_i32(inputs.text_pos, inputs.num_text_pos);
+  const std::vector<int32_t> infer_out_pos = to_i32(inputs.infer_out_pos, inputs.num_infer_out_pos);
+
+  // combined_indices = inverse_indices * modality_num + token_tags.clamp(min=0)
+  // (minimax_h3_transformer.py:1057).
+  std::vector<int32_t> combined(static_cast<size_t>(seq_len));
+  std::vector<int32_t> inverse(static_cast<size_t>(seq_len));
+  for (int64_t i = 0; i < seq_len; ++i) {
+    const int64_t tag = inputs.token_tags[i] < 0 ? 0 : inputs.token_tags[i];
+    combined[static_cast<size_t>(i)] =
+        static_cast<int32_t>(inputs.inverse_indices[i] * kMiniMaxH3AdalnModalityNum + tag);
+    inverse[static_cast<size_t>(i)] = static_cast<int32_t>(inputs.inverse_indices[i]);
+  }
+  DBuf d_img_pos(d, DType::kI32, {inputs.num_img_pos}, img_pos.data());
+  DBuf d_audio_pos(d, DType::kI32, {inputs.num_audio_pos}, audio_pos.data());
+  DBuf d_text_pos(d, DType::kI32, {inputs.num_text_pos}, text_pos.data());
+  DBuf d_infer_pos(d, DType::kI32, {inputs.num_infer_out_pos}, infer_out_pos.data());
+  DBuf d_combined(d, DType::kI32, {seq_len}, combined.data());
+  DBuf d_inverse(d, DType::kI32, {seq_len}, inverse.data());
+
+  // --- RoPE cache over the full packed sequence (:1040-1041) ---
+  const std::vector<float> rope_cache_host =
+      BuildRopeCosSin(inputs.img_position_ids, seq_len, weights.rope_inv_freq.Ptr<float>(),
+                      params.rope_inv_freq_len);
+  const int64_t rot_dim = params.rope_rot_dim();
+  // vt::RopeFromCache requires q/k/cache to share a dtype, so a bf16 stream gets a
+  // bf16 cache -- the same shape the project's other bf16 models use (qwen3_vl
+  // builds its cache in f32 then CastBf16's it). The ANGLES are still computed in
+  // f32 on the host; only the cached cos/sin are rounded.
+  DBuf d_rope_cache_f32(d, DType::kF32, {seq_len, rot_dim}, rope_cache_host.data());
+  DBuf d_rope_cache(d, dt.S(), {seq_len, rot_dim});
+  CastTo(d, d_rope_cache.t(), d_rope_cache_f32.t());
+  std::vector<int32_t> arange(static_cast<size_t>(seq_len));
+  for (int64_t i = 0; i < seq_len; ++i) arange[static_cast<size_t>(i)] = static_cast<int32_t>(i);
+  DBuf d_rope_pos(d, DType::kI32, {seq_len}, arange.data());
+
+  // --- _embed (minimax_h3_transformer.py:944-984) ---
+  DBuf d_x(d, DType::kF32, {seq_len, video_width}, inputs.x);
+  DBuf video_rows(d, DType::kF32, {inputs.num_img_pos, video_width});
+  vt::IndexSelect(d.q, video_rows.t(), d_x.t(), d_img_pos.t());
+  DBuf video_embed(d, DType::kF32, {inputs.num_img_pos, hidden});
+  LinearDev(d, video_rows.t(), inputs.num_img_pos, video_width, weights.video_patch_proj_w,
+            &weights.video_patch_proj_b, video_embed.t());
+
+  DBuf d_audio_x(d, DType::kF32, {seq_len, audio_width}, inputs.audio_x);
+  DBuf audio_rows(d, DType::kF32, {inputs.num_audio_pos, audio_width});
+  vt::IndexSelect(d.q, audio_rows.t(), d_audio_x.t(), d_audio_pos.t());
+  DBuf audio_embed(d, DType::kF32, {inputs.num_audio_pos, hidden});
+  LinearDev(d, audio_rows.t(), inputs.num_audio_pos, audio_width, weights.audio_patch_proj_w,
+            &weights.audio_patch_proj_b, audio_embed.t());
+
+  // text rows enter as the stream dtype before the BF16 condition projection.
+  // text rows enter as the stream dtype before the BF16 condition projection.
+  DBuf text_rows_f32(d, DType::kF32, {inputs.num_text_pos, params.text_dim}, inputs.prompt_embeds);
+  DBuf text_rows(d, dt.S(), {inputs.num_text_pos, params.text_dim});
+  CastTo(d, text_rows.t(), text_rows_f32.t());
+  DBuf text_embed(d, dt.S(), {inputs.num_text_pos, hidden});
+  LinearDev(d, text_rows.t(), inputs.num_text_pos, params.text_dim, weights.condition_proj_w,
+            &weights.condition_proj_b, text_embed.t());
+
+  // Token refiner: a plain pre-norm stack, no AdaLN and no RoPE (:564-623), on the
+  // REPLICATED text rows, so it uses the refiner's own cu_seqlens.
+  {
+    const int64_t rows = inputs.num_text_pos;
+    DBuf normed(d, dt.S(), {rows, hidden});
+    DBuf tmp(d, dt.S(), {rows, hidden});
+    vt::RmsNormArgs args;
+    args.eps = static_cast<float>(params.norm_eps);
+    for (const MiniMaxH3DitBlockWeights& block : weights.refiner) {
+      vt::RmsNorm(d.q, normed.t(), text_embed.t(), block.norm1, args);
+      AttentionDev(d, params, AttnWeightsDev{&block.qkv_proj, &block.q_norm, &block.k_norm,
+                                             &block.out_proj},
+                   normed.t(), rows, nullptr, nullptr, inputs.refiner_cu_seqlens,
+                   static_cast<int>(inputs.num_refiner_cu_seqlens - 1), dt, tmp.t());
+      // FOLD onto the catalog recipe. This was DECLINED one milestone ago because
+      // the recipe casts nothing between its `residual = x + residual` and its
+      // `rms_norm(residual)`, which would have dropped a bf16 rounding. TRUE bf16
+      // STORAGE removes that objection: the residual operand IS bf16, so the add is
+      // rounded on store before the f32 variance (vt::RmsNorm's documented
+      // bf16-residual behaviour, matching csrc fused_add_rms_norm). Same cast point,
+      // one launch instead of two.
+      vt::FusedChain(d.q, normed.t(), tmp.t(), block.norm2, &text_embed.t(),
+                     vt::kFusedAddRmsNormStd, args.eps);
+      MlpDev(d, params, block.fc1, block.fc2, normed.t(), rows, dt, tmp.t());
+      vt::Add(d.q, text_embed.t(), text_embed.t(), tmp.t());
+    }
+    vt::RmsNormArgs final_args;
+    final_args.eps = static_cast<float>(params.final_norm_eps);
+    vt::RmsNorm(d.q, normed.t(), text_embed.t(), weights.refiner_final_norm, final_args);
+    backend.Copy(d.q, text_embed.ptr(), normed.ptr(), normed.bytes());
+  }
+
+  // index_add_ scatter of the three modality embeddings into the packed stream.
+  // The three position sets are DISJOINT by construction (each packed row carries
+  // exactly one modality), so torch's index_add_ into a zeroed stream is an
+  // index_COPY here — asserted rather than assumed, since a silent overlap would
+  // turn a lost add into a wrong answer.
+  {
+    std::vector<uint8_t> seen(static_cast<size_t>(seq_len), 0);
+    auto mark = [&](const std::vector<int32_t>& pos) {
+      for (int32_t p : pos) {
+        VT_CHECK(p >= 0 && p < seq_len, "minimax_h3: scatter position out of range");
+        VT_CHECK(seen[static_cast<size_t>(p)] == 0,
+                 "minimax_h3: modality scatter positions overlap; index_copy would drop an add");
+        seen[static_cast<size_t>(p)] = 1;
+      }
+    };
+    mark(text_pos);
+    mark(img_pos);
+    mark(audio_pos);
+  }
+  // The patch projections are fp32 ISLANDS; their outputs enter the bf16 stream
+  // only at this indexed scatter (minimax_h3_transformer.py:978-981), which is
+  // exactly where the cast belongs.
+  DBuf video_s(d, dt.S(), {inputs.num_img_pos, hidden});
+  DBuf audio_s(d, dt.S(), {inputs.num_audio_pos, hidden});
+  CastTo(d, video_s.t(), video_embed.t());
+  CastTo(d, audio_s.t(), audio_embed.t());
+  DBuf stream(d, dt.S(), {seq_len, hidden});
+  stream.Zero(d);
+  vt::IndexCopy(d.q, stream.t(), text_embed.t(), d_text_pos.t());
+  vt::IndexCopy(d.q, stream.t(), video_s.t(), d_img_pos.t());
+  vt::IndexCopy(d.q, stream.t(), audio_s.t(), d_audio_pos.t());
+
+  // --- time embedding (minimax_h3_transformer.py:272-285) ---
+  DBuf t_emb(d, DType::kF32, {m, params.time_embed_dim});
+  {
+    const int64_t half = params.timestep_input_dim / 2;
+    std::vector<float> t_freq(static_cast<size_t>(m * params.timestep_input_dim));
+    for (int64_t r = 0; r < m; ++r) {
+      for (int64_t i = 0; i < half; ++i) {
+        const double freq =
+            std::exp(-std::log(10000.0) * static_cast<double>(i) / static_cast<double>(half));
+        const double arg = static_cast<double>(inputs.unique_timesteps[r]) * freq;
+        // Cosine values are concatenated BEFORE sine values.
+        t_freq[static_cast<size_t>(r * params.timestep_input_dim + i)] =
+            static_cast<float>(std::cos(arg));
+        t_freq[static_cast<size_t>(r * params.timestep_input_dim + half + i)] =
+            static_cast<float>(std::sin(arg));
+      }
+    }
+    DBuf d_t_freq(d, DType::kF32, {m, params.timestep_input_dim}, t_freq.data());
+    DBuf mid(d, DType::kF32, {m, params.time_embed_hidden_size});
+    LinearDev(d, d_t_freq.t(), m, params.timestep_input_dim, weights.time_proj_in_w,
+              &weights.time_proj_in_b, mid.t());
+    glue->silu(d.q, mid.t().Ptr<float>(), m * params.time_embed_hidden_size);
+    LinearDev(d, mid.t(), m, params.time_embed_hidden_size, weights.time_proj_out_w,
+              &weights.time_proj_out_b, t_emb.t());
+  }
+
+  // silu(t_emb), hoisted: t_emb is loop-invariant, so the reference's per-block
+  // silu inside AdalnProject is redundant work here.
+  DBuf t_emb_act(d, DType::kF32, {m, params.time_embed_dim});
+  backend.Copy(d.q, t_emb_act.ptr(), t_emb.ptr(), t_emb.bytes());
+  glue->silu(d.q, t_emb_act.t().Ptr<float>(), m * params.time_embed_dim);
+  // silu(t_emb) is fp32; cast to the BF16 AdaLN linear's dtype before the GEMM.
+  DBuf t_emb_s(d, dt.S(), {m, params.time_embed_dim});
+  CastTo(d, t_emb_s.t(), t_emb_act.t());
+
+  // --- the DiT block stack (minimax_h3_transformer.py:645-688) ---
+  const int num_reqs = static_cast<int>(inputs.num_cu_seqlens - 1);
+  const int64_t adaln_rows = m * kMiniMaxH3AdalnModalityNum;
+  DBuf normed(d, dt.S(), {seq_len, hidden});
+  DBuf tmp(d, dt.S(), {seq_len, hidden});
+  DBuf projected(d, dt.S(), {adaln_rows, 6 * hidden});
+  vt::RmsNormArgs block_args;
+  block_args.eps = static_cast<float>(params.norm_eps);
+
+  // Chunk c of AdaLN row r lives at (r * expand + c) * hidden within the flat
+  // projection; as a TENSOR that is a row-strided [rows, hidden] view, so the
+  // chunks need no copy — MatmulBT wrote them where the modulates want them.
+  auto chunk_view = [&](DBuf& buf, int64_t rows, int64_t expand, int64_t c) {
+    std::byte* base = static_cast<std::byte*>(buf.ptr()) +
+                      static_cast<size_t>(c * hidden) * vt::SizeOf(dt.S());
+    Tensor t = MakeTensor(base, dt.S(), d.q.device, {rows, hidden});
+    t.stride[0] = expand * hidden;  // row stride skips the sibling chunks
+    return t;
+  };
+
+  for (const MiniMaxH3DitBlockWeights& block : weights.blocks) {
+    AdalnProjectDev(d, t_emb_s.t(), m, params.time_embed_dim, block.adaln_w, block.adaln_b,
+                    projected.t());
+    const Tensor shift_msa = chunk_view(projected, adaln_rows, 6, 0);
+    const Tensor scale_msa = chunk_view(projected, adaln_rows, 6, 1);
+    const Tensor gate_msa = chunk_view(projected, adaln_rows, 6, 2);
+    const Tensor shift_mlp = chunk_view(projected, adaln_rows, 6, 3);
+    const Tensor scale_mlp = chunk_view(projected, adaln_rows, 6, 4);
+    const Tensor gate_mlp = chunk_view(projected, adaln_rows, 6, 5);
+
+    vt::RmsNorm(d.q, normed.t(), stream.t(), block.norm1, block_args);
+    glue->modulate_scale_shift(d.q, normed.t().data, shift_msa.data, scale_msa.data,
+                               d_combined.t().Ptr<int32_t>(), seq_len, hidden, 6 * hidden,
+                               dt.S());
+    AttentionDev(d, params,
+                 AttnWeightsDev{&block.qkv_proj, &block.q_norm, &block.k_norm, &block.out_proj},
+                 normed.t(), seq_len, &d_rope_cache.t(), &d_rope_pos.t(), inputs.cu_seqlens,
+                 num_reqs, dt, tmp.t());
+    glue->modulate_gate(d.q, stream.t().data, gate_msa.data, tmp.t().data,
+                        d_combined.t().Ptr<int32_t>(), seq_len, hidden, 6 * hidden, dt.S());
+
+    vt::RmsNorm(d.q, normed.t(), stream.t(), block.norm2, block_args);
+    glue->modulate_scale_shift(d.q, normed.t().data, shift_mlp.data, scale_mlp.data,
+                               d_combined.t().Ptr<int32_t>(), seq_len, hidden, 6 * hidden,
+                               dt.S());
+    MlpDev(d, params, block.fc1, block.fc2, normed.t(), seq_len, dt, tmp.t());
+    glue->modulate_gate(d.q, stream.t().data, gate_mlp.data, tmp.t().data,
+                        d_combined.t().Ptr<int32_t>(), seq_len, hidden, 6 * hidden, dt.S());
+  }
+
+  // --- final layer (minimax_h3_transformer.py:724-743) ---
+  DBuf final_projected(d, dt.S(), {m, 2 * hidden});
+  AdalnProjectDev(d, t_emb_s.t(), m, params.time_embed_dim, weights.final_adaln_w,
+                  weights.final_adaln_b, final_projected.t());
+  const Tensor final_shift = chunk_view(final_projected, m, 2, 0);
+  const Tensor final_scale = chunk_view(final_projected, m, 2, 1);
+  vt::RmsNormArgs final_args;
+  final_args.eps = static_cast<float>(params.final_norm_eps);
+  vt::RmsNorm(d.q, normed.t(), stream.t(), weights.final_norm, final_args);
+  // The final layer is single-modality, so it indexes by inverse_indices directly.
+  glue->modulate_scale_shift(d.q, normed.t().data, final_shift.data, final_scale.data,
+                             d_inverse.t().Ptr<int32_t>(), seq_len, hidden, 2 * hidden, dt.S());
+  // Cast UP before both output heads: they are fp32 ISLANDS.
+  DBuf head_in(d, DType::kF32, {seq_len, hidden});
+  CastTo(d, head_in.t(), normed.t());
+
+  DBuf video_all(d, DType::kF32, {seq_len, video_width});
+  LinearDev(d, head_in.t(), seq_len, hidden, weights.video_out_w, &weights.video_out_b,
+            video_all.t());
+  DBuf audio_all(d, DType::kF32, {seq_len, audio_width});
+  LinearDev(d, head_in.t(), seq_len, hidden, weights.audio_out_w, &weights.audio_out_b,
+            audio_all.t());
+
+  // Select the inference-output rows ON DEVICE, so only the selected rows cross
+  // the bus (:1087-1101).
+  MiniMaxH3DitOutputs out;
+  DBuf video_sel(d, DType::kF32, {inputs.num_infer_out_pos, video_width});
+  vt::IndexSelect(d.q, video_sel.t(), video_all.t(), d_infer_pos.t());
+  out.video_logits.resize(static_cast<size_t>(inputs.num_infer_out_pos * video_width));
+  video_sel.Download(d, out.video_logits.data());
+
+  DBuf audio_sel(d, DType::kF32, {inputs.num_audio_pos, audio_width});
+  vt::IndexSelect(d.q, audio_sel.t(), audio_all.t(), d_audio_pos.t());
+  out.audio_logits.resize(static_cast<size_t>(inputs.num_audio_pos * audio_width));
+  audio_sel.Download(d, out.audio_logits.data());
+
+  // Zeroing the pinned condition rows stays on the host: the rows are already
+  // here, and a kernel for it would buy nothing.
+  if (!inputs.skip_mask_out_condition) {
+    VT_CHECK(inputs.update_mask != nullptr, "minimax_h3: update_mask is required");
+    for (int64_t r = 0; r < inputs.num_infer_out_pos; ++r) {
+      if (inputs.update_mask[r]) continue;
+      std::fill_n(out.video_logits.data() + r * video_width, video_width, 0.0f);
+    }
+    if (inputs.audio_update_mask != nullptr) {
+      for (int64_t r = 0; r < inputs.num_audio_pos; ++r) {
+        if (inputs.audio_update_mask[r]) continue;
+        std::fill_n(out.audio_logits.data() + r * audio_width, audio_width, 0.0f);
+      }
+    }
+  }
+  return out;
+}
+
+
+namespace {
+
+// Bind the forward's views over the DEVICE tensors, by the same names the
+// checkpoint uses, so a missing tensor still throws BY NAME.
+//
+// Shared by BOTH streaming stagers (GGUF and NVFP4). One copy deliberately: a
+// name-by-name binding this long would drift the moment a tensor is added to one
+// path only. `rope.inv_freq` is NOT bound here -- it is the one entry that must
+// stay HOST-resident, and each loader reads it from its own container.
+void BindStreamedDitViews(const std::map<std::string, Tensor>& views,
+                          const MiniMaxH3DitParams& params, MiniMaxH3DitWeights* out) {
+  auto view = [&](const std::string& name) -> Tensor {
+    const auto it = views.find(name);
+    VT_CHECK(it != views.end(), "minimax_h3 stream: checkpoint is missing a required tensor");
+    return it->second;
+  };
+  MiniMaxH3DitWeights& w = *out;
+  w.video_patch_proj_w = view("video_patch_proj.weight");
+  w.video_patch_proj_b = view("video_patch_proj.bias");
+  w.audio_patch_proj_w = view("audio_patch_proj.weight");
+  w.audio_patch_proj_b = view("audio_patch_proj.bias");
+  w.condition_proj_w = view("condition_proj.weight");
+  w.condition_proj_b = view("condition_proj.bias");
+  w.time_proj_in_w = view("time_embedder.proj_in.weight");
+  w.time_proj_in_b = view("time_embedder.proj_in.bias");
+  w.time_proj_out_w = view("time_embedder.proj_out.weight");
+  w.time_proj_out_b = view("time_embedder.proj_out.bias");
+  auto block = [&](const std::string& prefix, bool adaln) {
+    MiniMaxH3DitBlockWeights b;
+    b.norm1 = view(prefix + ".norm1.weight");
+    b.norm2 = view(prefix + ".norm2.weight");
+    b.qkv_proj = view(prefix + ".attn.qkv_proj.weight");
+    b.q_norm = view(prefix + ".attn.q_norm.weight");
+    b.k_norm = view(prefix + ".attn.k_norm.weight");
+    b.out_proj = view(prefix + ".attn.out_proj.weight");
+    b.fc1 = view(prefix + ".mlp.fc1.weight");
+    b.fc2 = view(prefix + ".mlp.fc2.weight");
+    if (adaln) {
+      b.adaln_w = view(prefix + ".adaln_proj.linear.weight");
+      b.adaln_b = view(prefix + ".adaln_proj.linear.bias");
+    }
+    return b;
+  };
+  for (int64_t i = 0; i < params.token_refiner_num_layers; ++i) {
+    w.refiner.push_back(block("token_refiner.blocks." + std::to_string(i), false));
+  }
+  w.refiner_final_norm = view("token_refiner.final_norm.weight");
+  for (int64_t i = 0; i < params.num_layers; ++i) {
+    w.blocks.push_back(block("blocks." + std::to_string(i), true));
+  }
+  w.final_norm = view("final_layer.norm.weight");
+  w.final_adaln_w = view("final_layer.adaln_proj.linear.weight");
+  w.final_adaln_b = view("final_layer.adaln_proj.linear.bias");
+  w.video_out_w = view("final_layer.video_out.weight");
+  w.video_out_b = view("final_layer.video_out.bias");
+  w.audio_out_w = view("final_layer.audio_out.weight");
+  w.audio_out_b = view("final_layer.audio_out.bias");
+}
+
+}  // namespace
+
+MiniMaxH3DitDeviceWeights StreamMiniMaxH3DitToDeviceBf16(vt::Queue& queue, const GgufFile& file,
+                                                         MiniMaxH3DitParams* out_params) {
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  const std::vector<MiniMaxH3TensorSpec> manifest = EnumerateMiniMaxH3GgufTensors(file);
+  const MiniMaxH3DitParams params = ParseMiniMaxH3DitParamsFromGgufManifest(manifest);
+  if (out_params != nullptr) *out_params = params;
+
+  // Opt the mapping into page release: without this the DropSpanResidency calls
+  // below are no-ops and the read-once file pages accumulate against the same
+  // unified pool the weights live in.
+  // NOTE: page release is OFF by default here. It was enabled once and the load was
+  // SIGKILLed early at only ~21 GB peak — not a memory problem — so it is gated
+  // behind VT_H3_DROP_PAGES until that is understood rather than left on by faith.
+  const bool drop_pages = std::getenv("VT_H3_DROP_PAGES") != nullptr;
+  if (drop_pages) file.ReleaseExpandedPages(true);
+  const bool trace = std::getenv("VT_H3_PROGRESS") != nullptr;
+  MiniMaxH3DitDeviceWeights staged;
+  std::map<std::string, Tensor> views;
+  // Upstream's fp32 ISLANDS (MINIMAX_H3_FP32_PARAM_NAMES / _BUFFER_NAMES): both patch
+  // projections, both time-embedder projections and both output heads stay f32 even
+  // in a bf16 stream. Their ACTIVATIONS are f32 too, and vt::MatmulBT rejects a
+  // mixed (f32 act, bf16 weight) pair — so getting this split wrong is not a
+  // precision nuance, it fails loudly at the first island GEMM.
+  auto is_fp32_island = [](const std::string& n) {
+    return n.rfind("video_patch_proj.", 0) == 0 || n.rfind("audio_patch_proj.", 0) == 0 ||
+           n.rfind("time_embedder.", 0) == 0 || n.rfind("final_layer.video_out.", 0) == 0 ||
+           n.rfind("final_layer.audio_out.", 0) == 0 || n == "rope.inv_freq";
+  };
+  int64_t done = 0;
+  for (const MiniMaxH3TensorSpec& spec : manifest) {
+    const GgufTensorInfo& info = file.Get(spec.name);
+    int64_t numel = 1;
+    for (int64_t d : spec.shape) numel *= d;
+    VT_CHECK(numel > 0, "minimax_h3 stream: tensor has an empty logical shape");
+    // Dequantize ONE tensor, upload it, and let the host buffer die before the next.
+    // That is the whole point: peak stays at the device copy plus one tensor.
+    {
+      const bool island = is_fp32_island(spec.name);
+      const DType want = island ? DType::kF32 : DType::kBF16;
+      std::vector<float> f32;
+      std::vector<uint16_t> bf16;
+      const void* src = nullptr;
+      size_t bytes = 0;
+      if (island) {
+        f32 = DequantGgufRowToF32(info.ggml_type, static_cast<const uint8_t*>(info.data), numel);
+        VT_CHECK(static_cast<int64_t>(f32.size()) == numel,
+                 "minimax_h3 stream: island dequant produced the wrong element count");
+        src = f32.data();
+        bytes = f32.size() * sizeof(float);
+      } else {
+        bf16 = DequantGgufRowToBf16(info.ggml_type, static_cast<const uint8_t*>(info.data), numel);
+        VT_CHECK(static_cast<int64_t>(bf16.size()) == numel,
+                 "minimax_h3 stream: dequant produced the wrong element count");
+        src = bf16.data();
+        bytes = bf16.size() * sizeof(uint16_t);
+      }
+      void* p = backend.Alloc(bytes);
+      std::shared_ptr<void> owner(p, [&backend](void* q) { backend.Free(q); });
+      backend.Copy(queue, p, src, bytes);
+      backend.Synchronize(queue);  // the host buffer is about to go out of scope
+      views[spec.name] = dense_attn::MakeTensor(p, want, queue.device, spec.shape);
+      staged.storage.push_back(std::move(owner));
+    }
+    // Drop the file pages we will never read again — on a unified-memory box the
+    // page cache competes with the model for the same pool.
+    if (drop_pages) file.DropSpanResidency(static_cast<const uint8_t*>(info.data), info.nbytes);
+    if (trace && (++done % 50 == 0 || done == static_cast<int64_t>(manifest.size()))) {
+      std::fprintf(stderr, "[h3] streamed %lld/%zu tensors (last: %s)\n",
+                   static_cast<long long>(done), manifest.size(), spec.name.c_str());
+      std::fflush(stderr);
+    }
+  }
+
+  MiniMaxH3DitWeights& w = staged.weights;
+  // rope.inv_freq is read on the HOST (BuildRopeCosSin runs before any kernel), so
+  // it is dequantized to host f32 and kept alive by the staged struct. Binding the
+  // device tensor here segfaults on the first forward.
+  {
+    const GgufTensorInfo& info = file.Get("rope.inv_freq");
+    int64_t n = 1;
+    for (int64_t d : info.shape) n *= d;
+    staged.rope_inv_freq_host =
+        DequantGgufRowToF32(info.ggml_type, static_cast<const uint8_t*>(info.data), n);
+    w.rope_inv_freq = vt::Tensor::Contiguous(staged.rope_inv_freq_host.data(), DType::kF32,
+                                             vt::Device{}, {n});
+  }
+  BindStreamedDitViews(views, params, &staged.weights);
+  return staged;
+}
+
+
+// Stream an NVFP4 (compressed-tensors) DiT STRAIGHT ONTO THE DEVICE as bf16.
+//
+// The non-streaming LoadMiniMaxH3DitFromNvfp4 materializes every weight as host
+// f32, which for this checkpoint is ~132 GB and is an OOM kill on a 122 GiB
+// unified box (observed: anon-rss 125 GB, killed during load). It stays as the
+// portable/reference loader; this is the one a real run uses, and it mirrors
+// StreamMiniMaxH3DitToDeviceBf16 exactly: dequantize ONE tensor, upload it, let
+// the host buffer die before the next, so peak is the device copy plus one tensor.
+MiniMaxH3DitDeviceWeights StreamMiniMaxH3Nvfp4ToDeviceBf16(vt::Queue& queue,
+                                                           const SafetensorsFile& file,
+                                                           MiniMaxH3DitParams* out_params) {
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  const bool trace = std::getenv("VT_H3_PROGRESS") != nullptr;
+
+  auto is_sidecar = [](const std::string& n) {
+    return (n.size() > 12 && n.compare(n.size() - 12, 12, "weight_scale") == 0) ||
+           (n.size() > 14 && n.compare(n.size() - 14, 14, "weight_scale_2") == 0);
+  };
+  // Same fp32 ISLANDS as the GGUF stream: vt::MatmulBT rejects a mixed
+  // (f32 activation, bf16 weight) pair, so this split is load-bearing, not a
+  // precision nicety.
+  auto is_fp32_island = [](const std::string& n) {
+    return n.rfind("video_patch_proj.", 0) == 0 || n.rfind("audio_patch_proj.", 0) == 0 ||
+           n.rfind("time_embedder.", 0) == 0 || n.rfind("final_layer.video_out.", 0) == 0 ||
+           n.rfind("final_layer.audio_out.", 0) == 0 || n == "rope.inv_freq";
+  };
+
+  // Pass 1: LOGICAL shapes only (no payload), so geometry is known before any
+  // allocation. A packed [out, in/2] U8 weight is logically [out, in].
+  std::vector<MiniMaxH3TensorSpec> manifest;
+  for (const std::string& name : file.Names()) {
+    if (is_sidecar(name)) continue;
+    const StTensor& t = file.Get(name);
+    MiniMaxH3TensorSpec spec;
+    spec.name = name;
+    spec.shape = t.shape;
+    if (t.dtype == "U8") {
+      VT_CHECK(t.shape.size() == 2, "minimax_h3 nvfp4 stream: a packed weight must be rank 2");
+      spec.shape = {t.shape[0], t.shape[1] * 2};
+    }
+    manifest.push_back(std::move(spec));
+  }
+  const MiniMaxH3DitParams params = ParseMiniMaxH3DitParamsFromGgufManifest(manifest);
+  if (out_params != nullptr) *out_params = params;
+
+  MiniMaxH3DitDeviceWeights staged;
+  std::map<std::string, Tensor> views;
+  size_t done = 0;
+  for (const MiniMaxH3TensorSpec& spec : manifest) {
+    const StTensor& t = file.Get(spec.name);
+    const bool island = is_fp32_island(spec.name);
+
+    // rope.inv_freq is consumed on the HOST (BuildRopeCosSin runs before any
+    // kernel); binding a device pointer here segfaults on the first forward.
+    if (spec.name == "rope.inv_freq") {
+      staged.rope_inv_freq_host = MiniMaxH3ReadSafetensorF32(t);
+      staged.weights.rope_inv_freq = vt::Tensor::Contiguous(
+          staged.rope_inv_freq_host.data(), DType::kF32, vt::Device{},
+          {static_cast<int64_t>(staged.rope_inv_freq_host.size())});
+      continue;
+    }
+
+    std::vector<uint16_t> bf16;
+    std::vector<float> f32;
+    const void* src = nullptr;
+    size_t bytes = 0;
+    DType want = island ? DType::kF32 : DType::kBF16;
+
+    if (t.dtype == "U8") {
+      const int64_t out_dim = spec.shape[0], in_dim = spec.shape[1];
+      const StTensor& scale = file.Get(spec.name + "_scale");
+      const StTensor& global = file.Get(spec.name + "_scale_2");
+      VT_CHECK(scale.dtype == "F8_E4M3", "minimax_h3 nvfp4 stream: weight_scale must be F8_E4M3");
+      VT_CHECK(global.dtype == "F32", "minimax_h3 nvfp4 stream: weight_scale_2 must be F32");
+      VT_CHECK(scale.shape.size() == 2 && scale.shape[0] == out_dim &&
+                   scale.shape[1] * 16 == in_dim,
+               "minimax_h3 nvfp4 stream: weight_scale must be [out, in/16] (group size 16)");
+      VT_CHECK(global.nbytes >= sizeof(float), "minimax_h3 nvfp4 stream: weight_scale_2 too small");
+      float global_scale = 0.0f;
+      std::memcpy(&global_scale, global.data, sizeof(float));
+      bf16.resize(static_cast<size_t>(out_dim * in_dim));
+      DequantNvfp4ToBf16(static_cast<const uint8_t*>(t.data),
+                         static_cast<const uint8_t*>(scale.data), global_scale, out_dim, in_dim,
+                         bf16.data());
+      if (island) {
+        f32.resize(bf16.size());
+        for (size_t i = 0; i < bf16.size(); ++i) {
+          const uint32_t widened = static_cast<uint32_t>(bf16[i]) << 16;
+          std::memcpy(&f32[i], &widened, sizeof(float));
+        }
+        bf16.clear();
+        bf16.shrink_to_fit();
+        src = f32.data();
+        bytes = f32.size() * sizeof(float);
+      } else {
+        src = bf16.data();
+        bytes = bf16.size() * sizeof(uint16_t);
+      }
+    } else {
+      f32 = MiniMaxH3ReadSafetensorF32(t);
+      if (island) {
+        src = f32.data();
+        bytes = f32.size() * sizeof(float);
+      } else {
+        bf16.resize(f32.size());
+        for (size_t i = 0; i < f32.size(); ++i) {
+          uint32_t bits;
+          std::memcpy(&bits, &f32[i], sizeof(bits));
+          // round-to-nearest-even, the same rounding vt uses on a bf16 store
+          const uint32_t rounded = bits + 0x7FFFu + ((bits >> 16) & 1u);
+          bf16[i] = static_cast<uint16_t>(rounded >> 16);
+        }
+        f32.clear();
+        f32.shrink_to_fit();
+        src = bf16.data();
+        bytes = bf16.size() * sizeof(uint16_t);
+      }
+    }
+
+    void* pdev = backend.Alloc(bytes);
+    std::shared_ptr<void> owner(pdev, [&backend](void* q) { backend.Free(q); });
+    backend.Copy(queue, pdev, src, bytes);
+    backend.Synchronize(queue);  // the host buffer dies at the end of this iteration
+    views[spec.name] = dense_attn::MakeTensor(pdev, want, queue.device, spec.shape);
+    staged.storage.push_back(std::move(owner));
+
+    if (trace && (++done % 50 == 0 || done == manifest.size())) {
+      std::fprintf(stderr, "[h3] nvfp4-streamed %zu/%zu tensors (last: %s)\n", done,
+                   manifest.size(), spec.name.c_str());
+      std::fflush(stderr);
+    }
+  }
+
+  BindStreamedDitViews(views, params, &staged.weights);
+  return staged;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_device_resolve.cpp b/src/vllm/model_executor/models/minimax_h3_device_resolve.cpp
new file mode 100644
index 000000000..a17e31741
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_device_resolve.cpp
@@ -0,0 +1,19 @@
+// Resolvers for the MiniMax-H3 device glue table (vt::OpId::kMiniMaxH3).
+// The tables themselves are registered by src/vt/cpu/cpu_minimax_h3.cpp and
+// src/vt/cuda/cuda_minimax_h3.cu; this TU only casts the OpProvider result, so it
+// links in both CPU-only and CUDA builds.
+#include "vllm/model_executor/models/minimax_h3_device.h"
+
+#include "vt/ops.h"
+
+namespace vllm::minimax_h3 {
+
+const MiniMaxH3DeviceKernels* MiniMaxH3Device(vt::DeviceType device) {
+  return static_cast<const MiniMaxH3DeviceKernels*>(vt::GetOp(vt::OpId::kMiniMaxH3, device));
+}
+
+bool MiniMaxH3DeviceKernelsAvailable(vt::DeviceType device) {
+  return vt::OpRegistered(vt::OpId::kMiniMaxH3, device);
+}
+
+}  // namespace vllm::minimax_h3
diff --git a/src/vllm/model_executor/models/minimax_h3_encoder.cpp b/src/vllm/model_executor/models/minimax_h3_encoder.cpp
new file mode 100644
index 000000000..7151a079e
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_encoder.cpp
@@ -0,0 +1,643 @@
+// MiniMax-H3 ENCODER text tower — a Qwen3-VL with three H3-specific deltas.
+//
+// The H3-Encoder produces the `[seq, 5120]` `prompt_embeds` the DiT consumes. It
+// is a Qwen3-VL, which this project already ports (qwen3_vl_{text,vision}.cpp), so
+// the ARCHITECTURE is reuse; what is H3-specific — and what this file pins down and
+// gates — are the three deltas (upstream encoder.py:1-30):
+//
+//   1. LAYER TRUNCATION. Only the first `MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER`
+//      (50) decoder layers are kept: `num_layers = min(config.num_hidden_layers,
+//      selected_layer)`.
+//   2. UNNORMALIZED OUTPUT. The checkpoint consumes the hidden state straight out
+//      of layer 49 — there is NO final RMSNorm, unlike a stock Qwen3-VL text model.
+//      Applying one silently shifts every conditioning vector.
+//   3. DEEPSTACK. Visual features are ADDED at the visual token positions after
+//      each of the first `len(deepstack_visual_embeds)` layers.
+//
+// The layer itself is the familiar pre-norm block: RMSNorm -> fused-QKV attention
+// with per-head q/k RMSNorm and interleaved M-RoPE -> causal GQA SDPA -> o_proj ->
+// residual; RMSNorm -> gated-SiLU MLP -> residual.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+void RmsNormRowsEnc(const float* in, const float* weight, float* out, int64_t rows, int64_t width,
+                    double eps) {
+  for (int64_t r = 0; r < rows; ++r) {
+    const float* src = in + r * width;
+    double sum = 0.0;
+    for (int64_t i = 0; i < width; ++i) sum += static_cast<double>(src[i]) * src[i];
+    const double inv = 1.0 / std::sqrt(sum / static_cast<double>(width) + eps);
+    float* dst = out + r * width;
+    for (int64_t i = 0; i < width; ++i) dst[i] = static_cast<float>(src[i] * inv * weight[i]);
+  }
+}
+
+float SiluEnc(float x) { return x / (1.0f + std::exp(-x)); }
+
+// y = x @ W^T (no bias; Qwen3-VL text projections are bias-free), W [out, in],
+// optionally reading a ROW SLICE of a larger fused weight.
+std::vector<float> LinearSlice(const std::vector<float>& x, int64_t rows, int64_t in_features,
+                               const std::vector<float>& weight, int64_t row_offset,
+                               int64_t out_features) {
+  std::vector<float> out(static_cast<size_t>(rows * out_features));
+  for (int64_t r = 0; r < rows; ++r) {
+    for (int64_t o = 0; o < out_features; ++o) {
+      double acc = 0.0;
+      const float* w = weight.data() + (row_offset + o) * in_features;
+      for (int64_t i = 0; i < in_features; ++i) {
+        acc += static_cast<double>(x[static_cast<size_t>(r * in_features + i)]) *
+               static_cast<double>(w[i]);
+      }
+      out[static_cast<size_t>(r * out_features + o)] = static_cast<float>(acc);
+    }
+  }
+  return out;
+}
+
+}  // namespace
+
+// Interleaved M-RoPE (encoder.py:292-300 + 319-329). `positions` is [3, seq]
+// (temporal, height, width). Produces cos/sin of [seq, head_dim].
+void MiniMaxH3EncoderMrope(const int64_t* positions, int64_t seq, int64_t head_dim,
+                           double rope_theta, const std::vector<int64_t>& mrope_section,
+                           std::vector<float>* cos_out, std::vector<float>* sin_out) {
+  VT_CHECK(head_dim % 2 == 0, "minimax_h3 encoder: head_dim must be even");
+  VT_CHECK(mrope_section.size() == 3, "minimax_h3 encoder: mrope_section must have 3 entries");
+  const int64_t half = head_dim / 2;
+
+  cos_out->assign(static_cast<size_t>(seq * head_dim), 0.0f);
+  sin_out->assign(static_cast<size_t>(seq * head_dim), 0.0f);
+  for (int64_t s = 0; s < seq; ++s) {
+    for (int64_t i = 0; i < half; ++i) {
+      // The frequency slot i takes its position from the TEMPORAL axis by
+      // default; slots at (1, 4, 7, ...) below 3*section[1] come from HEIGHT and
+      // slots at (2, 5, 8, ...) below 3*section[2] come from WIDTH. That is the
+      // "chunked [TTT HHH WWW] -> interleaved [THW THW ...]" reshuffle.
+      int64_t axis = 0;
+      if (i % 3 == 1 && i < 3 * mrope_section[1]) {
+        axis = 1;
+      } else if (i % 3 == 2 && i < 3 * mrope_section[2]) {
+        axis = 2;
+      }
+      const double inv_freq =
+          1.0 / std::pow(rope_theta, static_cast<double>(2 * i) / static_cast<double>(head_dim));
+      const double angle = static_cast<double>(positions[axis * seq + s]) * inv_freq;
+      const float c = static_cast<float>(std::cos(angle));
+      const float sn = static_cast<float>(std::sin(angle));
+      // emb = cat(freqs, freqs) => the second half repeats the first.
+      (*cos_out)[static_cast<size_t>(s * head_dim + i)] = c;
+      (*cos_out)[static_cast<size_t>(s * head_dim + half + i)] = c;
+      (*sin_out)[static_cast<size_t>(s * head_dim + i)] = sn;
+      (*sin_out)[static_cast<size_t>(s * head_dim + half + i)] = sn;
+    }
+  }
+}
+
+// The H3 layer budget: min(config.num_hidden_layers, selected_layer).
+int64_t MiniMaxH3EncoderNumLayers(int64_t config_num_hidden_layers, int64_t selected_layer) {
+  VT_CHECK(config_num_hidden_layers > 0 && selected_layer > 0,
+           "minimax_h3 encoder: layer counts must be positive");
+  return std::min(config_num_hidden_layers, selected_layer);
+}
+
+std::vector<float> MiniMaxH3EncoderTextForward(const MiniMaxH3EncoderConfig& config,
+                                               const MiniMaxH3AudioVaeWeights& weights,
+                                               const std::vector<float>& inputs_embeds,
+                                               const int64_t* positions, int64_t seq,
+                                               const uint8_t* visual_pos_mask,
+                                               const std::vector<std::vector<float>>& deepstack) {
+  const int64_t hidden = config.hidden_size;
+  const int64_t heads = config.num_attention_heads;
+  const int64_t kv_heads = config.num_key_value_heads;
+  const int64_t head_dim = config.head_dim;
+  const int64_t q_width = heads * head_dim;
+  const int64_t kv_width = kv_heads * head_dim;
+  VT_CHECK(static_cast<int64_t>(inputs_embeds.size()) == seq * hidden,
+           "minimax_h3 encoder: inputs_embeds size does not match [seq, hidden]");
+  VT_CHECK(heads % kv_heads == 0, "minimax_h3 encoder: heads must be a multiple of kv_heads");
+  const int64_t groups = heads / kv_heads;
+
+  std::vector<float> cos, sin;
+  MiniMaxH3EncoderMrope(positions, seq, head_dim, config.rope_theta, config.mrope_section, &cos,
+                        &sin);
+
+  const int64_t num_layers =
+      MiniMaxH3EncoderNumLayers(config.num_hidden_layers, config.selected_layer);
+  std::vector<float> h = inputs_embeds;
+  std::vector<float> normed(h.size());
+
+  for (int64_t layer = 0; layer < num_layers; ++layer) {
+    const std::string p = "layers." + std::to_string(layer) + ".";
+    RmsNormRowsEnc(h.data(), weights.Get(p + "input_layernorm.weight").data(), normed.data(), seq,
+                   hidden, config.rms_norm_eps);
+
+    // Fused qkv weight rows are [q_all | k_all | v_all].
+    const std::vector<float>& qkv_w = weights.Get(p + "self_attn.qkv_proj.weight");
+    std::vector<float> q = LinearSlice(normed, seq, hidden, qkv_w, 0, q_width);
+    std::vector<float> k = LinearSlice(normed, seq, hidden, qkv_w, q_width, kv_width);
+    const std::vector<float> v = LinearSlice(normed, seq, hidden, qkv_w, q_width + kv_width, kv_width);
+
+    // Per-head q/k RMSNorm, THEN RoPE.
+    std::vector<float> qn(q.size()), kn(k.size());
+    RmsNormRowsEnc(q.data(), weights.Get(p + "self_attn.q_norm.weight").data(), qn.data(),
+                   seq * heads, head_dim, config.rms_norm_eps);
+    RmsNormRowsEnc(k.data(), weights.Get(p + "self_attn.k_norm.weight").data(), kn.data(),
+                   seq * kv_heads, head_dim, config.rms_norm_eps);
+    const int64_t rot_half = head_dim / 2;
+    auto apply_rope = [&](std::vector<float>& x, int64_t n_heads) {
+      for (int64_t s = 0; s < seq; ++s) {
+        const float* c = cos.data() + s * head_dim;
+        const float* sn = sin.data() + s * head_dim;
+        for (int64_t head = 0; head < n_heads; ++head) {
+          float* row = x.data() + (s * n_heads + head) * head_dim;
+          for (int64_t i = 0; i < rot_half; ++i) {
+            const float lo = row[i], hi = row[i + rot_half];
+            row[i] = lo * c[i] - hi * sn[i];
+            row[i + rot_half] = hi * c[i + rot_half] + lo * sn[i + rot_half];
+          }
+        }
+      }
+    };
+    apply_rope(qn, heads);
+    apply_rope(kn, kv_heads);
+
+    // CAUSAL GQA attention (is_causal=True upstream).
+    std::vector<float> attn(static_cast<size_t>(seq * q_width), 0.0f);
+    std::vector<double> probs(static_cast<size_t>(seq));
+    const double scale = 1.0 / std::sqrt(static_cast<double>(head_dim));
+    for (int64_t head = 0; head < heads; ++head) {
+      const int64_t kv_head = head / groups;
+      for (int64_t i = 0; i < seq; ++i) {
+        double max_score = -1e30;
+        for (int64_t j = 0; j <= i; ++j) {
+          double dot = 0.0;
+          for (int64_t d = 0; d < head_dim; ++d) {
+            dot += static_cast<double>(qn[static_cast<size_t>((i * heads + head) * head_dim + d)]) *
+                   static_cast<double>(kn[static_cast<size_t>((j * kv_heads + kv_head) * head_dim + d)]);
+          }
+          probs[static_cast<size_t>(j)] = dot * scale;
+          max_score = std::max(max_score, probs[static_cast<size_t>(j)]);
+        }
+        double denom = 0.0;
+        for (int64_t j = 0; j <= i; ++j) {
+          probs[static_cast<size_t>(j)] = std::exp(probs[static_cast<size_t>(j)] - max_score);
+          denom += probs[static_cast<size_t>(j)];
+        }
+        for (int64_t d = 0; d < head_dim; ++d) {
+          double acc = 0.0;
+          for (int64_t j = 0; j <= i; ++j) {
+            acc += probs[static_cast<size_t>(j)] *
+                   static_cast<double>(v[static_cast<size_t>((j * kv_heads + kv_head) * head_dim + d)]);
+          }
+          attn[static_cast<size_t>((i * heads + head) * head_dim + d)] =
+              static_cast<float>(acc / denom);
+        }
+      }
+    }
+    const std::vector<float> projected =
+        LinearSlice(attn, seq, q_width, weights.Get(p + "self_attn.o_proj.weight"), 0, hidden);
+    for (size_t i = 0; i < h.size(); ++i) h[i] += projected[i];
+
+    // gated-SiLU MLP; gate_up_proj rows are [gate | up].
+    RmsNormRowsEnc(h.data(), weights.Get(p + "post_attention_layernorm.weight").data(),
+                   normed.data(), seq, hidden, config.rms_norm_eps);
+    const std::vector<float>& gate_up = weights.Get(p + "mlp.gate_up_proj.weight");
+    const std::vector<float> gate = LinearSlice(normed, seq, hidden, gate_up, 0, config.intermediate_size);
+    const std::vector<float> up =
+        LinearSlice(normed, seq, hidden, gate_up, config.intermediate_size, config.intermediate_size);
+    std::vector<float> act(gate.size());
+    for (size_t i = 0; i < act.size(); ++i) act[i] = SiluEnc(gate[i]) * up[i];
+    const std::vector<float> down =
+        LinearSlice(act, seq, config.intermediate_size, weights.Get(p + "mlp.down_proj.weight"), 0,
+                    hidden);
+    for (size_t i = 0; i < h.size(); ++i) h[i] += down[i];
+
+    // DeepStack: add the visual features into the visual token rows, for the
+    // FIRST len(deepstack) layers only (encoder.py:770-779, 792-798).
+    if (layer < static_cast<int64_t>(deepstack.size())) {
+      VT_CHECK(visual_pos_mask != nullptr,
+               "minimax_h3 encoder: deepstack embeds require a visual position mask");
+      const std::vector<float>& embeds = deepstack[static_cast<size_t>(layer)];
+      int64_t visual_index = 0;
+      for (int64_t s = 0; s < seq; ++s) {
+        if (!visual_pos_mask[s]) continue;
+        for (int64_t i = 0; i < hidden; ++i) {
+          h[static_cast<size_t>(s * hidden + i)] +=
+              embeds[static_cast<size_t>(visual_index * hidden + i)];
+        }
+        ++visual_index;
+      }
+    }
+  }
+  // NO final norm: the checkpoint consumes the UNNORMALIZED layer-49 state.
+  return h;
+}
+
+// ---------------------------------------------------------------------------
+// Vision tower block (encoder.py:417-481) — the repeated unit of the ViT.
+//
+// Differs from the TEXT tower in several ways that all matter numerically:
+//   * LayerNorm (with bias), not RMSNorm, at eps 1e-6;
+//   * the qkv output is reshaped [seq, 3, heads, head_dim] and PERMUTED, so the
+//     layout is [q_all | k_all | v_all] per token — not the per-head interleave
+//     the video VAE's ViT uses;
+//   * rotary is applied in FP32 with cos/sin supplied per token;
+//   * attention is NON-CAUSAL and segmented by `cu_seqlens` (one segment per
+//     image/frame), so it never crosses a packed-image boundary;
+//   * the MLP uses the TANH-approximate GELU (`gelu_pytorch_tanh`), not exact erf.
+// ---------------------------------------------------------------------------
+
+namespace {
+
+// nn.LayerNorm over the last dim.
+void LayerNormRows(const float* in, const float* weight, const float* bias, float* out,
+                   int64_t rows, int64_t width, double eps) {
+  for (int64_t r = 0; r < rows; ++r) {
+    const float* src = in + r * width;
+    double mean = 0.0;
+    for (int64_t i = 0; i < width; ++i) mean += src[i];
+    mean /= static_cast<double>(width);
+    double var = 0.0;
+    for (int64_t i = 0; i < width; ++i) var += (src[i] - mean) * (src[i] - mean);
+    var /= static_cast<double>(width);
+    const double inv = 1.0 / std::sqrt(var + eps);
+    float* dst = out + r * width;
+    for (int64_t i = 0; i < width; ++i) {
+      double value = (src[i] - mean) * inv * weight[i];
+      if (bias != nullptr) value += bias[i];
+      dst[i] = static_cast<float>(value);
+    }
+  }
+}
+
+// nn.GELU(approximate="tanh").
+float GeluTanh(float x) {
+  const double xd = x;
+  const double inner = 0.7978845608028654 * (xd + 0.044715 * xd * xd * xd);
+  return static_cast<float>(0.5 * xd * (1.0 + std::tanh(inner)));
+}
+
+// y = x @ W^T + b.
+std::vector<float> LinearBias(const std::vector<float>& x, int64_t rows, int64_t in_features,
+                              const std::vector<float>& weight, const std::vector<float>* bias,
+                              int64_t out_features) {
+  std::vector<float> out(static_cast<size_t>(rows * out_features));
+  for (int64_t r = 0; r < rows; ++r) {
+    for (int64_t o = 0; o < out_features; ++o) {
+      double acc = bias != nullptr ? (*bias)[static_cast<size_t>(o)] : 0.0;
+      const float* w = weight.data() + o * in_features;
+      for (int64_t i = 0; i < in_features; ++i) {
+        acc += static_cast<double>(x[static_cast<size_t>(r * in_features + i)]) *
+               static_cast<double>(w[i]);
+      }
+      out[static_cast<size_t>(r * out_features + o)] = static_cast<float>(acc);
+    }
+  }
+  return out;
+}
+
+}  // namespace
+
+std::vector<float> MiniMaxH3VisionBlockForward(const MiniMaxH3VisionBlockConfig& config,
+                                               const MiniMaxH3AudioVaeWeights& weights,
+                                               const std::string& prefix,
+                                               const std::vector<float>& hidden, int64_t seq,
+                                               const float* cos, const float* sin,
+                                               const int32_t* cu_seqlens, int64_t num_segments) {
+  const int64_t dim = config.hidden_size;
+  const int64_t heads = config.num_heads;
+  const int64_t head_dim = dim / heads;
+  VT_CHECK(dim > 0 && heads > 0 && dim % heads == 0,
+           "minimax_h3 vision: hidden_size must divide by num_heads");
+  VT_CHECK(static_cast<int64_t>(hidden.size()) == seq * dim,
+           "minimax_h3 vision: hidden size does not match [seq, dim]");
+
+  std::vector<float> h = hidden;
+  std::vector<float> normed(h.size());
+
+  // --- attention ---
+  LayerNormRows(h.data(), weights.Get(prefix + ".norm1.weight").data(),
+                weights.Get(prefix + ".norm1.bias").data(), normed.data(), seq, dim, config.eps);
+  const std::vector<float> qkv =
+      LinearBias(normed, seq, dim, weights.Get(prefix + ".attn.qkv.weight"),
+                 &weights.Get(prefix + ".attn.qkv.bias"), 3 * dim);
+
+  // reshape(seq, 3, heads, head_dim).permute(1,0,2,3) => q/k/v each [seq, heads, head_dim].
+  std::vector<float> q(static_cast<size_t>(seq * dim));
+  std::vector<float> k(static_cast<size_t>(seq * dim));
+  std::vector<float> v(static_cast<size_t>(seq * dim));
+  for (int64_t s = 0; s < seq; ++s) {
+    const float* row = qkv.data() + s * 3 * dim;
+    std::copy(row, row + dim, q.begin() + s * dim);
+    std::copy(row + dim, row + 2 * dim, k.begin() + s * dim);
+    std::copy(row + 2 * dim, row + 3 * dim, v.begin() + s * dim);
+  }
+
+  // Rotary in FP32, cos/sin shared across heads (encoder.py:404-415).
+  const int64_t half = head_dim / 2;
+  for (int64_t s = 0; s < seq; ++s) {
+    const float* c = cos + s * head_dim;
+    const float* sn = sin + s * head_dim;
+    for (int64_t head = 0; head < heads; ++head) {
+      for (std::vector<float>* target : {&q, &k}) {
+        float* row = target->data() + (s * heads + head) * head_dim;
+        for (int64_t i = 0; i < half; ++i) {
+          const double lo = row[i], hi = row[i + half];
+          row[i] = static_cast<float>(lo * c[i] - hi * sn[i]);
+          row[i + half] = static_cast<float>(hi * c[i + half] + lo * sn[i + half]);
+        }
+      }
+    }
+  }
+
+  // Non-causal attention, segmented by cu_seqlens.
+  std::vector<float> attn(static_cast<size_t>(seq * dim), 0.0f);
+  const double scale = 1.0 / std::sqrt(static_cast<double>(head_dim));
+  std::vector<double> probs;
+  for (int64_t seg = 0; seg < num_segments; ++seg) {
+    const int64_t begin = cu_seqlens[seg];
+    const int64_t end = cu_seqlens[seg + 1];
+    const int64_t len = end - begin;
+    if (len <= 0) continue;
+    probs.resize(static_cast<size_t>(len));
+    for (int64_t head = 0; head < heads; ++head) {
+      for (int64_t i = begin; i < end; ++i) {
+        double max_score = -1e30;
+        for (int64_t j = begin; j < end; ++j) {
+          double dot = 0.0;
+          for (int64_t d = 0; d < head_dim; ++d) {
+            dot += static_cast<double>(q[static_cast<size_t>((i * heads + head) * head_dim + d)]) *
+                   static_cast<double>(k[static_cast<size_t>((j * heads + head) * head_dim + d)]);
+          }
+          probs[static_cast<size_t>(j - begin)] = dot * scale;
+          max_score = std::max(max_score, probs[static_cast<size_t>(j - begin)]);
+        }
+        double denom = 0.0;
+        for (int64_t j = 0; j < len; ++j) {
+          probs[static_cast<size_t>(j)] = std::exp(probs[static_cast<size_t>(j)] - max_score);
+          denom += probs[static_cast<size_t>(j)];
+        }
+        for (int64_t d = 0; d < head_dim; ++d) {
+          double acc = 0.0;
+          for (int64_t j = 0; j < len; ++j) {
+            acc += probs[static_cast<size_t>(j)] *
+                   static_cast<double>(
+                       v[static_cast<size_t>(((begin + j) * heads + head) * head_dim + d)]);
+          }
+          attn[static_cast<size_t>((i * heads + head) * head_dim + d)] =
+              static_cast<float>(acc / denom);
+        }
+      }
+    }
+  }
+  const std::vector<float> projected =
+      LinearBias(attn, seq, dim, weights.Get(prefix + ".attn.proj.weight"),
+                 &weights.Get(prefix + ".attn.proj.bias"), dim);
+  for (size_t i = 0; i < h.size(); ++i) h[i] += projected[i];
+
+  // --- MLP with tanh-approximate GELU ---
+  LayerNormRows(h.data(), weights.Get(prefix + ".norm2.weight").data(),
+                weights.Get(prefix + ".norm2.bias").data(), normed.data(), seq, dim, config.eps);
+  std::vector<float> mid =
+      LinearBias(normed, seq, dim, weights.Get(prefix + ".mlp.linear_fc1.weight"),
+                 &weights.Get(prefix + ".mlp.linear_fc1.bias"), config.intermediate_size);
+  for (float& value : mid) value = GeluTanh(value);
+  const std::vector<float> down =
+      LinearBias(mid, seq, config.intermediate_size, weights.Get(prefix + ".mlp.linear_fc2.weight"),
+                 &weights.Get(prefix + ".mlp.linear_fc2.bias"), dim);
+  for (size_t i = 0; i < h.size(); ++i) h[i] += down[i];
+  return h;
+}
+
+// ---------------------------------------------------------------------------
+// Vision tower surround (encoder.py:483-600) — patch embed, interpolated
+// position embedding, 2D rotary, the block stack, and the patch mergers.
+// ---------------------------------------------------------------------------
+
+// The learned position grid is BILINEARLY resampled to each image's patch grid,
+// then permuted into spatial-merge order (encoder.py:544-585). `num_grid_per_side`
+// is sqrt(num_position_embeddings).
+std::vector<float> MiniMaxH3VisionPosEmbedInterpolate(const std::vector<float>& pos_embed_table,
+                                                      int64_t num_grid_per_side, int64_t dim,
+                                                      const std::vector<int64_t>& grid_thw,
+                                                      int64_t merge_size) {
+  std::vector<float> out;
+  for (size_t g = 0; g + 2 < grid_thw.size() + 1 && g * 3 + 2 < grid_thw.size(); ++g) {
+    const int64_t t = grid_thw[g * 3 + 0];
+    const int64_t h = grid_thw[g * 3 + 1];
+    const int64_t w = grid_thw[g * 3 + 2];
+
+    // torch.linspace(0, n-1, k): with k == 1 torch returns just the START.
+    auto linspace = [&](int64_t count) {
+      std::vector<double> v(static_cast<size_t>(count));
+      if (count == 1) {
+        v[0] = 0.0;
+        return v;
+      }
+      const double step = static_cast<double>(num_grid_per_side - 1) / static_cast<double>(count - 1);
+      for (int64_t i = 0; i < count; ++i) v[static_cast<size_t>(i)] = static_cast<double>(i) * step;
+      return v;
+    };
+    const std::vector<double> h_idxs = linspace(h);
+    const std::vector<double> w_idxs = linspace(w);
+
+    // Bilinear over the four surrounding grid points; `.int()` TRUNCATES.
+    std::vector<float> plane(static_cast<size_t>(h * w * dim), 0.0f);
+    for (int64_t i = 0; i < h; ++i) {
+      const int64_t hf = static_cast<int64_t>(h_idxs[static_cast<size_t>(i)]);
+      const int64_t hc = std::min<int64_t>(hf + 1, num_grid_per_side - 1);
+      const double dh = h_idxs[static_cast<size_t>(i)] - static_cast<double>(hf);
+      for (int64_t j = 0; j < w; ++j) {
+        const int64_t wf = static_cast<int64_t>(w_idxs[static_cast<size_t>(j)]);
+        const int64_t wc = std::min<int64_t>(wf + 1, num_grid_per_side - 1);
+        const double dw = w_idxs[static_cast<size_t>(j)] - static_cast<double>(wf);
+        const int64_t idx[4] = {hf * num_grid_per_side + wf, hf * num_grid_per_side + wc,
+                                hc * num_grid_per_side + wf, hc * num_grid_per_side + wc};
+        const double wt[4] = {(1.0 - dh) * (1.0 - dw), (1.0 - dh) * dw, dh * (1.0 - dw), dh * dw};
+        float* dst = plane.data() + (i * w + j) * dim;
+        for (int64_t c = 0; c < dim; ++c) {
+          double acc = 0.0;
+          for (int k = 0; k < 4; ++k) {
+            acc += static_cast<double>(
+                       pos_embed_table[static_cast<size_t>(idx[k] * dim + c)]) * wt[k];
+          }
+          dst[c] = static_cast<float>(acc);
+        }
+      }
+    }
+
+    // repeat over t, then view(t, h/m, m, w/m, m, -1).permute(0,1,3,2,4,5).flatten
+    const int64_t mh = h / merge_size, mw = w / merge_size;
+    for (int64_t frame = 0; frame < t; ++frame) {
+      for (int64_t bh = 0; bh < mh; ++bh) {
+        for (int64_t bw = 0; bw < mw; ++bw) {
+          for (int64_t ih = 0; ih < merge_size; ++ih) {
+            for (int64_t iw = 0; iw < merge_size; ++iw) {
+              const int64_t row = (bh * merge_size + ih) * w + (bw * merge_size + iw);
+              const float* src = plane.data() + row * dim;
+              out.insert(out.end(), src, src + dim);
+            }
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// 2D rotary position ids in spatial-merge order (encoder.py:510-537), then
+// freq_table[pos_ids].flatten(1) -> [tokens, 2 * (head_dim/2 / 2)].
+std::vector<float> MiniMaxH3VisionRotary(const std::vector<int64_t>& grid_thw, int64_t merge_size,
+                                         int64_t rotary_dim, double theta) {
+  int64_t max_hw = 0;
+  for (size_t g = 0; g * 3 + 2 < grid_thw.size(); ++g) {
+    max_hw = std::max({max_hw, grid_thw[g * 3 + 1], grid_thw[g * 3 + 2]});
+  }
+  const int64_t freqs = rotary_dim / 2;
+  std::vector<double> inv(static_cast<size_t>(freqs));
+  for (int64_t i = 0; i < freqs; ++i) {
+    inv[static_cast<size_t>(i)] =
+        1.0 / std::pow(theta, static_cast<double>(2 * i) / static_cast<double>(rotary_dim));
+  }
+  // freq_table[p][f] = p * inv[f]
+  auto table = [&](int64_t pos, int64_t f) { return static_cast<double>(pos) * inv[static_cast<size_t>(f)]; };
+
+  std::vector<float> out;
+  for (size_t g = 0; g * 3 + 2 < grid_thw.size(); ++g) {
+    const int64_t t = grid_thw[g * 3 + 0];
+    const int64_t h = grid_thw[g * 3 + 1];
+    const int64_t w = grid_thw[g * 3 + 2];
+    const int64_t mh = h / merge_size, mw = w / merge_size;
+    std::vector<float> one;
+    for (int64_t bh = 0; bh < mh; ++bh) {
+      for (int64_t bw = 0; bw < mw; ++bw) {
+        for (int64_t ih = 0; ih < merge_size; ++ih) {
+          for (int64_t iw = 0; iw < merge_size; ++iw) {
+            const int64_t row = bh * merge_size + ih;
+            const int64_t col = bw * merge_size + iw;
+            for (int64_t f = 0; f < freqs; ++f) one.push_back(static_cast<float>(table(row, f)));
+            for (int64_t f = 0; f < freqs; ++f) one.push_back(static_cast<float>(table(col, f)));
+          }
+        }
+      }
+    }
+    for (int64_t frame = 0; frame < t; ++frame) out.insert(out.end(), one.begin(), one.end());
+  }
+  (void)max_hw;  // the table is evaluated lazily; max_hw only bounds it upstream
+  return out;
+}
+
+namespace {
+
+// PatchMerger (encoder.py:372-386): LayerNorm -> fc1 -> exact-erf GELU -> fc2.
+// `use_postshuffle_norm` decides whether the norm sees the pre- or post-shuffle
+// width, which is why the DeepStack mergers and the final merger differ.
+std::vector<float> PatchMerger(const MiniMaxH3AudioVaeWeights& weights, const std::string& prefix,
+                               const std::vector<float>& x, int64_t rows, int64_t dim,
+                               int64_t merged_width, int64_t out_hidden, bool postshuffle,
+                               double eps) {
+  const int64_t groups = rows / (merged_width / dim);
+  std::vector<float> normed(x.size());
+  if (postshuffle) {
+    LayerNormRows(x.data(), weights.Get(prefix + ".norm.weight").data(),
+                  weights.Get(prefix + ".norm.bias").data(), normed.data(), groups, merged_width,
+                  eps);
+  } else {
+    LayerNormRows(x.data(), weights.Get(prefix + ".norm.weight").data(),
+                  weights.Get(prefix + ".norm.bias").data(), normed.data(), rows, dim, eps);
+  }
+  std::vector<float> mid =
+      LinearBias(normed, groups, merged_width, weights.Get(prefix + ".linear_fc1.weight"),
+                 &weights.Get(prefix + ".linear_fc1.bias"), merged_width);
+  for (float& value : mid) {
+    // nn.GELU() default = EXACT erf, unlike the vision MLP's tanh approximation.
+    value = static_cast<float>(0.5 * value * (1.0 + std::erf(value / std::sqrt(2.0))));
+  }
+  return LinearBias(mid, groups, merged_width, weights.Get(prefix + ".linear_fc2.weight"),
+                    &weights.Get(prefix + ".linear_fc2.bias"), out_hidden);
+}
+
+}  // namespace
+
+MiniMaxH3VisionTowerResult MiniMaxH3VisionTowerForward(
+    const MiniMaxH3VisionTowerConfig& config, const MiniMaxH3AudioVaeWeights& weights,
+    const std::vector<float>& patches, const std::vector<int64_t>& grid_thw) {
+  const int64_t dim = config.block.hidden_size;
+  const int64_t merge = config.spatial_merge_size;
+  const int64_t patch_elems =
+      config.in_channels * config.temporal_patch_size * config.patch_size * config.patch_size;
+  int64_t tokens = 0;
+  for (size_t g = 0; g * 3 + 2 < grid_thw.size(); ++g) {
+    tokens += grid_thw[g * 3] * grid_thw[g * 3 + 1] * grid_thw[g * 3 + 2];
+  }
+  VT_CHECK(static_cast<int64_t>(patches.size()) == tokens * patch_elems,
+           "minimax_h3 vision: patch input does not match the grid");
+
+  // patch_embed: a Conv3d whose kernel EQUALS its stride is a linear map over the
+  // flattened patch (encoder.py:337-353).
+  std::vector<float> h = LinearBias(patches, tokens, patch_elems,
+                                    weights.Get("patch_embed.proj.weight"),
+                                    &weights.Get("patch_embed.proj.bias"), dim);
+
+  const int64_t num_grid_per_side =
+      static_cast<int64_t>(std::llround(std::sqrt(static_cast<double>(config.num_position_embeddings))));
+  VT_CHECK(num_grid_per_side * num_grid_per_side == config.num_position_embeddings,
+           "minimax_h3 vision: num_position_embeddings must be a perfect square");
+  const std::vector<float> pos = MiniMaxH3VisionPosEmbedInterpolate(
+      weights.Get("pos_embed.weight"), num_grid_per_side, dim, grid_thw, merge);
+  VT_CHECK(pos.size() == h.size(), "minimax_h3 vision: position embedding size mismatch");
+  for (size_t i = 0; i < h.size(); ++i) h[i] += pos[i];
+
+  const int64_t head_dim = dim / config.block.num_heads;
+  const std::vector<float> freqs =
+      MiniMaxH3VisionRotary(grid_thw, merge, head_dim / 2, config.rope_theta);
+  // emb = cat(freqs, freqs); cos/sin over [tokens, head_dim].
+  const int64_t rot = head_dim / 2;
+  std::vector<float> cos(static_cast<size_t>(tokens * head_dim));
+  std::vector<float> sin(static_cast<size_t>(tokens * head_dim));
+  for (int64_t s = 0; s < tokens; ++s) {
+    for (int64_t i = 0; i < rot; ++i) {
+      const double angle = freqs[static_cast<size_t>(s * rot + i)];
+      cos[static_cast<size_t>(s * head_dim + i)] = static_cast<float>(std::cos(angle));
+      cos[static_cast<size_t>(s * head_dim + rot + i)] = static_cast<float>(std::cos(angle));
+      sin[static_cast<size_t>(s * head_dim + i)] = static_cast<float>(std::sin(angle));
+      sin[static_cast<size_t>(s * head_dim + rot + i)] = static_cast<float>(std::sin(angle));
+    }
+  }
+
+  // cu_seqlens: one segment per FRAME (h*w repeated t times), cumulative.
+  std::vector<int32_t> cu = {0};
+  for (size_t g = 0; g * 3 + 2 < grid_thw.size(); ++g) {
+    const int64_t frame_tokens = grid_thw[g * 3 + 1] * grid_thw[g * 3 + 2];
+    for (int64_t f = 0; f < grid_thw[g * 3]; ++f) cu.push_back(cu.back() + static_cast<int32_t>(frame_tokens));
+  }
+
+  MiniMaxH3VisionTowerResult result;
+  const int64_t merged_width = dim * merge * merge;
+  for (int64_t layer = 0; layer < config.depth; ++layer) {
+    h = MiniMaxH3VisionBlockForward(config.block, weights,
+                                    "blocks." + std::to_string(layer), h, tokens, cos.data(),
+                                    sin.data(), cu.data(), static_cast<int64_t>(cu.size()) - 1);
+    for (size_t d = 0; d < config.deepstack_visual_indexes.size(); ++d) {
+      if (config.deepstack_visual_indexes[d] != layer) continue;
+      result.deepstack.push_back(PatchMerger(
+          weights, "deepstack_merger_list." + std::to_string(d), h, tokens, dim, merged_width,
+          config.out_hidden_size, /*postshuffle=*/true, config.block.eps));
+    }
+  }
+  result.merged = PatchMerger(weights, "merger", h, tokens, dim, merged_width,
+                              config.out_hidden_size, /*postshuffle=*/false, config.block.eps);
+  return result;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_encoder_device.cpp b/src/vllm/model_executor/models/minimax_h3_encoder_device.cpp
new file mode 100644
index 000000000..56e832846
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_encoder_device.cpp
@@ -0,0 +1,225 @@
+// H3-Encoder — the DEVICE-resident text tower, running from ggml blocks.
+//
+// This is what makes real text conditioning possible on a box that cannot hold the
+// encoder in f32: the tower is 32B (~128 GB expanded, ~13.2 GiB kept quantized), so
+// the projections stay in their blocks and go through vt::MatmulBT, which dispatches
+// kMatmulBTQuant on a block-typed weight. No dequantization anywhere on this path.
+//
+// Structure is 1:1 with MiniMaxH3EncoderTextForward (the gated host reference), and
+// the three H3 deltas are preserved:
+//   * LAYER TRUNCATION to min(num_hidden_layers, selected_layer) — 50, not 64;
+//   * the output is UNNORMALIZED (no final RMSNorm), which is why `norm.weight` is
+//     not even loaded;
+//   * DeepStack injection is the caller's business (text-only prompts have none).
+//
+// The M-RoPE looks like it needs a bespoke kernel and does not. Upstream builds
+// `emb = cat(freqs, freqs)`, so cos and sin REPEAT across the two halves — exactly
+// vt::RopeFromCache's [cos_half | sin_half] layout. Only the ANGLES are unusual
+// (three axes interleaved as [THW THW ...] over the frequency slots), and those are
+// computed host-side once per prompt.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "vllm/model_executor/models/dense_device_glue.h"
+#include "vt/backend.h"
+#include "vt/dtype.h"
+#include "vt/ops.h"
+
+namespace vllm {
+
+const vt::Tensor& MiniMaxH3EncoderDeviceWeights::Get(const std::string& name) const {
+  const auto it = views.find(name);
+  VT_CHECK(it != views.end(), "minimax_h3 encoder device: missing tensor (by name)");
+  return it->second;
+}
+
+MiniMaxH3EncoderDeviceWeights StageMiniMaxH3EncoderWeights(
+    vt::Queue& queue, const MiniMaxH3EncoderQuantWeights& host) {
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  MiniMaxH3EncoderDeviceWeights out;
+  for (const auto& kv : host.views) {
+    const vt::Tensor& src = kv.second;
+    // Block-quant tensors go up VERBATIM; f32 norms go up as-is. Either way the
+    // GEMM must see DEVICE memory — a host-byte view reads as zeros on the GPU and
+    // a CPU-only gate cannot catch it.
+    const size_t bytes = vt::IsBlockQuant(src.dtype)
+                             ? static_cast<size_t>(src.shape[0]) *
+                                   vt::RowSizeBytes(src.dtype, src.shape[1])
+                             : static_cast<size_t>(src.Numel()) * vt::SizeOf(src.dtype);
+    void* p = backend.Alloc(bytes);
+    std::shared_ptr<void> owner(p, [&backend](void* q) { backend.Free(q); });
+    backend.Copy(queue, p, src.data, bytes);
+    std::vector<int64_t> shape(src.shape, src.shape + src.rank);
+    out.views[kv.first] = dense_attn::MakeTensor(p, src.dtype, queue.device, shape);
+    out.storage.push_back(std::move(owner));
+  }
+  backend.Synchronize(queue);
+  return out;
+}
+
+namespace {
+
+using dense_attn::DBuf;
+using dense_attn::Dev;
+using vt::DType;
+using vt::Tensor;
+
+// The M-RoPE cos/sin cache in vt::RopeFromCache's layout: [seq, head_dim] with the
+// first half cos and the second half sin. Upstream's cat(freqs, freqs) is what makes
+// that layout sufficient — the halves repeat, so one entry per frequency slot serves
+// both. The axis interleave ([TTT HHH WWW] chunks reshuffled to [THW THW ...]) is
+// transcribed from the host reference; getting it wrong rotates the wrong axis and
+// silently mis-positions every token.
+std::vector<float> BuildEncoderRopeCache(const int64_t* positions, int64_t seq,
+                                         int64_t head_dim, double rope_theta,
+                                         const std::vector<int64_t>& mrope_section) {
+  const int64_t half = head_dim / 2;
+  std::vector<float> cache(static_cast<size_t>(seq * head_dim));
+  for (int64_t s = 0; s < seq; ++s) {
+    for (int64_t i = 0; i < half; ++i) {
+      int64_t axis = 0;
+      if (i % 3 == 1 && i < 3 * mrope_section[1]) {
+        axis = 1;
+      } else if (i % 3 == 2 && i < 3 * mrope_section[2]) {
+        axis = 2;
+      }
+      const double inv_freq =
+          1.0 / std::pow(rope_theta, static_cast<double>(2 * i) / static_cast<double>(head_dim));
+      const double angle = static_cast<double>(positions[axis * seq + s]) * inv_freq;
+      cache[static_cast<size_t>(s * head_dim + i)] = static_cast<float>(std::cos(angle));
+      cache[static_cast<size_t>(s * head_dim + half + i)] = static_cast<float>(std::sin(angle));
+    }
+  }
+  return cache;
+}
+
+}  // namespace
+
+std::vector<float> MiniMaxH3EncoderTextForwardDevice(
+    vt::Queue& queue, const MiniMaxH3EncoderConfig& config,
+    const MiniMaxH3EncoderDeviceWeights& weights, const std::vector<float>& inputs_embeds,
+    const int64_t* positions, int64_t seq) {
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  Dev d{backend, queue};
+
+  const int64_t hidden = config.hidden_size;
+  const int64_t heads = config.num_attention_heads;
+  const int64_t kv_heads = config.num_key_value_heads;
+  const int64_t head_dim = config.head_dim;
+  const int64_t q_width = heads * head_dim;
+  const int64_t kv_width = kv_heads * head_dim;
+  VT_CHECK(static_cast<int64_t>(inputs_embeds.size()) == seq * hidden,
+           "minimax_h3 encoder device: inputs_embeds size does not match [seq, hidden]");
+  VT_CHECK(heads % kv_heads == 0,
+           "minimax_h3 encoder device: heads must be a multiple of kv_heads");
+
+  const std::vector<float> rope_host =
+      BuildEncoderRopeCache(positions, seq, head_dim, config.rope_theta, config.mrope_section);
+  DBuf rope(d, DType::kF32, {seq, head_dim}, rope_host.data());
+  std::vector<int32_t> arange(static_cast<size_t>(seq));
+  for (int64_t i = 0; i < seq; ++i) arange[static_cast<size_t>(i)] = static_cast<int32_t>(i);
+  DBuf rope_pos(d, DType::kI32, {seq}, arange.data());
+
+  // The whole prompt is ONE causal document.
+  const std::vector<int32_t> cu_seqlens = {0, static_cast<int32_t>(seq)};
+
+  DBuf h(d, DType::kF32, {seq, hidden}, inputs_embeds.data());
+  DBuf normed(d, DType::kF32, {seq, hidden});
+  DBuf attn_out(d, DType::kF32, {seq, hidden});
+
+  vt::RmsNormArgs norm_args;
+  norm_args.eps = static_cast<float>(config.rms_norm_eps);
+
+  const int64_t num_layers =
+      MiniMaxH3EncoderNumLayers(config.num_hidden_layers, config.selected_layer);
+  for (int64_t layer = 0; layer < num_layers; ++layer) {
+    const std::string p = "layers." + std::to_string(layer) + ".";
+    vt::RmsNorm(d.q, normed.t(), h.t(), weights.Get(p + "input_layernorm.weight"), norm_args);
+
+    DBuf q(d, DType::kF32, {seq, q_width});
+    DBuf k(d, DType::kF32, {seq, kv_width});
+    DBuf v(d, DType::kF32, {seq, kv_width});
+    if (weights.Has(p + "self_attn.qkv_proj.weight")) {
+      // Uniform-encoding checkpoint: one GEMM then split.
+      DBuf qkv(d, DType::kF32, {seq, q_width + 2 * kv_width});
+      vt::MatmulBT(d.q, qkv.t(), normed.t(), weights.Get(p + "self_attn.qkv_proj.weight"));
+      vt::QkvSplit(d.q, q.t(), k.t(), v.t(), qkv.t());
+    } else {
+      // MIXED-encoding checkpoint (the shipped Q4_K_M keeps v_proj at Q6_K), so the
+      // group was never fused: three GEMMs, each in its own encoding. Costs launches,
+      // not precision.
+      vt::MatmulBT(d.q, q.t(), normed.t(), weights.Get(p + "self_attn.q_proj.weight"));
+      vt::MatmulBT(d.q, k.t(), normed.t(), weights.Get(p + "self_attn.k_proj.weight"));
+      vt::MatmulBT(d.q, v.t(), normed.t(), weights.Get(p + "self_attn.v_proj.weight"));
+    }
+
+    // Per-head q/k RMSNorm over head_dim, THEN RoPE — that order is upstream's.
+    Tensor qn = dense_attn::Reshape(q.t(), {seq * heads, head_dim});
+    Tensor kn = dense_attn::Reshape(k.t(), {seq * kv_heads, head_dim});
+    vt::RmsNorm(d.q, qn, qn, weights.Get(p + "self_attn.q_norm.weight"), norm_args);
+    vt::RmsNorm(d.q, kn, kn, weights.Get(p + "self_attn.k_norm.weight"), norm_args);
+
+    Tensor q3 = dense_attn::Reshape(q.t(), {seq, heads, head_dim});
+    Tensor k3 = dense_attn::Reshape(k.t(), {seq, kv_heads, head_dim});
+    vt::RopeArgs rope_args;
+    rope_args.rotary_dim = static_cast<int>(head_dim);
+    rope_args.is_neox_style = true;
+    vt::RopeFromCache(d.q, q3, &k3, rope_pos.t(), rope.t(), rope_args);
+
+    // CAUSAL GQA attention (upstream passes is_causal=True); the shared op
+    // broadcasts kv heads across their query group.
+    Tensor tv = dense_attn::Reshape(v.t(), {seq, kv_heads, head_dim});
+    DBuf attn(d, DType::kF32, {seq, heads, head_dim});
+    vt::DFlashBlockAttentionArgs args;
+    args.scale = static_cast<float>(1.0 / std::sqrt(static_cast<double>(head_dim)));
+    args.causal = true;
+    args.sliding_window = 0;
+    args.cu_seqlens = cu_seqlens.data();
+    args.num_reqs = 1;
+    vt::DFlashBlockAttention(d.q, attn.t(), q3, k3, tv, args);
+
+    Tensor flat = dense_attn::Reshape(attn.t(), {seq, q_width});
+    vt::MatmulBT(d.q, attn_out.t(), flat, weights.Get(p + "self_attn.o_proj.weight"));
+    vt::Add(d.q, h.t(), h.t(), attn_out.t());
+
+    vt::RmsNorm(d.q, normed.t(), h.t(), weights.Get(p + "post_attention_layernorm.weight"),
+                norm_args);
+    const int64_t ffn = config.intermediate_size;
+    DBuf act(d, DType::kF32, {seq, ffn});
+    if (weights.Has(p + "mlp.gate_up_proj.weight")) {
+      DBuf gate_up(d, DType::kF32, {seq, 2 * ffn});
+      vt::MatmulBT(d.q, gate_up.t(), normed.t(), weights.Get(p + "mlp.gate_up_proj.weight"));
+      vt::SiluAndMul(d.q, act.t(), gate_up.t());
+    } else {
+      DBuf gate(d, DType::kF32, {seq, ffn});
+      DBuf up(d, DType::kF32, {seq, ffn});
+      vt::MatmulBT(d.q, gate.t(), normed.t(), weights.Get(p + "mlp.gate_proj.weight"));
+      vt::MatmulBT(d.q, up.t(), normed.t(), weights.Get(p + "mlp.up_proj.weight"));
+      // SiluAndMul wants [gate | up] contiguous, so stage the pair once.
+      DBuf gate_up(d, DType::kF32, {seq, 2 * ffn});
+      for (int64_t r = 0; r < seq; ++r) {
+        backend.Copy(d.q, static_cast<float*>(gate_up.ptr()) + r * 2 * ffn,
+                     static_cast<float*>(gate.ptr()) + r * ffn,
+                     static_cast<size_t>(ffn) * sizeof(float));
+        backend.Copy(d.q, static_cast<float*>(gate_up.ptr()) + r * 2 * ffn + ffn,
+                     static_cast<float*>(up.ptr()) + r * ffn,
+                     static_cast<size_t>(ffn) * sizeof(float));
+      }
+      vt::SiluAndMul(d.q, act.t(), gate_up.t());
+    }
+    vt::MatmulBT(d.q, attn_out.t(), act.t(), weights.Get(p + "mlp.down_proj.weight"));
+    vt::Add(d.q, h.t(), h.t(), attn_out.t());
+  }
+
+  // NO final RMSNorm: H3 reads the UNNORMALIZED truncated output.
+  std::vector<float> out(static_cast<size_t>(seq * hidden));
+  h.Download(d, out.data());
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_encoder_gguf.cpp b/src/vllm/model_executor/models/minimax_h3_encoder_gguf.cpp
new file mode 100644
index 000000000..befe773f0
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_encoder_gguf.cpp
@@ -0,0 +1,246 @@
+// H3-Encoder KEEP-QUANT loader — the Qwen3-VL tower from a ComfyUI-format GGUF.
+//
+// WHY THIS EXISTS: the encoder is 32B. The safetensors loader materializes f32,
+// which is ~128 GB and does not fit the box we test on. Held in its ggml blocks the
+// tower is ~14.6 GB, and the block-quant GEMM has no arch gate, so it runs natively
+// on hardware that cannot do FP4.
+//
+// THE FUSIONS ARE DONE ON QUANTIZED BYTES. The forward consumes `qkv_proj` and
+// `gate_up_proj` fused (what vLLM consumes); the checkpoint ships q/k/v and gate/up
+// separate. Concatenating the raw ggml bytes is sound because ggml rows are
+// INDEPENDENT — a row is a whole number of blocks, and every K here is a multiple of
+// the 256-element Q4_K block — so the result is a valid block-quant tensor whose
+// rows are [q_all | k_all | v_all]. No dequantize/requantize round trip, and no
+// precision lost to one.
+//
+// GGUF stores `ne` REVERSED vs torch, so a logical [out, in] weight appears as
+// {in, out}; the reader already reverses it, which is why `shape[0]` below is `out`.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <cstdint>
+#include <cstring>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "vllm/model_executor/model_loader/gguf_dequant.h"
+#include "vllm/model_executor/model_loader/gguf_keep_quant.h"
+#include "vllm/model_executor/model_loader/gguf_reader.h"
+#include "vt/dtype.h"
+
+namespace vllm {
+
+const vt::Tensor& MiniMaxH3EncoderQuantWeights::Get(const std::string& name) const {
+  const auto it = views.find(name);
+  VT_CHECK(it != views.end(), "minimax_h3 encoder gguf: missing tensor (by name)");
+  return it->second;
+}
+
+namespace {
+
+// A rank-2 ggml tensor's row stride in BYTES.
+size_t RowBytes(vt::DType dtype, int64_t k) { return vt::RowSizeBytes(dtype, k); }
+
+}  // namespace
+
+MiniMaxH3EncoderQuantWeights LoadMiniMaxH3EncoderFromGguf(const GgufFile& file,
+                                                          int64_t max_layers) {
+  MiniMaxH3EncoderQuantWeights out;
+
+  // Index by name. GGUF drops the safetensors `language_model.` level: the text
+  // tower is `model.layers.N.*` and the vision tower is `visual.*` (no `model.`).
+  // GgufFile has no membership query, so build one from the tensor list.
+  std::set<std::string> present;
+  for (const GgufTensorInfo& info : file.Tensors()) present.insert(info.name);
+  auto has = [&](const std::string& n) { return present.count(n) != 0; };
+
+  auto keep = [&](const std::string& src, const std::string& dst) {
+    const GgufTensorInfo& info = file.Get(src);
+    VT_CHECK(info.shape.size() == 2, "minimax_h3 encoder gguf: expected a rank-2 projection");
+    vt::DType block = vt::DType::kF32;
+    VT_CHECK(KeepQuantDType(info.ggml_type, &block),
+             "minimax_h3 encoder gguf: unsupported quant encoding for a projection");
+    const int64_t rows = info.shape[0], k = info.shape[1];
+    VT_CHECK(k % vt::BlockElems(block) == 0,
+             "minimax_h3 encoder gguf: K is not a whole number of blocks");
+    const size_t bytes = static_cast<size_t>(rows) * RowBytes(block, k);
+    const uint8_t* src_bytes = static_cast<const uint8_t*>(info.data);
+    out.quant_storage[dst].assign(src_bytes, src_bytes + bytes);
+    out.ggml_type[dst] = info.ggml_type;
+    out.views[dst] = vt::Tensor::Contiguous(out.quant_storage[dst].data(), block, vt::Device{},
+                                            {rows, k});
+  };
+
+  auto plain = [&](const std::string& src, const std::string& dst) {
+    const GgufTensorInfo& info = file.Get(src);
+    int64_t numel = 1;
+    for (int64_t d : info.shape) numel *= d;
+    out.storage[dst] = DequantGgufRowToF32(info.ggml_type, info.data, numel);
+    std::vector<int64_t> shape(info.shape.begin(), info.shape.end());
+    vt::Tensor t;
+    t.data = out.storage[dst].data();
+    t.dtype = vt::DType::kF32;
+    t.device = vt::Device{};
+    t.rank = static_cast<int>(shape.size());
+    int64_t stride = 1;
+    for (int i = t.rank - 1; i >= 0; --i) {
+      t.shape[i] = shape[static_cast<size_t>(i)];
+      t.stride[i] = stride;
+      stride *= shape[static_cast<size_t>(i)];
+    }
+    out.views[dst] = t;
+  };
+
+  // Fuse a group of same-K quantized projections by concatenating whole ROWS of
+  // ggml bytes. Sound because rows are independent block sequences.
+  //
+  // Returns FALSE when the group mixes ggml encodings, in which case nothing is
+  // written and the caller keeps the members separate. That is not hypothetical:
+  // the shipped Q4_K_M encoder stores v_proj as Q6_K while q_proj/k_proj are Q4_K
+  // (the usual K_M recipe of keeping V at higher precision), so the attention group
+  // CANNOT be byte-concatenated. Dequantizing to force a fusion would throw away
+  // exactly the precision the recipe was chosen to keep.
+  auto fuse = [&](const std::vector<std::string>& srcs, const std::string& dst) -> bool {
+    vt::DType block = vt::DType::kF32;
+    int64_t total_rows = 0, k = -1;
+    for (const std::string& s : srcs) {
+      const GgufTensorInfo& info = file.Get(s);
+      VT_CHECK(info.shape.size() == 2, "minimax_h3 encoder gguf: fuse expects rank-2");
+      vt::DType b = vt::DType::kF32;
+      VT_CHECK(KeepQuantDType(info.ggml_type, &b),
+               "minimax_h3 encoder gguf: unsupported quant encoding in a fused group");
+      if (k < 0) {
+        k = info.shape[1];
+        block = b;
+      }
+      VT_CHECK(info.shape[1] == k, "minimax_h3 encoder gguf: fused group disagrees on K");
+      if (b != block) return false;  // mixed encodings: keep the members separate
+      total_rows += info.shape[0];
+    }
+    VT_CHECK(k % vt::BlockElems(block) == 0,
+             "minimax_h3 encoder gguf: fused K is not a whole number of blocks");
+    const size_t row_bytes = RowBytes(block, k);
+    std::vector<uint8_t>& dstbuf = out.quant_storage[dst];
+    dstbuf.clear();
+    dstbuf.reserve(static_cast<size_t>(total_rows) * row_bytes);
+    for (const std::string& s : srcs) {
+      const GgufTensorInfo& info = file.Get(s);
+      const uint8_t* p = static_cast<const uint8_t*>(info.data);
+      dstbuf.insert(dstbuf.end(), p, p + static_cast<size_t>(info.shape[0]) * row_bytes);
+    }
+    out.ggml_type[dst] = file.Get(srcs.front()).ggml_type;
+    out.views[dst] =
+        vt::Tensor::Contiguous(dstbuf.data(), block, vt::Device{}, {total_rows, k});
+    return true;
+  };
+
+  // Fuse if the group is uniform; otherwise bind each member under its own name.
+  // The forward takes whichever is present, so a mixed-precision checkpoint costs
+  // extra GEMM launches rather than precision.
+  auto fuse_or_keep = [&](const std::vector<std::string>& srcs,
+                          const std::vector<std::string>& dsts, const std::string& fused) {
+    if (fuse(srcs, fused)) return;
+    for (size_t i = 0; i < srcs.size(); ++i) keep(srcs[i], dsts[i]);
+  };
+
+  for (int64_t layer = 0;; ++layer) {
+    const std::string src = "model.layers." + std::to_string(layer) + ".";
+    if (!has(src + "input_layernorm.weight")) break;
+    if (max_layers > 0 && layer >= max_layers) break;
+    const std::string dst = "layers." + std::to_string(layer) + ".";
+
+    plain(src + "input_layernorm.weight", dst + "input_layernorm.weight");
+    plain(src + "post_attention_layernorm.weight", dst + "post_attention_layernorm.weight");
+    plain(src + "self_attn.q_norm.weight", dst + "self_attn.q_norm.weight");
+    plain(src + "self_attn.k_norm.weight", dst + "self_attn.k_norm.weight");
+    keep(src + "self_attn.o_proj.weight", dst + "self_attn.o_proj.weight");
+    keep(src + "mlp.down_proj.weight", dst + "mlp.down_proj.weight");
+    fuse_or_keep({src + "self_attn.q_proj.weight", src + "self_attn.k_proj.weight",
+                  src + "self_attn.v_proj.weight"},
+                 {dst + "self_attn.q_proj.weight", dst + "self_attn.k_proj.weight",
+                  dst + "self_attn.v_proj.weight"},
+                 dst + "self_attn.qkv_proj.weight");
+    fuse_or_keep({src + "mlp.gate_proj.weight", src + "mlp.up_proj.weight"},
+                 {dst + "mlp.gate_proj.weight", dst + "mlp.up_proj.weight"},
+                 dst + "mlp.gate_up_proj.weight");
+  }
+  VT_CHECK(out.views.count("layers.0.self_attn.qkv_proj.weight") != 0 ||
+               out.views.count("layers.0.self_attn.q_proj.weight") != 0,
+           "minimax_h3 encoder gguf: no text-tower layers were loaded");
+
+  // The embedding table stays QUANTIZED too — at [151936, 5120] it is the single
+  // largest tensor, and a caller only ever gathers a handful of its rows.
+  if (has("model.embed_tokens.weight")) keep("model.embed_tokens.weight", "embed_tokens.weight");
+
+  // `model.norm.weight` is deliberately NOT bound: H3 reads the UNNORMALIZED
+  // truncated output, so carrying it would imply it is applied.
+
+  // Recover the geometry from the fused shapes. qkv rows are q + 2*kv, and the
+  // per-head dim comes from q_norm, which is [head_dim].
+  const vt::Tensor& qn = out.Get("layers.0.self_attn.q_norm.weight");
+  out.config.head_dim = qn.shape[0];
+  const int64_t o_rows = out.Get("layers.0.self_attn.o_proj.weight").shape[1];
+  out.config.num_attention_heads = o_rows / out.config.head_dim;
+  if (out.views.count("layers.0.self_attn.qkv_proj.weight") != 0) {
+    const vt::Tensor& qkv = out.Get("layers.0.self_attn.qkv_proj.weight");
+    out.config.hidden_size = qkv.shape[1];
+    out.config.num_key_value_heads = (qkv.shape[0] - o_rows) / (2 * out.config.head_dim);
+  } else {
+    const vt::Tensor& q = out.Get("layers.0.self_attn.q_proj.weight");
+    out.config.hidden_size = q.shape[1];
+    out.config.num_key_value_heads =
+        out.Get("layers.0.self_attn.k_proj.weight").shape[0] / out.config.head_dim;
+  }
+  out.config.intermediate_size =
+      out.views.count("layers.0.mlp.gate_up_proj.weight") != 0
+          ? out.Get("layers.0.mlp.gate_up_proj.weight").shape[0] / 2
+          : out.Get("layers.0.mlp.gate_proj.weight").shape[0];
+  int64_t layers = 0;
+  while (out.views.count("layers." + std::to_string(layers) + ".input_layernorm.weight") != 0) {
+    ++layers;
+  }
+  out.config.num_hidden_layers = layers;
+  return out;
+}
+
+
+std::vector<float> MiniMaxH3EncoderEmbedTokens(const MiniMaxH3EncoderQuantWeights& weights,
+                                               const std::vector<int32_t>& ids) {
+  const vt::Tensor& table = weights.Get("embed_tokens.weight");
+  const int64_t vocab = table.shape[0], hidden = table.shape[1];
+  std::vector<float> out(static_cast<size_t>(ids.size()) * static_cast<size_t>(hidden));
+
+  if (!vt::IsBlockQuant(table.dtype)) {
+    const float* src = table.Ptr<float>();
+    for (size_t i = 0; i < ids.size(); ++i) {
+      const int64_t id = ids[i];
+      VT_CHECK(id >= 0 && id < vocab, "minimax_h3 encoder: token id out of vocabulary range");
+      std::memcpy(out.data() + i * hidden, src + id * hidden,
+                  static_cast<size_t>(hidden) * sizeof(float));
+    }
+    return out;
+  }
+
+  // Block-quant: decode ONE ROW at a time from its own bytes. The table is ~1.5 GB
+  // and a prompt touches a few dozen rows, so decoding the whole thing to gather a
+  // handful would be the expensive way to get the same answer.
+  const auto type_it = weights.ggml_type.find("embed_tokens.weight");
+  VT_CHECK(type_it != weights.ggml_type.end(),
+           "minimax_h3 encoder: embed_tokens has no recorded ggml type");
+  const size_t row_bytes = vt::RowSizeBytes(table.dtype, hidden);
+  const uint8_t* base = static_cast<const uint8_t*>(table.data);
+  for (size_t i = 0; i < ids.size(); ++i) {
+    const int64_t id = ids[i];
+    VT_CHECK(id >= 0 && id < vocab, "minimax_h3 encoder: token id out of vocabulary range");
+    const std::vector<float> row =
+        DequantGgufRowToF32(type_it->second, base + static_cast<size_t>(id) * row_bytes, hidden);
+    VT_CHECK(static_cast<int64_t>(row.size()) == hidden,
+             "minimax_h3 encoder: embedding row dequantized to the wrong width");
+    std::memcpy(out.data() + i * hidden, row.data(),
+                static_cast<size_t>(hidden) * sizeof(float));
+  }
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_gguf.cpp b/src/vllm/model_executor/models/minimax_h3_gguf.cpp
new file mode 100644
index 000000000..553618627
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_gguf.cpp
@@ -0,0 +1,331 @@
+// MiniMax-H3 GGUF arm — the quantized checkpoints that actually FIT one GB10.
+//
+// ─── WHY THIS EXISTS ─────────────────────────────────────────────────────────
+// The bf16 MiniMax-H3 release is ~354 GB and needs 4x B300, which is why the
+// safetensors arm is hardware-blocked here. The community ComfyUI-format GGUFs
+// change that verdict: the DiT at Q3_K_M is ~15.6 GB and the Qwen3-VL encoder at
+// Q4_K_M is ~14.6 GB, so a whole working set (plus the two fp16/fp32 VAEs) lands
+// around ~41 GB — comfortably inside the 119 GiB unified pool. See
+// .agents/specs/minimax-h3.md section 0.
+//
+// ─── THE NAME MAP IS THE IDENTITY (verified against a real checkpoint) ───────
+// ComfyUI's H3 GGUF keeps the checkpoint's own parameter names, so every one of
+// the 535 tensors in `MiniMax-H3-FL2VA-Q3_K_M.gguf` matches the contract
+// `EnumerateMiniMaxH3DitTensors` derives from upstream source — no rename table.
+// That equivalence is GATED on the real manifest
+// (tests/vllm/models/minimax_h3_gguf_manifest.inc, produced by
+// scripts/gen-minimax-h3-gguf-manifest.py from the file's header alone).
+//
+// Two shape rules, and they are the whole subtlety:
+//   1. GGUF `ne` is REVERSED relative to torch: a `[out, in]` weight is stored
+//      `[in, out]` (qkv_proj is ne=[5376, 21504] for logical [21504, 5376]).
+//   2. When ComfyUI had to RESHAPE a tensor so its fastest axis is a whole
+//      number of quant blocks, it records the true torch shape in the metadata
+//      key `comfy.gguf.orig_shape.<name>`, which is already in `[out, in]`
+//      order and therefore must NOT be reversed. The 50 AdaLN projections are
+//      exactly this case: logical [96768, 2688], but 2688 is not a multiple of
+//      the 256-element Q3_K block, so they ship as ne=[256, 1016064].
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "vllm/model_executor/model_loader/gguf_dequant.h"
+#include "vllm/model_executor/model_loader/gguf_keep_quant.h"
+#include "vllm/model_executor/model_loader/gguf_reader.h"
+#include "vt/dtype.h"
+
+namespace vllm {
+
+namespace {
+
+// Parse the trailing integer of a `prefix<N>.` path segment; -1 when absent.
+int64_t IndexAfter(const std::string& name, const std::string& prefix) {
+  if (name.compare(0, prefix.size(), prefix) != 0) return -1;
+  size_t pos = prefix.size();
+  if (pos >= name.size() || name[pos] < '0' || name[pos] > '9') return -1;
+  int64_t value = 0;
+  while (pos < name.size() && name[pos] >= '0' && name[pos] <= '9') {
+    value = value * 10 + (name[pos] - '0');
+    ++pos;
+  }
+  return value;
+}
+
+}  // namespace
+
+// The logical (torch) shape of a tensor from its RAW GGUF `ne` dims: reverse the
+// ne order, unless ComfyUI recorded `orig_shape`, which is already torch order.
+// NOTE the asymmetry with `EnumerateMiniMaxH3GgufTensors` below: `GgufTensorInfo::shape`
+// has ALREADY been reversed by the reader, so that path must not reverse again.
+// This overload is the one that speaks the on-disk order, and it is what the
+// real-manifest gate exercises.
+std::vector<int64_t> MiniMaxH3GgufLogicalShape(const std::vector<int64_t>& gguf_dims,
+                                               const std::vector<int64_t>& orig_shape) {
+  if (!orig_shape.empty()) return orig_shape;
+  std::vector<int64_t> shape(gguf_dims.rbegin(), gguf_dims.rend());
+  // GGUF pads trailing dims with 1; drop the leading 1s the reversal produces so
+  // a 1-D tensor stays 1-D.
+  while (shape.size() > 1 && shape.front() == 1) shape.erase(shape.begin());
+  return shape;
+}
+
+// Derive the H3 geometry from the tensor manifest alone. A ComfyUI GGUF carries
+// no transformer config.json, so the shapes ARE the config: this is what lets a
+// GGUF checkpoint load without the original repo.
+MiniMaxH3DitParams ParseMiniMaxH3DitParamsFromGgufManifest(
+    const std::vector<MiniMaxH3TensorSpec>& manifest) {
+  MiniMaxH3DitParams p;
+  int64_t max_block = -1, max_refiner = -1;
+  bool saw_hidden = false, saw_head_dim = false;
+
+  for (const MiniMaxH3TensorSpec& spec : manifest) {
+    const std::string& name = spec.name;
+    max_block = std::max(max_block, IndexAfter(name, "blocks."));
+    max_refiner = std::max(max_refiner, IndexAfter(name, "token_refiner.blocks."));
+
+    if (name == "final_layer.norm.weight" && spec.shape.size() == 1) {
+      p.hidden_size = spec.shape[0];
+      saw_hidden = true;
+    } else if (name == "blocks.0.attn.q_norm.weight" && spec.shape.size() == 1) {
+      p.attention_head_dim = spec.shape[0];
+      saw_head_dim = true;
+    } else if (name == "condition_proj.weight" && spec.shape.size() == 2) {
+      p.text_dim = spec.shape[1];
+    } else if (name == "video_patch_proj.weight" && spec.shape.size() == 2) {
+      // [hidden, latents_dim * patch volume]; the patch is fixed at (1,2,2).
+      p.latents_dim = spec.shape[1] / (p.patch_size_t * p.patch_size_h * p.patch_size_w);
+    } else if (name == "audio_patch_proj.weight" && spec.shape.size() == 2) {
+      p.audio_latents_dim = spec.shape[1];
+    } else if (name == "time_embedder.proj_in.weight" && spec.shape.size() == 2) {
+      p.time_embed_hidden_size = spec.shape[0];
+      p.timestep_input_dim = spec.shape[1];
+    } else if (name == "time_embedder.proj_out.weight" && spec.shape.size() == 2) {
+      p.time_embed_dim = spec.shape[0];
+    } else if (name == "blocks.0.mlp.fc2.weight" && spec.shape.size() == 2) {
+      p.ffn_hidden_size = spec.shape[1];
+    } else if (name == "blocks.0.adaln_proj.linear.weight" && spec.shape.size() == 2) {
+      p.adaln_out_features = spec.shape[0];
+    } else if (name == "final_layer.adaln_proj.linear.weight" && spec.shape.size() == 2) {
+      p.final_adaln_out_features = spec.shape[0];
+    } else if (name == "rope.inv_freq" && spec.shape.size() == 1) {
+      p.rope_inv_freq_len = spec.shape[0];
+    }
+  }
+
+  VT_CHECK(saw_hidden, "minimax_h3 gguf: final_layer.norm.weight is required to size the model");
+  VT_CHECK(saw_head_dim, "minimax_h3 gguf: blocks.0.attn.q_norm.weight is required");
+  VT_CHECK(max_block >= 0, "minimax_h3 gguf: no blocks.<N> tensors found");
+  p.num_layers = max_block + 1;
+  p.token_refiner_num_layers = max_refiner + 1;
+
+  // MHA: qkv is 3 * heads * head_dim wide, so the head count follows.
+  for (const MiniMaxH3TensorSpec& spec : manifest) {
+    if (spec.name == "blocks.0.attn.qkv_proj.weight" && spec.shape.size() == 2) {
+      VT_CHECK(spec.shape[0] % (3 * p.attention_head_dim) == 0,
+               "minimax_h3 gguf: qkv width is not 3 * heads * head_dim");
+      p.num_attention_heads = spec.shape[0] / (3 * p.attention_head_dim);
+    }
+  }
+  VT_CHECK(p.num_attention_heads > 0, "minimax_h3 gguf: could not derive the head count");
+  VT_CHECK(p.adaln_out_features == 6 * p.hidden_size * kMiniMaxH3AdalnModalityNum,
+           "minimax_h3 gguf: adaln width does not match 6 * hidden * 3");
+  VT_CHECK(p.rope_rot_dim() <= p.attention_head_dim,
+           "minimax_h3 gguf: 6 * rope_inv_freq_len exceeds attention_head_dim");
+  return p;
+}
+
+// Read the manifest (names + logical shapes + ggml types) out of a GGUF.
+std::vector<MiniMaxH3TensorSpec> EnumerateMiniMaxH3GgufTensors(const GgufFile& file) {
+  std::vector<MiniMaxH3TensorSpec> out;
+  out.reserve(file.Tensors().size());
+  for (const GgufTensorInfo& info : file.Tensors()) {
+    MiniMaxH3TensorSpec spec;
+    spec.name = info.name;
+    // `info.shape` is already torch row-major (the reader reverses ne), so it is
+    // used as-is; `orig_shape` overrides it when ComfyUI reshaped the tensor for
+    // quant-block alignment.
+    spec.shape = info.shape;
+    if (const GgufValue* kv = file.FindKv("comfy.gguf.orig_shape." + info.name)) {
+      if (const GgufArray* array = std::get_if<GgufArray>(&kv->v)) {
+        std::vector<int64_t> orig;
+        orig.reserve(array->elems.size());
+        for (const GgufValue& elem : array->elems) {
+          switch (elem.TypeId()) {
+            case kGgufU32: orig.push_back(std::get<uint32_t>(elem.v)); break;
+            case kGgufI32: orig.push_back(std::get<int32_t>(elem.v)); break;
+            case kGgufU64: orig.push_back(static_cast<int64_t>(std::get<uint64_t>(elem.v))); break;
+            case kGgufI64: orig.push_back(std::get<int64_t>(elem.v)); break;
+            default:
+              VT_CHECK(false, "minimax_h3 gguf: comfy.gguf.orig_shape must hold integers");
+          }
+        }
+        if (!orig.empty()) spec.shape = orig;
+      }
+    }
+    // The fp32 islands stay unquantized in the GGUF too (the ComfyUI quantizer
+    // leaves norms, biases, and the small projections alone).
+    spec.fp32 = info.ggml_type == 0;
+    out.push_back(std::move(spec));
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Loading: manifest -> dequantized DiT weights
+// ---------------------------------------------------------------------------
+
+// Materialize every DiT tensor from a ComfyUI-format GGUF into owned f32 buffers
+// and hand back the non-owning `MiniMaxH3DitWeights` views the forward consumes.
+//
+// Each tensor is dequantized to f32 by the shared `DequantGgufRowToF32`, so the
+// K-quant families the H3 GGUFs actually use (Q2_K / Q3_K / Q4_K, plus the F32 and
+// F16 islands) are handled by the same code path every other GGUF model uses.
+// Shapes are resolved by the rules gated in the manifest test: reversed `ne`,
+// unless `comfy.gguf.orig_shape.<name>` says otherwise.
+// Bind the forward's non-owning views onto the owned buffers. Shared by the GGUF
+// and NVFP4 arms — both land on the SAME weight contract, so both bind identically.
+void BindMiniMaxH3DitViews(MiniMaxH3GgufDit* out) {
+  // Bind the views. Any missing name throws by NAME rather than yielding a null
+  // tensor the forward would read as zeros.
+  const MiniMaxH3DitParams& p = out->params;
+  auto view = [out](const std::string& name) -> vt::Tensor {
+    const auto quant = out->quant_storage.find(name);
+    const auto bf16 = out->bf16_storage.find(name);
+    const auto it = out->storage.find(name);
+    VT_CHECK(quant != out->quant_storage.end() || bf16 != out->bf16_storage.end() ||
+                 it != out->storage.end(),
+             "minimax_h3 gguf: checkpoint is missing a required tensor");
+    const std::vector<int64_t>& shape = out->shapes.at(name);
+    vt::Tensor t;
+    // A keep-quant tensor keeps its ggml bytes and its BLOCK dtype; the logical
+    // [N,K] shape is unchanged, which is what lets the forward stay identical.
+    if (quant != out->quant_storage.end()) {
+      t.data = quant->second.data();
+      t.dtype = out->quant_dtype.at(name);
+    } else if (bf16 != out->bf16_storage.end()) {
+      t.data = bf16->second.data();
+      t.dtype = vt::DType::kBF16;
+    } else {
+      t.data = it->second.data();
+      t.dtype = vt::DType::kF32;
+    }
+    t.device = vt::Device{};
+    t.rank = static_cast<int>(shape.size());
+    int64_t stride = 1;
+    for (int i = t.rank - 1; i >= 0; --i) {
+      t.shape[i] = shape[static_cast<size_t>(i)];
+      t.stride[i] = stride;
+      stride *= shape[static_cast<size_t>(i)];
+    }
+    return t;
+  };
+
+  out->weights.video_patch_proj_w = view("video_patch_proj.weight");
+  out->weights.video_patch_proj_b = view("video_patch_proj.bias");
+  out->weights.audio_patch_proj_w = view("audio_patch_proj.weight");
+  out->weights.audio_patch_proj_b = view("audio_patch_proj.bias");
+  out->weights.condition_proj_w = view("condition_proj.weight");
+  out->weights.condition_proj_b = view("condition_proj.bias");
+  out->weights.time_proj_in_w = view("time_embedder.proj_in.weight");
+  out->weights.time_proj_in_b = view("time_embedder.proj_in.bias");
+  out->weights.time_proj_out_w = view("time_embedder.proj_out.weight");
+  out->weights.time_proj_out_b = view("time_embedder.proj_out.bias");
+  out->weights.rope_inv_freq = view("rope.inv_freq");
+
+  auto bind_block = [&](const std::string& prefix, bool with_adaln) {
+    MiniMaxH3DitBlockWeights block;
+    block.norm1 = view(prefix + ".norm1.weight");
+    block.norm2 = view(prefix + ".norm2.weight");
+    block.qkv_proj = view(prefix + ".attn.qkv_proj.weight");
+    block.q_norm = view(prefix + ".attn.q_norm.weight");
+    block.k_norm = view(prefix + ".attn.k_norm.weight");
+    block.out_proj = view(prefix + ".attn.out_proj.weight");
+    block.fc1 = view(prefix + ".mlp.fc1.weight");
+    block.fc2 = view(prefix + ".mlp.fc2.weight");
+    if (with_adaln) {
+      block.adaln_w = view(prefix + ".adaln_proj.linear.weight");
+      block.adaln_b = view(prefix + ".adaln_proj.linear.bias");
+      out->weights.blocks.push_back(block);
+    } else {
+      out->weights.refiner.push_back(block);
+    }
+  };
+  for (int64_t i = 0; i < p.token_refiner_num_layers; ++i) {
+    bind_block("token_refiner.blocks." + std::to_string(i), /*with_adaln=*/false);
+  }
+  out->weights.refiner_final_norm = view("token_refiner.final_norm.weight");
+  for (int64_t i = 0; i < p.num_layers; ++i) {
+    bind_block("blocks." + std::to_string(i), /*with_adaln=*/true);
+  }
+  out->weights.final_norm = view("final_layer.norm.weight");
+  out->weights.final_adaln_w = view("final_layer.adaln_proj.linear.weight");
+  out->weights.final_adaln_b = view("final_layer.adaln_proj.linear.bias");
+  out->weights.video_out_w = view("final_layer.video_out.weight");
+  out->weights.video_out_b = view("final_layer.video_out.bias");
+  out->weights.audio_out_w = view("final_layer.audio_out.weight");
+  out->weights.audio_out_b = view("final_layer.audio_out.bias");
+}
+
+MiniMaxH3GgufDit LoadMiniMaxH3DitFromGguf(const GgufFile& file, bool keep_quant) {
+  MiniMaxH3GgufDit out;
+  const std::vector<MiniMaxH3TensorSpec> manifest = EnumerateMiniMaxH3GgufTensors(file);
+  out.params = ParseMiniMaxH3DitParamsFromGgufManifest(manifest);
+
+  for (const MiniMaxH3TensorSpec& spec : manifest) {
+    const GgufTensorInfo& info = file.Get(spec.name);
+    int64_t numel = 1;
+    for (int64_t d : spec.shape) numel *= d;
+    VT_CHECK(numel > 0, "minimax_h3 gguf: tensor has an empty logical shape");
+    out.shapes[spec.name] = spec.shape;
+
+    // KEEP-QUANT eligibility, the SHARED rule: a supported block encoding, rank 2
+    // (a projection, not a norm or bias), and K a whole number of blocks. Anything
+    // else dequantizes, so the decision is total and the forward is unaffected.
+    vt::DType block = vt::DType::kF32;
+    const bool eligible = keep_quant && spec.shape.size() == 2 &&
+                          KeepQuantDType(info.ggml_type, &block) &&
+                          spec.shape[1] % vt::BlockElems(block) == 0;
+    if (eligible) {
+      const size_t bytes =
+          static_cast<size_t>(spec.shape[0]) * vt::RowSizeBytes(block, spec.shape[1]);
+      const uint8_t* src = static_cast<const uint8_t*>(info.data);
+      out.quant_storage[spec.name].assign(src, src + bytes);
+      out.quant_dtype[spec.name] = block;
+      out.quant_ggml_type[spec.name] = info.ggml_type;
+      continue;
+    }
+
+    // Dequantize once per tensor, keyed by checkpoint name.
+    out.storage[spec.name] = DequantGgufRowToF32(info.ggml_type, info.data, numel);
+    VT_CHECK(static_cast<int64_t>(out.storage[spec.name].size()) == numel,
+             "minimax_h3 gguf: dequant produced the wrong element count");
+  }
+
+  BindMiniMaxH3DitViews(&out);
+  return out;
+}
+
+
+MiniMaxH3GgufDit LoadMiniMaxH3DitFromGgufBf16(const GgufFile& file) {
+  MiniMaxH3GgufDit out;
+  const std::vector<MiniMaxH3TensorSpec> manifest = EnumerateMiniMaxH3GgufTensors(file);
+  out.params = ParseMiniMaxH3DitParamsFromGgufManifest(manifest);
+  for (const MiniMaxH3TensorSpec& spec : manifest) {
+    const GgufTensorInfo& info = file.Get(spec.name);
+    int64_t numel = 1;
+    for (int64_t d : spec.shape) numel *= d;
+    VT_CHECK(numel > 0, "minimax_h3 gguf bf16: tensor has an empty logical shape");
+    // Straight to bf16: going via f32 would double the peak for no benefit, and the
+    // f32 intermediate is exactly what does not fit.
+    out.bf16_storage[spec.name] = DequantGgufRowToBf16(info.ggml_type, info.data, numel);
+    VT_CHECK(static_cast<int64_t>(out.bf16_storage[spec.name].size()) == numel,
+             "minimax_h3 gguf bf16: dequant produced the wrong element count");
+    out.shapes[spec.name] = spec.shape;
+  }
+  BindMiniMaxH3DitViews(&out);
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_mux.cpp b/src/vllm/model_executor/models/minimax_h3_mux.cpp
new file mode 100644
index 000000000..96b641583
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_mux.cpp
@@ -0,0 +1,92 @@
+// MiniMax-H3 video output: frame serialization and the MP4 mux command.
+//
+// ─── WHERE THE PROCESS BOUNDARY SITS, AND WHY ────────────────────────────────
+// `/v1/videos` returns MP4 (H.264 + audio). Upstream vLLM-Omni obtains that by
+// shelling out to `ffmpeg`. Mirroring upstream is this project's policy, but
+// vLLM-Omni is a Python SERVING layer while vllm.cpp is a LIBRARY, and `src/vllm/`
+// has no subprocess precedent anywhere — a library that forks a process is an
+// architectural commitment (PATH dependence, sandboxing, process lifetime) that
+// does not belong here.
+//
+// So the split is: this file produces the ARTIFACTS (RGB frames as PPM, audio as
+// WAV via MiniMaxH3WriteWav) and BUILDS the argv, both as pure data transforms
+// with no process spawning; the example/server layer performs the actual
+// invocation. That mirrors upstream's behaviour while keeping the library
+// dependency-free, and it keeps the interesting logic unit-testable.
+//
+// RATIFIED by the developer 2026-08-03: "re: ffmpeg invocation, correct -
+// let's keep in the examples only". So this boundary is a project decision,
+// not an implementation convenience: do NOT add process spawning to src/vllm/.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+
+// One frame of a [C, T, H, W] float tensor as binary PPM (P6, 8-bit RGB).
+// ffmpeg reads PPM natively, so this is the handoff format for the mux step.
+// `frames` is the pipeline's decoded output; values are clamped from [-1, 1].
+std::string MiniMaxH3WritePpmFrame(const std::vector<float>& frames,
+                                   const MiniMaxH3VideoFrameShape& shape, int64_t frame_index) {
+  VT_CHECK(shape.channels == 3, "minimax_h3 ppm: expected 3 (RGB) channels");
+  VT_CHECK(frame_index >= 0 && frame_index < shape.t, "minimax_h3 ppm: frame index out of range");
+  const int64_t plane = shape.h * shape.w;
+  VT_CHECK(static_cast<int64_t>(frames.size()) == shape.channels * shape.t * plane,
+           "minimax_h3 ppm: frame buffer does not match the shape");
+
+  std::string out = "P6\n" + std::to_string(shape.w) + " " + std::to_string(shape.h) + "\n255\n";
+  out.reserve(out.size() + static_cast<size_t>(plane * 3));
+  for (int64_t y = 0; y < shape.h; ++y) {
+    for (int64_t x = 0; x < shape.w; ++x) {
+      for (int64_t c = 0; c < 3; ++c) {
+        const size_t idx =
+            static_cast<size_t>((c * shape.t + frame_index) * plane + y * shape.w + x);
+        // The VAE emits roughly [-1, 1]; map to [0, 255] and clamp.
+        const double v = std::min(1.0, std::max(-1.0, static_cast<double>(frames[idx])));
+        const int32_t byte = static_cast<int32_t>(std::lround((v + 1.0) * 0.5 * 255.0));
+        out.push_back(static_cast<char>(static_cast<uint8_t>(std::min(255, std::max(0, byte)))));
+      }
+    }
+  }
+  return out;
+}
+
+// The argv the SERVER layer runs to mux frames + audio into MP4. Pure string
+// assembly — this function never spawns anything.
+//
+// Mirrors upstream's container choice: H.264 video (yuv420p so every player
+// accepts it) plus AAC audio, `+faststart` so the moov atom leads and the file is
+// streamable. `frame_pattern` is a printf-style path (e.g. ".../frame_%06d.ppm").
+std::vector<std::string> MiniMaxH3BuildMp4MuxArgs(const MiniMaxH3MuxRequest& request) {
+  VT_CHECK(!request.frame_pattern.empty(), "minimax_h3 mux: frame_pattern is required");
+  VT_CHECK(!request.output_path.empty(), "minimax_h3 mux: output_path is required");
+  VT_CHECK(request.fps > 0, "minimax_h3 mux: fps must be positive");
+
+  std::vector<std::string> argv = {
+      "ffmpeg", "-y", "-loglevel", "error",
+      // video input: a numbered PPM sequence at the generation frame rate
+      "-framerate", std::to_string(request.fps),
+      "-i", request.frame_pattern,
+  };
+  if (!request.audio_path.empty()) {
+    argv.insert(argv.end(), {"-i", request.audio_path});
+  }
+  argv.insert(argv.end(), {"-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf",
+                           std::to_string(request.crf)});
+  if (!request.audio_path.empty()) {
+    argv.insert(argv.end(), {"-c:a", "aac", "-b:a", "192k",
+                             // stop at the shorter stream so a half-second of
+                             // trailing silence or video never leaks in
+                             "-shortest"});
+  }
+  argv.insert(argv.end(), {"-movflags", "+faststart", request.output_path});
+  return argv;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_nvfp4.cpp b/src/vllm/model_executor/models/minimax_h3_nvfp4.cpp
new file mode 100644
index 000000000..72f1f714c
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_nvfp4.cpp
@@ -0,0 +1,100 @@
+// MiniMax-H3 NVFP4 arm — the quantized safetensors checkpoint that is also the
+// SPEED path on sm_121 (native FP4 tensor cores).
+//
+// The real 1051-tensor manifest of `lilcheaty/MiniMax-H3-NVFP4` is gated in
+// tests/vllm/models/minimax_h3_nvfp4_manifest.inc and shows the checkpoint is the
+// textbook compressed-tensors triple this project ALREADY consumes:
+//
+//   <name>.weight          U8       FP4 packed 2-per-byte, [out, in/2]
+//   <name>.weight_scale    F8_E4M3  one per group of 16 along K, [out, in/16]
+//   <name>.weight_scale_2  F32      one global scalar
+//
+// 258 quantized projections carry all three; the fp32/bf16 ISLANDS (both patch
+// projections, the time embedder, both output heads, the norms, rope.inv_freq)
+// are left unquantized so the DiT's dtype policy survives. The names are
+// IDENTICAL to the contract derived from upstream source, so — as with the GGUF
+// arm — there is no rename table, only a dequantization decision per tensor.
+//
+// This loader materializes to f32 for the reference forward. The DEVICE path
+// (brick W2b/W10b) will instead keep the packed FP4 resident and route the
+// projections through the existing cutlass FP4 GEMM, which is where the speed
+// actually comes from; nothing here claims a speed result.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "vllm/model_executor/model_loader/nvfp4_dequant.h"
+#include "vllm/model_executor/model_loader/safetensors_reader.h"
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+// vt bf16 bit pattern -> f32.
+float Bf16ToF32(uint16_t bits) {
+  const uint32_t widened = static_cast<uint32_t>(bits) << 16;
+  float out;
+  std::memcpy(&out, &widened, sizeof(out));
+  return out;
+}
+
+}  // namespace
+
+MiniMaxH3GgufDit LoadMiniMaxH3DitFromNvfp4(const SafetensorsFile& file) {
+  MiniMaxH3GgufDit out;
+
+  // --- pass 1: materialize every tensor to f32 ---
+  for (const std::string& name : file.Names()) {
+    // Quantization sidecars are consumed with their parent, never on their own.
+    if (name.size() > 12 &&
+        (name.compare(name.size() - 12, 12, "weight_scale") == 0 ||
+         (name.size() > 14 && name.compare(name.size() - 14, 14, "weight_scale_2") == 0))) {
+      continue;
+    }
+    const StTensor& t = file.Get(name);
+    if (t.dtype != "U8") {
+      out.storage[name] = MiniMaxH3ReadSafetensorF32(t);
+      out.shapes[name] = t.shape;
+      continue;
+    }
+
+    // NVFP4: [out, in/2] packed + [out, in/16] E4M3 group scales + f32 global.
+    VT_CHECK(t.shape.size() == 2, "minimax_h3 nvfp4: a packed weight must be rank 2");
+    const int64_t out_dim = t.shape[0];
+    const int64_t in_dim = t.shape[1] * 2;
+    const StTensor& scale = file.Get(name + "_scale");
+    const StTensor& global = file.Get(name + "_scale_2");
+    VT_CHECK(scale.dtype == "F8_E4M3", "minimax_h3 nvfp4: weight_scale must be F8_E4M3");
+    VT_CHECK(global.dtype == "F32", "minimax_h3 nvfp4: weight_scale_2 must be F32");
+    VT_CHECK(scale.shape.size() == 2 && scale.shape[0] == out_dim &&
+                 scale.shape[1] * 16 == in_dim,
+             "minimax_h3 nvfp4: weight_scale must be [out, in/16] (NVFP4 group size 16)");
+    float global_scale = 0.0f;
+    VT_CHECK(global.nbytes >= sizeof(float), "minimax_h3 nvfp4: weight_scale_2 is too small");
+    std::memcpy(&global_scale, global.data, sizeof(float));
+
+    std::vector<uint16_t> bf16(static_cast<size_t>(out_dim * in_dim));
+    DequantNvfp4ToBf16(t.data, scale.data, global_scale, out_dim, in_dim, bf16.data());
+    std::vector<float> values(bf16.size());
+    for (size_t i = 0; i < bf16.size(); ++i) values[i] = Bf16ToF32(bf16[i]);
+    out.storage[name] = std::move(values);
+    out.shapes[name] = {out_dim, in_dim};
+  }
+
+  // --- pass 2: geometry from the materialized shapes, then bind the views ---
+  std::vector<MiniMaxH3TensorSpec> manifest;
+  manifest.reserve(out.shapes.size());
+  for (const auto& entry : out.shapes) {
+    MiniMaxH3TensorSpec spec;
+    spec.name = entry.first;
+    spec.shape = entry.second;
+    manifest.push_back(std::move(spec));
+  }
+  out.params = ParseMiniMaxH3DitParamsFromGgufManifest(manifest);
+  BindMiniMaxH3DitViews(&out);
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_packing.cpp b/src/vllm/model_executor/models/minimax_h3_packing.cpp
new file mode 100644
index 000000000..f11190a2f
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_packing.cpp
@@ -0,0 +1,751 @@
+// MiniMax-H3 packed-token and packed-sequence layout math.
+// Port of vllm-project/vllm-omni, vllm_omni/diffusion/models/minimax_h3/
+// packed_tokens.py (patchify/unpatchify/audio pack) and packed_sequence.py
+// (the fl2va and ref2va packed layouts).
+//
+// EXACTNESS NOTE. The position grid is FP64 and feeds RoPE directly, so this port
+// reproduces upstream's arithmetic ORDER, not merely its formulas:
+//   * `NumpyLinspaceNoEndpoint` reproduces numpy.linspace(endpoint=False), which
+//     evaluates `i * (delta/num) + start` — NOT `start + i*delta/num`.
+//   * `TemporalPositionSpan` reproduces numpy's PAIRWISE summation and
+//     `VideoTSpan` reproduces Python's SEQUENTIAL `sum()`. Upstream keeps these
+//     two deliberately separate because they diverge in the last ulp from n=16
+//     onward (packed_sequence.py:101-113); unifying them would silently shift the
+//     fl2va last-keyframe anchor against the ref2va origin.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <numeric>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+// packed_sequence.py:37-45
+constexpr double kInterp = 32.0;
+constexpr int64_t kTGroup = 5;
+constexpr double kFramePerToken[kTGroup] = {1.0, 4.0, 4.0, 4.0, 4.0};
+constexpr double kFrameRescale = 5.0 / 3.0;
+constexpr int64_t kSeqAlign = 64;
+constexpr int64_t kPatchH = 2;
+constexpr int64_t kPatchW = 2;
+
+// numpy.linspace(start, stop, num, endpoint=False): step = (stop-start)/num and
+// y[i] = i*step + start, evaluated in that order (numpy/core/function_base.py).
+std::vector<double> NumpyLinspaceNoEndpoint(double start, double stop, int64_t num) {
+  VT_CHECK(num > 0, "minimax_h3: linspace num must be positive");
+  const double step = (stop - start) / static_cast<double>(num);
+  std::vector<double> out(static_cast<size_t>(num));
+  for (int64_t i = 0; i < num; ++i) {
+    out[static_cast<size_t>(i)] = static_cast<double>(i) * step + start;
+  }
+  return out;
+}
+
+// _axis_from_sqrt_area (packed_sequence.py:258-263).
+std::vector<double> AxisFromSqrtArea(int64_t dim, int64_t patch, double sqrt_area) {
+  const double ratio = static_cast<double>(dim) / sqrt_area;
+  const double left = (1.0 - ratio) * 1.0 / 2.0;
+  const double right = left + ratio * 1.0;
+  std::vector<double> grid = NumpyLinspaceNoEndpoint(left, right, dim / patch);
+  for (double& value : grid) value *= kInterp;
+  return grid;
+}
+
+// numpy's pairwise summation (numpy/core/src/umath/loops_utils.h pairwise_sum_@TYPE@).
+double NumpyPairwiseSum(const double* data, int64_t n) {
+  if (n < 8) {
+    double res = 0.0;
+    for (int64_t i = 0; i < n; ++i) res += data[i];
+    return res;
+  }
+  if (n <= 128) {
+    double r[8];
+    for (int i = 0; i < 8; ++i) r[i] = data[i];
+    const int64_t body = n - (n % 8);
+    for (int64_t i = 8; i < body; i += 8) {
+      for (int j = 0; j < 8; ++j) r[j] += data[i + j];
+    }
+    double res = ((r[0] + r[1]) + (r[2] + r[3])) + ((r[4] + r[5]) + (r[6] + r[7]));
+    for (int64_t i = body; i < n; ++i) res += data[i];
+    return res;
+  }
+  int64_t n2 = n / 2;
+  n2 -= n2 % 8;
+  return NumpyPairwiseSum(data, n2) + NumpyPairwiseSum(data + n2, n - n2);
+}
+
+// _temporal_position_span (packed_sequence.py:101-113): numpy pairwise sum.
+double TemporalPositionSpan(int64_t temporal_length) {
+  std::vector<double> spans(static_cast<size_t>(temporal_length), kFrameRescale);
+  for (int64_t token_index = 0; token_index < kTGroup; ++token_index) {
+    for (int64_t i = token_index; i < temporal_length; i += kTGroup) {
+      spans[static_cast<size_t>(i)] *= kFramePerToken[token_index];
+    }
+  }
+  return NumpyPairwiseSum(spans.data(), temporal_length);
+}
+
+// _video_t_span (packed_sequence.py:274-277): Python sum(), sequential.
+double VideoTSpan(int64_t n) {
+  double total = 0.0;
+  for (int64_t k = 0; k < n; ++k) total += kFrameRescale * kFramePerToken[k % kTGroup];
+  return total;
+}
+
+// _video_t_grid (packed_sequence.py:266-271): origin + [0, cumsum(spans[:-1])].
+std::vector<double> VideoTGrid(int64_t n, double origin) {
+  std::vector<double> grid(static_cast<size_t>(n));
+  double running = 0.0;
+  for (int64_t k = 0; k < n; ++k) {
+    grid[static_cast<size_t>(k)] = origin + running;
+    running += kFrameRescale * kFramePerToken[k % kTGroup];
+  }
+  return grid;
+}
+
+// The [h, w] coordinate pairs of one frame, meshgrid(h_grid, w_grid, "ij").
+std::vector<double> FrameGrid(const std::vector<double>& h_grid, const std::vector<double>& w_grid) {
+  std::vector<double> frame(h_grid.size() * w_grid.size() * 2);
+  size_t k = 0;
+  for (double h : h_grid) {
+    for (double w : w_grid) {
+      frame[k++] = h;
+      frame[k++] = w;
+    }
+  }
+  return frame;
+}
+
+void FillRange(std::vector<int64_t>& out, int64_t start, int64_t stop) {
+  for (int64_t i = start; i < stop; ++i) out.push_back(i);
+}
+
+int64_t AlignUp(int64_t used) { return ((used + kSeqAlign - 1) / kSeqAlign) * kSeqAlign; }
+
+}  // namespace
+
+// ---------------------------------------------------------------------------
+// packed_tokens.py
+// ---------------------------------------------------------------------------
+
+// minimax_h3_patchify_video_latent (packed_tokens.py:23-41).
+// einsum("nctrhpwq->nthwcrpq") over [B,C,t,pt,h,ph,w,pw].
+std::vector<float> MiniMaxH3PatchifyVideoLatent(const std::vector<float>& latent, int64_t batch,
+                                                int64_t channels, int64_t full_t, int64_t full_h,
+                                                int64_t full_w, int64_t patch_t, int64_t patch_h,
+                                                int64_t patch_w) {
+  VT_CHECK(patch_t > 0 && patch_h > 0 && patch_w > 0, "minimax_h3 patchify: patch_size must be positive");
+  VT_CHECK(full_t % patch_t == 0 && full_h % patch_h == 0 && full_w % patch_w == 0,
+           "minimax_h3 patchify: latent dims must be divisible by patch_size");
+  const int64_t expected = batch * channels * full_t * full_h * full_w;
+  VT_CHECK(static_cast<int64_t>(latent.size()) == expected,
+           "minimax_h3 patchify: latent size does not match [B,C,T,H,W]");
+  const int64_t t = full_t / patch_t, h = full_h / patch_h, w = full_w / patch_w;
+  const int64_t row_width = channels * patch_t * patch_h * patch_w;
+  std::vector<float> rows(static_cast<size_t>(batch * t * h * w * row_width));
+  for (int64_t n = 0; n < batch; ++n) {
+    for (int64_t ti = 0; ti < t; ++ti) {
+      for (int64_t hi = 0; hi < h; ++hi) {
+        for (int64_t wi = 0; wi < w; ++wi) {
+          const int64_t row = ((n * t + ti) * h + hi) * w + wi;
+          int64_t k = 0;
+          for (int64_t c = 0; c < channels; ++c) {
+            for (int64_t r = 0; r < patch_t; ++r) {
+              for (int64_t p = 0; p < patch_h; ++p) {
+                for (int64_t q = 0; q < patch_w; ++q) {
+                  const int64_t src =
+                      (((n * channels + c) * full_t + ti * patch_t + r) * full_h + hi * patch_h + p) *
+                          full_w +
+                      wi * patch_w + q;
+                  rows[static_cast<size_t>(row * row_width + k)] = latent[static_cast<size_t>(src)];
+                  ++k;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return rows;
+}
+
+// minimax_h3_unpatchify_video_tokens (packed_tokens.py:44-70).
+std::vector<float> MiniMaxH3UnpatchifyVideoTokens(const std::vector<float>& rows, int64_t t,
+                                                  int64_t h, int64_t w, int64_t channels,
+                                                  int64_t patch_t, int64_t patch_h,
+                                                  int64_t patch_w) {
+  const int64_t row_width = channels * patch_t * patch_h * patch_w;
+  const int64_t rows_per_sample = t * h * w;
+  VT_CHECK(row_width > 0 && rows_per_sample > 0, "minimax_h3 unpatchify: degenerate shape");
+  VT_CHECK(static_cast<int64_t>(rows.size()) % (rows_per_sample * row_width) == 0,
+           "minimax_h3 unpatchify: rows not divisible by t*h*w");
+  const int64_t batch = static_cast<int64_t>(rows.size()) / (rows_per_sample * row_width);
+  const int64_t full_t = t * patch_t, full_h = h * patch_h, full_w = w * patch_w;
+  std::vector<float> latent(static_cast<size_t>(batch * channels * full_t * full_h * full_w));
+  for (int64_t n = 0; n < batch; ++n) {
+    for (int64_t ti = 0; ti < t; ++ti) {
+      for (int64_t hi = 0; hi < h; ++hi) {
+        for (int64_t wi = 0; wi < w; ++wi) {
+          const int64_t row = ((n * t + ti) * h + hi) * w + wi;
+          int64_t k = 0;
+          for (int64_t c = 0; c < channels; ++c) {
+            for (int64_t r = 0; r < patch_t; ++r) {
+              for (int64_t p = 0; p < patch_h; ++p) {
+                for (int64_t q = 0; q < patch_w; ++q) {
+                  const int64_t dst =
+                      (((n * channels + c) * full_t + ti * patch_t + r) * full_h + hi * patch_h + p) *
+                          full_w +
+                      wi * patch_w + q;
+                  latent[static_cast<size_t>(dst)] = rows[static_cast<size_t>(row * row_width + k)];
+                  ++k;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return latent;
+}
+
+// minimax_h3_pack_audio_latent (packed_tokens.py:73-85): permute(0,2,1).reshape.
+std::vector<float> MiniMaxH3PackAudioLatent(const std::vector<float>& latent, int64_t audio_channel,
+                                            int64_t latent_dim, int64_t steps) {
+  VT_CHECK(static_cast<int64_t>(latent.size()) == audio_channel * latent_dim * steps,
+           "minimax_h3 audio pack: latent size does not match [C,D,T]");
+  std::vector<float> rows(static_cast<size_t>(audio_channel * steps * latent_dim));
+  for (int64_t c = 0; c < audio_channel; ++c) {
+    for (int64_t s = 0; s < steps; ++s) {
+      for (int64_t d = 0; d < latent_dim; ++d) {
+        rows[static_cast<size_t>((c * steps + s) * latent_dim + d)] =
+            latent[static_cast<size_t>((c * latent_dim + d) * steps + s)];
+      }
+    }
+  }
+  return rows;
+}
+
+// minimax_h3_unpack_audio_tokens (packed_tokens.py:88-106).
+std::vector<float> MiniMaxH3UnpackAudioTokens(const std::vector<float>& rows, int64_t audio_t,
+                                              int64_t audio_channel, int64_t latent_dim) {
+  VT_CHECK(audio_t > 0 && audio_channel > 0, "minimax_h3 audio unpack: dims must be positive");
+  VT_CHECK(audio_t % audio_channel == 0,
+           "minimax_h3 audio unpack: audio_t must be divisible by audio_channel");
+  VT_CHECK(static_cast<int64_t>(rows.size()) == audio_t * latent_dim,
+           "minimax_h3 audio unpack: rows size does not match [audio_t, D]");
+  const int64_t steps = audio_t / audio_channel;
+  std::vector<float> latent(static_cast<size_t>(audio_channel * latent_dim * steps));
+  for (int64_t c = 0; c < audio_channel; ++c) {
+    for (int64_t s = 0; s < steps; ++s) {
+      for (int64_t d = 0; d < latent_dim; ++d) {
+        latent[static_cast<size_t>((c * latent_dim + d) * steps + s)] =
+            rows[static_cast<size_t>((c * steps + s) * latent_dim + d)];
+      }
+    }
+  }
+  return latent;
+}
+
+// ---------------------------------------------------------------------------
+// packed_sequence.py — fl2va / t2va
+// ---------------------------------------------------------------------------
+
+MiniMaxH3PackedSequence BuildMiniMaxH3PackedSequence(
+    int64_t text_len, int64_t latent_t, int64_t latent_h, int64_t latent_w, int64_t audio_t,
+    int64_t audio_channel, bool include_keyframe_cond,
+    const std::vector<int64_t>& keyframe_frame_indices, int64_t frame_count) {
+  // _keyframe_cond_frame_indices (packed_sequence.py:48-67): the strict fl2va
+  // layout only accepts the first, the last, or first+last as keyframe anchors.
+  std::vector<int64_t> cond_frames;
+  if (include_keyframe_cond) {
+    VT_CHECK(!keyframe_frame_indices.empty(),
+             "minimax_h3 fl2va: keyframe cond requires keyframe_frame_indices");
+    const bool ok = (keyframe_frame_indices == std::vector<int64_t>{0}) ||
+                    (keyframe_frame_indices == std::vector<int64_t>{-1}) ||
+                    (keyframe_frame_indices == std::vector<int64_t>{0, -1});
+    VT_CHECK(ok, "minimax_h3 fl2va: keyframe_frame_indices must be {0}, {-1} or {0,-1}");
+    cond_frames = keyframe_frame_indices;
+    VT_CHECK(frame_count > 0, "minimax_h3 fl2va: frame_count required with keyframes");
+  } else {
+    VT_CHECK(keyframe_frame_indices.empty(),
+             "minimax_h3 fl2va: keyframe_frame_indices must be empty without keyframe cond");
+  }
+
+  const int64_t ph = latent_h / kPatchH, pw = latent_w / kPatchW;
+  const int64_t frame_rows = ph * pw;
+  const int64_t cond_rows = static_cast<int64_t>(cond_frames.size()) * frame_rows;
+  const int64_t video_rows = latent_t * frame_rows;
+  const int64_t audio_rows = audio_t * audio_channel;
+  const int64_t used = text_len + cond_rows + audio_rows + video_rows;
+
+  MiniMaxH3PackedSequence out;
+  out.seq_len = AlignUp(used);
+  const int64_t seq_len = out.seq_len;
+
+  const int64_t text_begin = 0, text_end = text_len;
+  const int64_t cond_begin = text_end, cond_end = cond_begin + cond_rows;
+  const int64_t audio_begin = cond_end, audio_end = audio_begin + audio_rows;
+  const int64_t video_begin = audio_end, video_end = video_begin + video_rows;
+
+  out.input_ids.assign(static_cast<size_t>(seq_len), kMiniMaxH3PadId);
+  for (int64_t i = text_begin; i < text_end; ++i) out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3TextId;
+  for (int64_t i = cond_begin; i < cond_end; ++i)
+    out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3ImgVidCondId;
+  for (int64_t i = audio_begin; i < audio_end; ++i)
+    out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3AudioId;
+  if (audio_rows > 0) out.input_ids[static_cast<size_t>(audio_begin)] = kMiniMaxH3AudioFirstId;
+  for (int64_t i = video_begin; i < video_end; ++i)
+    out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3VideoId;
+  if (video_rows > 0) {
+    out.input_ids[static_cast<size_t>(video_begin)] = kMiniMaxH3VideoFirstId;
+    out.input_ids[static_cast<size_t>(video_end - 1)] = kMiniMaxH3VideoLastId;
+  }
+
+  out.image_mask.assign(static_cast<size_t>(seq_len), 0);
+  out.audio_mask.assign(static_cast<size_t>(seq_len), 0);
+  for (int64_t i = cond_begin; i < cond_end; ++i) out.image_mask[static_cast<size_t>(i)] = 1;
+  for (int64_t i = video_begin; i < video_end; ++i) out.image_mask[static_cast<size_t>(i)] = 1;
+  for (int64_t i = audio_begin; i < audio_end; ++i) out.audio_mask[static_cast<size_t>(i)] = 1;
+
+  FillRange(out.img_pos, cond_begin, cond_end);
+  FillRange(out.img_pos, video_begin, video_end);
+  out.update_mask.assign(out.img_pos.size(), 0);
+  for (size_t i = static_cast<size_t>(cond_rows); i < out.update_mask.size(); ++i)
+    out.update_mask[i] = 1;
+  FillRange(out.audio_pos, audio_begin, audio_end);
+  FillRange(out.text_pos, 0, text_len);
+
+  // --- fp64 position grid (packed_sequence.py:181-216) ---
+  out.img_position_ids.assign(static_cast<size_t>(seq_len) * 3, 0.0);
+  for (int64_t i = 0; i < text_len; ++i) {
+    out.img_position_ids[static_cast<size_t>(i) * 3] = static_cast<double>(i);
+  }
+
+  const std::vector<double> t_grid = VideoTGrid(latent_t, static_cast<double>(text_len));
+  const double sqrt_area = std::sqrt(static_cast<double>(latent_h) * static_cast<double>(latent_w));
+  const std::vector<double> h_grid = AxisFromSqrtArea(latent_h, kPatchH, sqrt_area);
+  const std::vector<double> w_grid = AxisFromSqrtArea(latent_w, kPatchW, sqrt_area);
+  const std::vector<double> frame = FrameGrid(h_grid, w_grid);
+
+  for (size_t block_index = 0; block_index < cond_frames.size(); ++block_index) {
+    // _resolve_keyframe_frame_indices (packed_sequence.py:70-98) then the anchor
+    // rule at :193-207: only the first and last frames are valid anchors.
+    const int64_t semantic = cond_frames[block_index];
+    const int64_t resolved = semantic == -1 ? frame_count - 1 : semantic;
+    double cond_t = 0.0;
+    if (resolved == 0) {
+      cond_t = static_cast<double>(text_len);
+    } else if (resolved == frame_count - 1) {
+      cond_t = static_cast<double>(text_len) + TemporalPositionSpan(latent_t) - kFrameRescale;
+    } else {
+      VT_CHECK(false, "minimax_h3 fl2va: only first/last keyframe anchors are supported");
+    }
+    const int64_t begin = cond_begin + static_cast<int64_t>(block_index) * frame_rows;
+    for (int64_t r = 0; r < frame_rows; ++r) {
+      const size_t base = static_cast<size_t>(begin + r) * 3;
+      out.img_position_ids[base] = cond_t;
+      out.img_position_ids[base + 1] = frame[static_cast<size_t>(r) * 2];
+      out.img_position_ids[base + 2] = frame[static_cast<size_t>(r) * 2 + 1];
+    }
+  }
+
+  for (int64_t ti = 0; ti < latent_t; ++ti) {
+    for (int64_t r = 0; r < frame_rows; ++r) {
+      const size_t base = static_cast<size_t>(video_begin + ti * frame_rows + r) * 3;
+      out.img_position_ids[base] = t_grid[static_cast<size_t>(ti)];
+      out.img_position_ids[base + 1] = frame[static_cast<size_t>(r) * 2];
+      out.img_position_ids[base + 2] = frame[static_cast<size_t>(r) * 2 + 1];
+    }
+  }
+
+  // Audio rows are channel-major over the same t counter and are pinned to the
+  // extremes of the w grid (packed_sequence.py:209-216).
+  for (int64_t c = 0; c < audio_channel; ++c) {
+    for (int64_t s = 0; s < audio_t; ++s) {
+      const size_t base = static_cast<size_t>(audio_begin + c * audio_t + s) * 3;
+      out.img_position_ids[base] = static_cast<double>(text_len) + static_cast<double>(s);
+    }
+  }
+  for (int64_t i = 0; i < audio_rows; ++i) {
+    const size_t base = static_cast<size_t>(audio_begin + i) * 3;
+    out.img_position_ids[base + 2] = i < audio_t ? w_grid.front() : w_grid.back();
+  }
+
+  out.token_tags.assign(static_cast<size_t>(seq_len), kMiniMaxH3TagPadding);
+  for (int64_t i = text_begin; i < text_end; ++i)
+    out.token_tags[static_cast<size_t>(i)] = kMiniMaxH3TagText;
+  for (int64_t i = audio_begin; i < audio_end; ++i)
+    out.token_tags[static_cast<size_t>(i)] = kMiniMaxH3TagAudio;
+  for (int64_t pos : out.img_pos) out.token_tags[static_cast<size_t>(pos)] = kMiniMaxH3TagVideo;
+
+  out.cu_seqlens = {0, static_cast<int32_t>(used), static_cast<int32_t>(seq_len)};
+  out.document_id.assign(static_cast<size_t>(seq_len), 0);
+  for (int64_t i = video_end; i < seq_len; ++i) out.document_id[static_cast<size_t>(i)] = 1;
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// packed_sequence.py — ref2va block family
+// ---------------------------------------------------------------------------
+
+MiniMaxH3PackedSequence BuildMiniMaxH3PackedSequenceRef2va(
+    int64_t text_len, int64_t latent_t, int64_t latent_h, int64_t latent_w, int64_t audio_t,
+    const std::vector<MiniMaxH3RefBlock>& ref_blocks, int64_t audio_channel) {
+  using Kind = MiniMaxH3RefBlock::Kind;
+
+  int64_t ref_visual_rows = 0, ref_audio_rows = 0;
+  for (const MiniMaxH3RefBlock& block : ref_blocks) {
+    if (block.kind == Kind::kImage) {
+      VT_CHECK(block.latent_h > 0 && block.latent_w > 0, "minimax_h3 ref2va: image block dims");
+      ref_visual_rows += (block.latent_h / kPatchH) * (block.latent_w / kPatchW);
+    } else if (block.kind == Kind::kAudio) {
+      VT_CHECK(block.ref_audio_t >= 0, "minimax_h3 ref2va: audio block ref_audio_t");
+      ref_audio_rows += block.ref_audio_t * audio_channel;
+    } else {
+      VT_CHECK(block.latent_t > 0 && block.latent_h > 0 && block.latent_w > 0,
+               "minimax_h3 ref2va: video block dims");
+      ref_audio_rows += block.ref_audio_t * audio_channel;
+      ref_visual_rows += block.latent_t * (block.latent_h / kPatchH) * (block.latent_w / kPatchW);
+    }
+  }
+
+  const int64_t ph = latent_h / kPatchH, pw = latent_w / kPatchW;
+  const int64_t frame_rows = ph * pw;
+  const int64_t video_rows = latent_t * frame_rows;
+  const int64_t audio_rows = audio_t * audio_channel;
+  const int64_t used = text_len + ref_visual_rows + ref_audio_rows + audio_rows + video_rows;
+
+  MiniMaxH3PackedSequence out;
+  out.seq_len = AlignUp(used);
+  const int64_t seq_len = out.seq_len;
+
+  out.input_ids.assign(static_cast<size_t>(seq_len), kMiniMaxH3PadId);
+  out.image_mask.assign(static_cast<size_t>(seq_len), 0);
+  out.audio_mask.assign(static_cast<size_t>(seq_len), 0);
+  out.img_position_ids.assign(static_cast<size_t>(seq_len) * 3, 0.0);
+  out.token_tags.assign(static_cast<size_t>(seq_len), kMiniMaxH3TagPadding);
+
+  for (int64_t i = 0; i < text_len; ++i) {
+    out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3TextId;
+    out.token_tags[static_cast<size_t>(i)] = kMiniMaxH3TagText;
+    out.img_position_ids[static_cast<size_t>(i) * 3] = static_cast<double>(i);
+  }
+  FillRange(out.text_pos, 0, text_len);
+
+  const double target_area = std::sqrt(static_cast<double>(latent_h) * static_cast<double>(latent_w));
+  const std::vector<double> h_grid = AxisFromSqrtArea(latent_h, kPatchH, target_area);
+  const std::vector<double> w_grid = AxisFromSqrtArea(latent_w, kPatchW, target_area);
+  const std::vector<double> target_frame = FrameGrid(h_grid, w_grid);
+
+  // Reference blocks are consumed in request order; each advances the temporal
+  // cursor by its own span (packed_sequence.py:416-498).
+  std::vector<int64_t> ref_img_pos, ref_audio_pos;
+  int64_t cursor = text_len;
+  double t_cursor = static_cast<double>(text_len);
+  for (const MiniMaxH3RefBlock& block : ref_blocks) {
+    if (block.kind == Kind::kImage) {
+      const int64_t rows = (block.latent_h / kPatchH) * (block.latent_w / kPatchW);
+      const int64_t begin = cursor, end = cursor + rows;
+      cursor = end;
+      const double area =
+          std::sqrt(static_cast<double>(block.latent_h) * static_cast<double>(block.latent_w));
+      const std::vector<double> rh = AxisFromSqrtArea(block.latent_h, kPatchH, area);
+      const std::vector<double> rw = AxisFromSqrtArea(block.latent_w, kPatchW, area);
+      const std::vector<double> ref_frame = FrameGrid(rh, rw);
+      for (int64_t i = begin; i < end; ++i) {
+        out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3ImgVidCondId;
+        out.image_mask[static_cast<size_t>(i)] = 1;
+        const size_t base = static_cast<size_t>(i) * 3;
+        out.img_position_ids[base] = t_cursor;
+        out.img_position_ids[base + 1] = ref_frame[static_cast<size_t>(i - begin) * 2];
+        out.img_position_ids[base + 2] = ref_frame[static_cast<size_t>(i - begin) * 2 + 1];
+      }
+      FillRange(ref_img_pos, begin, end);
+      t_cursor += 1.0;
+    } else if (block.kind == Kind::kAudio) {
+      const int64_t rows = block.ref_audio_t * audio_channel;
+      const int64_t begin = cursor, end = cursor + rows;
+      cursor = end;
+      for (int64_t i = begin; i < end; ++i) {
+        out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3AudioRefCondId;
+        out.audio_mask[static_cast<size_t>(i)] = 1;
+      }
+      for (int64_t c = 0; c < audio_channel; ++c) {
+        for (int64_t s = 0; s < block.ref_audio_t; ++s) {
+          out.img_position_ids[static_cast<size_t>(begin + c * block.ref_audio_t + s) * 3] =
+              t_cursor + static_cast<double>(s);
+        }
+      }
+      for (int64_t i = 0; i < rows; ++i) {
+        out.img_position_ids[static_cast<size_t>(begin + i) * 3 + 2] =
+            i < block.ref_audio_t ? w_grid.front() : w_grid.back();
+      }
+      FillRange(ref_audio_pos, begin, end);
+      t_cursor += static_cast<double>(block.ref_audio_t);
+    } else {
+      // A video-bearing block packs its audio rows immediately before its video
+      // rows; both share a temporal origin and advance by the LONGER span.
+      const int64_t block_frame_rows = (block.latent_h / kPatchH) * (block.latent_w / kPatchW);
+      const int64_t a_rows = block.ref_audio_t * audio_channel;
+      const int64_t v_rows = block.latent_t * block_frame_rows;
+      const int64_t a_begin = cursor, a_end = cursor + a_rows;
+      const int64_t v_begin = a_end, v_end = a_end + v_rows;
+      cursor = v_end;
+
+      const double ref_area =
+          std::sqrt(static_cast<double>(block.latent_h) * static_cast<double>(block.latent_w));
+      const std::vector<double> rv_h = AxisFromSqrtArea(block.latent_h, kPatchH, ref_area);
+      const std::vector<double> rv_w = AxisFromSqrtArea(block.latent_w, kPatchW, ref_area);
+      const std::vector<double> rv_frame = FrameGrid(rv_h, rv_w);
+
+      for (int64_t i = a_begin; i < a_end; ++i) {
+        out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3AudioRefCondId;
+        out.audio_mask[static_cast<size_t>(i)] = 1;
+      }
+      for (int64_t c = 0; c < audio_channel; ++c) {
+        for (int64_t s = 0; s < block.ref_audio_t; ++s) {
+          out.img_position_ids[static_cast<size_t>(a_begin + c * block.ref_audio_t + s) * 3] =
+              t_cursor + static_cast<double>(s);
+        }
+      }
+      for (int64_t i = 0; i < a_rows; ++i) {
+        out.img_position_ids[static_cast<size_t>(a_begin + i) * 3 + 2] =
+            i < block.ref_audio_t ? rv_w.front() : rv_w.back();
+      }
+      FillRange(ref_audio_pos, a_begin, a_end);
+
+      const std::vector<double> rv_t_grid = VideoTGrid(block.latent_t, t_cursor);
+      for (int64_t i = v_begin; i < v_end; ++i) {
+        out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3ImgVidCondId;
+        out.image_mask[static_cast<size_t>(i)] = 1;
+      }
+      for (int64_t ti = 0; ti < block.latent_t; ++ti) {
+        for (int64_t r = 0; r < block_frame_rows; ++r) {
+          const size_t base = static_cast<size_t>(v_begin + ti * block_frame_rows + r) * 3;
+          out.img_position_ids[base] = rv_t_grid[static_cast<size_t>(ti)];
+          out.img_position_ids[base + 1] = rv_frame[static_cast<size_t>(r) * 2];
+          out.img_position_ids[base + 2] = rv_frame[static_cast<size_t>(r) * 2 + 1];
+        }
+      }
+      FillRange(ref_img_pos, v_begin, v_end);
+      t_cursor += std::max(static_cast<double>(block.ref_audio_t), VideoTSpan(block.latent_t));
+    }
+  }
+
+  const int64_t audio_begin = cursor, audio_end = cursor + audio_rows;
+  const int64_t video_begin = audio_end, video_end = audio_end + video_rows;
+
+  for (int64_t i = audio_begin; i < audio_end; ++i) {
+    out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3AudioId;
+    out.audio_mask[static_cast<size_t>(i)] = 1;
+  }
+  if (audio_rows > 0) out.input_ids[static_cast<size_t>(audio_begin)] = kMiniMaxH3AudioFirstId;
+  for (int64_t i = video_begin; i < video_end; ++i) {
+    out.input_ids[static_cast<size_t>(i)] = kMiniMaxH3VideoId;
+    out.image_mask[static_cast<size_t>(i)] = 1;
+  }
+  if (video_rows > 0) {
+    out.input_ids[static_cast<size_t>(video_begin)] = kMiniMaxH3VideoFirstId;
+    out.input_ids[static_cast<size_t>(video_end - 1)] = kMiniMaxH3VideoLastId;
+  }
+
+  for (int64_t c = 0; c < audio_channel; ++c) {
+    for (int64_t s = 0; s < audio_t; ++s) {
+      out.img_position_ids[static_cast<size_t>(audio_begin + c * audio_t + s) * 3] =
+          t_cursor + static_cast<double>(s);
+    }
+  }
+  for (int64_t i = 0; i < audio_rows; ++i) {
+    out.img_position_ids[static_cast<size_t>(audio_begin + i) * 3 + 2] =
+        i < audio_t ? w_grid.front() : w_grid.back();
+  }
+
+  const std::vector<double> t_grid = VideoTGrid(latent_t, t_cursor);
+  for (int64_t ti = 0; ti < latent_t; ++ti) {
+    for (int64_t r = 0; r < frame_rows; ++r) {
+      const size_t base = static_cast<size_t>(video_begin + ti * frame_rows + r) * 3;
+      out.img_position_ids[base] = t_grid[static_cast<size_t>(ti)];
+      out.img_position_ids[base + 1] = target_frame[static_cast<size_t>(r) * 2];
+      out.img_position_ids[base + 2] = target_frame[static_cast<size_t>(r) * 2 + 1];
+    }
+  }
+
+  out.img_pos = ref_img_pos;
+  FillRange(out.img_pos, video_begin, video_end);
+  out.audio_pos = ref_audio_pos;
+  FillRange(out.audio_pos, audio_begin, audio_end);
+
+  out.update_mask.assign(out.img_pos.size(), 0);
+  for (size_t i = static_cast<size_t>(ref_visual_rows); i < out.update_mask.size(); ++i)
+    out.update_mask[i] = 1;
+  out.audio_update_mask.assign(out.audio_pos.size(), 0);
+  for (size_t i = static_cast<size_t>(ref_audio_rows); i < out.audio_update_mask.size(); ++i)
+    out.audio_update_mask[i] = 1;
+
+  for (int64_t pos : ref_audio_pos) out.token_tags[static_cast<size_t>(pos)] = kMiniMaxH3TagAudio;
+  for (int64_t i = audio_begin; i < audio_end; ++i)
+    out.token_tags[static_cast<size_t>(i)] = kMiniMaxH3TagAudio;
+  for (int64_t pos : out.img_pos) out.token_tags[static_cast<size_t>(pos)] = kMiniMaxH3TagVideo;
+
+  out.cu_seqlens = {0, static_cast<int32_t>(used), static_cast<int32_t>(seq_len)};
+  out.document_id.assign(static_cast<size_t>(seq_len), 0);
+  for (int64_t i = video_end; i < seq_len; ++i) out.document_id[static_cast<size_t>(i)] = 1;
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// scheduling_minimax_h3_euler_ancestral.py
+// ---------------------------------------------------------------------------
+
+std::vector<float> MiniMaxH3RfVToX0(const std::vector<float>& xt, const std::vector<float>& v,
+                                    double timestep) {
+  VT_CHECK(xt.size() == v.size(), "minimax_h3 rf_v_to_x0: xt and v must match");
+  VT_CHECK(timestep >= 0.0 && timestep <= 1.0, "minimax_h3 rf_v_to_x0: timestep must be in [0,1]");
+  // x0 = xt + (1 - t) * v, evaluated at the state dtype (f32 here).
+  const float sigma = static_cast<float>(1.0 - timestep);
+  std::vector<float> out(xt.size());
+  for (size_t i = 0; i < xt.size(); ++i) out[i] = xt[i] + sigma * v[i];
+  return out;
+}
+
+std::vector<float> MiniMaxH3EulerEta0Step(const std::vector<float>& state,
+                                          const std::vector<float>& denoised, double sigma_curr,
+                                          double sigma_next) {
+  VT_CHECK(state.size() == denoised.size(), "minimax_h3 euler step: shapes must match");
+  VT_CHECK(sigma_curr >= 0.0 && sigma_next >= 0.0, "minimax_h3 euler step: sigmas must be >= 0");
+  if (sigma_curr == 0.0) {
+    VT_CHECK(sigma_next == 0.0, "minimax_h3 euler step: sigma_next must be 0 when sigma_curr is 0");
+    return state;
+  }
+  // f32 state keeps compute_dtype == f32 (scheduling:93-100).
+  const float ratio = static_cast<float>(sigma_next) / static_cast<float>(sigma_curr);
+  std::vector<float> out(state.size());
+  for (size_t i = 0; i < state.size(); ++i) out[i] = ratio * state[i] + (1.0f - ratio) * denoised[i];
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Condition-noise augmentation (condition_noise.py)
+//
+// fl2va/ref2va pin their keyframe (and reference-audio) rows to a NOISED anchor
+// rather than the clean latent: `out = t*clean + (1-t)*noise` with t the request's
+// `noise_aug`. The mix is trivial; what is easy to get wrong is the ROW ACCOUNTING
+// around it, which is what these functions own and what the gate pins:
+//   * each visual condition draws noise of length
+//     `target_latent_t + imgvid_cond_num_frames`, then slices the PREFIX matching
+//     its own latent_t (so a shorter condition does NOT get a shorter draw);
+//   * every condition restarts the SAME seed, so concatenating and drawing once
+//     would be numerically different for multi-reference requests;
+//   * rows advance by that condition's own patchified row count.
+//
+// NOISE IS AN INPUT here, exactly as in the t2va pipeline: upstream draws it from
+// a seeded torch CPU generator, and reproducing torch's RNG bit-exactly decides
+// WHICH sample you get rather than whether the accounting is right.
+// ---------------------------------------------------------------------------
+
+std::vector<float> MiniMaxH3ImgvidCondNoiseAug(const std::vector<float>& clean_rows,
+                                               const std::vector<int64_t>& condition_shapes,
+                                               int64_t target_latent_t,
+                                               int64_t imgvid_cond_num_frames, double noise_aug,
+                                               const std::vector<float>& noise_rows) {
+  VT_CHECK(noise_aug >= 0.0 && noise_aug <= 1.0,
+           "minimax_h3 cond noise: noise_aug must be in [0, 1]");
+  if (noise_aug == 1.0) return clean_rows;  // fully clean: the anchor IS the latent
+  VT_CHECK(!condition_shapes.empty() && condition_shapes.size() % 3 == 0,
+           "minimax_h3 cond noise: condition_shapes must be (t, h, w) triples");
+  VT_CHECK(target_latent_t > 0 && imgvid_cond_num_frames > 0,
+           "minimax_h3 cond noise: target_latent_t and imgvid_cond_num_frames must be positive");
+
+  int64_t expected_rows = 0;
+  const int64_t num_conditions = static_cast<int64_t>(condition_shapes.size()) / 3;
+  for (int64_t c = 0; c < num_conditions; ++c) {
+    const int64_t t = condition_shapes[static_cast<size_t>(c * 3 + 0)];
+    const int64_t h = condition_shapes[static_cast<size_t>(c * 3 + 1)];
+    const int64_t w = condition_shapes[static_cast<size_t>(c * 3 + 2)];
+    VT_CHECK(t > 0 && h > 0 && w > 0, "minimax_h3 cond noise: condition shape must be positive");
+    VT_CHECK(h % 2 == 0 && w % 2 == 0,
+             "minimax_h3 cond noise: condition spatial dims must be divisible by 2");
+    VT_CHECK(t <= target_latent_t + imgvid_cond_num_frames,
+             "minimax_h3 cond noise: condition latent_t exceeds the noise draw length");
+    expected_rows += t * (h / 2) * (w / 2);
+  }
+  VT_CHECK(static_cast<int64_t>(clean_rows.size()) == expected_rows * kMiniMaxH3VideoRowWidth,
+           "minimax_h3 cond noise: clean rows do not match the shape-derived row count");
+  VT_CHECK(noise_rows.size() == clean_rows.size(),
+           "minimax_h3 cond noise: noise rows must match the clean rows");
+
+  const float t_mix = static_cast<float>(noise_aug);
+  std::vector<float> out(clean_rows.size());
+  for (size_t i = 0; i < out.size(); ++i) {
+    out[i] = t_mix * clean_rows[i] + (1.0f - t_mix) * noise_rows[i];
+  }
+  return out;
+}
+
+std::vector<float> MiniMaxH3AudioCondNoiseAug(const std::vector<float>& clean_rows,
+                                              const std::vector<int64_t>& condition_audio_t,
+                                              double noise_aug,
+                                              const std::vector<float>& noise_rows) {
+  VT_CHECK(noise_aug >= 0.0 && noise_aug <= 1.0,
+           "minimax_h3 cond noise: noise_aug must be in [0, 1]");
+  if (noise_aug == 1.0) return clean_rows;
+  VT_CHECK(!condition_audio_t.empty(), "minimax_h3 cond noise: condition_audio_t must not be empty");
+  int64_t expected_rows = 0;
+  for (int64_t audio_t : condition_audio_t) {
+    VT_CHECK(audio_t > 0, "minimax_h3 cond noise: condition audio length must be positive");
+    expected_rows += kMiniMaxH3AudioCondChannels * audio_t;
+  }
+  VT_CHECK(static_cast<int64_t>(clean_rows.size()) == expected_rows * kMiniMaxH3AudioRowWidth,
+           "minimax_h3 cond noise: clean audio rows do not match the derived row count");
+  VT_CHECK(noise_rows.size() == clean_rows.size(),
+           "minimax_h3 cond noise: noise rows must match the clean rows");
+
+  const float t_mix = static_cast<float>(noise_aug);
+  std::vector<float> out(clean_rows.size());
+  for (size_t i = 0; i < out.size(); ++i) {
+    out[i] = t_mix * clean_rows[i] + (1.0f - t_mix) * noise_rows[i];
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Presentation token tags (presentation.py:42-62, 92-129)
+//
+// The prompt presentation interleaves TEXT spans with VISION blocks, and the AdaLN
+// token tags must line up with it. This is the fl2va "vision-span override" the
+// denoise loop requires callers to have applied to `token_tags` before the forward.
+//
+// THE DETAIL THAT MATTERS: a vision block is
+// `<|vision_start|> + pad*count + <|vision_end|>`, and the WHOLE block — markers
+// included — is tagged VIDEO. Tagging only the pads leaves the two markers as TEXT
+// and shifts every AdaLN modulation index after them.
+//
+// Tokenization stays with the caller (it owns the tokenizer); this takes SPAN
+// LENGTHS, which is the part that has to agree with the packed layout.
+// ---------------------------------------------------------------------------
+
+int64_t MiniMaxH3VisionBlockTokenLength(int64_t pad_count) {
+  VT_CHECK(pad_count > 0, "minimax_h3 presentation: vision pad count must be positive");
+  return pad_count + 2;  // the <|vision_start|> / <|vision_end|> markers
+}
+
+std::vector<int64_t> MiniMaxH3BuildPresentationTokenTags(
+    const std::vector<MiniMaxH3PresentationSpan>& spans) {
+  VT_CHECK(!spans.empty(), "minimax_h3 presentation: spans must not be empty");
+  std::vector<int64_t> tags;
+  for (const MiniMaxH3PresentationSpan& span : spans) {
+    VT_CHECK(span.length > 0, "minimax_h3 presentation: span length must be positive");
+    const int64_t tag =
+        span.kind == MiniMaxH3PresentationSpan::Kind::kVision ? kMiniMaxH3TagVideo : kMiniMaxH3TagText;
+    tags.insert(tags.end(), static_cast<size_t>(span.length), tag);
+  }
+  return tags;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_pipeline.cpp b/src/vllm/model_executor/models/minimax_h3_pipeline.cpp
new file mode 100644
index 000000000..2f79cc2ae
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_pipeline.cpp
@@ -0,0 +1,460 @@
+// MiniMax-H3 t2va pipeline assembly — the path from prompt embeddings to frames
+// and a waveform.
+//
+// Everything this file calls was ported and gated separately; W6 is the WIRING:
+//
+//   prompt_embeds ──► packed sequence (fl2va/t2va layout)
+//                     │
+//                     ├─► denoise loop: 50 x DiT forward + euler-eta0 step
+//                     │      (sigmas from the rectified-flow time-shift schedule)
+//                     ▼
+//              video rows / audio rows
+//                     │
+//        unpatchify ──┤── unpack audio
+//                     ▼
+//        video latent ──► video VAE ViT3D decoder ──► frames  [C, T, H, W]
+//        audio latent ──► audio VAE BigVGAN       ──► waveform per channel
+//
+// Latents are DENORMALIZED before decode (`latent * std + mean`), mirroring
+// vae.py:252-270 / :341-357.
+//
+// NOISE IS AN INPUT, deliberately. Upstream seeds a torch CPU generator
+// (pipeline_minimax_h3.py:813-843); reproducing torch's RNG bit-exactly is a
+// separate concern that decides WHICH sample you get, not whether the pipeline is
+// correct, so the caller supplies the initial rows. See the spec's open items.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "vt/backend.h"
+#include "vt/dtype.h"
+
+namespace vllm {
+
+// Turn supplied KEYFRAME IMAGES into the packed conditioning rows the denoise loop
+// pins. This is the one step that stands between "the fl2va primitives are ported"
+// and "a caller can pass a first frame".
+//
+// Each image is [3, H, W] in [-1, 1] and is encoded as a ONE-FRAME clip: the 3D CNN
+// is causal in time, so a single frame is a valid input and yields latent_t 1.
+// Rows are then patchified with the DiT's own patch sizes, which is what makes them
+// interchangeable with the video rows the loop carries.
+//
+// `noise_aug` blends toward the supplied noise (1.0 pins the frame exactly). Noise
+// is an INPUT for the same reason it is in the t2va path: reproducing upstream's RNG
+// decides WHICH sample you get, not whether the pipeline is right.
+void MiniMaxH3VideoDenormalizePixels(std::vector<float>& frames, int64_t channels,
+                                     int64_t per_channel) {
+  VT_CHECK(channels == 3, "minimax_h3: ImageNet de-normalization expects 3 channels");
+  VT_CHECK(static_cast<int64_t>(frames.size()) == channels * per_channel,
+           "minimax_h3: frame buffer does not match [C, ...]");
+  for (int64_t c = 0; c < channels; ++c) {
+    const float mean = kMiniMaxH3ImagenetMean[c], std_dev = kMiniMaxH3ImagenetStd[c];
+    for (int64_t i = 0; i < per_channel; ++i) {
+      float& v = frames[static_cast<size_t>(c * per_channel + i)];
+      // clamp in [0,1] BEFORE the [-1,1] map, matching vae.py:693's order --
+      // clamping afterwards would let out-of-gamut values survive rescaled.
+      const float pixel = std::min(1.0F, std::max(0.0F, v * std_dev + mean));
+      v = pixel * 2.0F - 1.0F;
+    }
+  }
+}
+
+void MiniMaxH3VideoNormalizePixels(std::vector<float>& frames, int64_t channels,
+                                   int64_t per_channel) {
+  VT_CHECK(channels == 3, "minimax_h3: ImageNet normalization expects 3 channels");
+  VT_CHECK(static_cast<int64_t>(frames.size()) == channels * per_channel,
+           "minimax_h3: frame buffer does not match [C, ...]");
+  for (int64_t c = 0; c < channels; ++c) {
+    const float mean = kMiniMaxH3ImagenetMean[c], std_dev = kMiniMaxH3ImagenetStd[c];
+    for (int64_t i = 0; i < per_channel; ++i) {
+      float& v = frames[static_cast<size_t>(c * per_channel + i)];
+      v = ((v + 1.0F) * 0.5F - mean) / std_dev;  // vae.py:659
+    }
+  }
+}
+
+std::vector<float> MiniMaxH3EncodeReferenceVideo(
+    const MiniMaxH3EncoderFcn3dConfig& encoder_config,
+    const MiniMaxH3AudioVaeWeights& encoder_weights, const MiniMaxH3DitParams& dit_params,
+    const std::vector<float>& frames, int64_t frame_count, int64_t frame_h, int64_t frame_w,
+    MiniMaxH3RefBlock* out_block) {
+  VT_CHECK(frame_count > 0, "minimax_h3 ref2va: a video reference needs at least one frame");
+  VT_CHECK(static_cast<int64_t>(frames.size()) ==
+               encoder_config.in_channels * frame_count * frame_h * frame_w,
+           "minimax_h3 ref2va: reference video is not [in_channels, T, H, W]");
+
+  // The 3D CNN is CAUSAL in time, so a clip encodes in one call -- this is the same
+  // encoder the single-image path uses, just with t > 1, which is why a video
+  // reference needed no new porting once the image path existed.
+  // Same ImageNet normalization the image path needs (vae.py:659).
+  std::vector<float> norm = frames;
+  MiniMaxH3VideoNormalizePixels(norm, encoder_config.in_channels, frame_count * frame_h * frame_w);
+  MiniMaxH3EncoderFcn3dConfig cfg = encoder_config;
+  cfg.t = frame_count;
+  cfg.h = frame_h;
+  cfg.w = frame_w;
+  MiniMaxH3VideoFrameShape ls{};
+  const std::vector<float> latent =
+      MiniMaxH3VideoVaeEncodeToLatent(cfg, encoder_weights, norm, &ls);
+  std::vector<float> rows = MiniMaxH3PatchifyVideoLatent(
+      latent, /*batch=*/1, dit_params.latents_dim, ls.t, ls.h, ls.w, dit_params.patch_size_t,
+      dit_params.patch_size_h, dit_params.patch_size_w);
+
+  if (out_block != nullptr) {
+    // kVideoAudio is the only kind that carries a temporal extent -- kImage counts
+    // exactly one frame regardless of latent_t. ref_audio_t stays 0: silent.
+    MiniMaxH3RefBlock b;
+    b.kind = MiniMaxH3RefBlock::Kind::kVideoAudio;
+    b.ref_audio_t = 0;
+    b.latent_t = ls.t / dit_params.patch_size_t;
+    b.latent_h = ls.h / dit_params.patch_size_h;
+    b.latent_w = ls.w / dit_params.patch_size_w;
+    *out_block = b;
+  }
+  return rows;
+}
+
+// Turn a supplied REFERENCE WAVEFORM into the packed audio conditioning rows, the
+// audio counterpart of MiniMaxH3EncodeReferenceImages. This is what makes a
+// `kAudio` block (and a `kVideoAudio` block with sound) expressible at all.
+//
+// `waveform` is CHANNEL-MAJOR and already at kMiniMaxH3AudioSampleRate; a mono
+// source is REPEATED up to kMiniMaxH3AudioChannels, exactly as upstream does
+// before it encodes (vae.py:305-313). Rows come back normalized by the audio VAE's
+// own latent statistics, because that is the space the DiT's rows live in.
+//
+// `noise_aug` blends toward the supplied noise the way the visual side does
+// (1.0 pins the reference exactly); noise is an INPUT for the same reason it is
+// everywhere else in this pipeline.
+std::vector<float> MiniMaxH3EncodeReferenceAudio(
+    const MiniMaxH3AudioVaeEncoderConfig& encoder_config,
+    const MiniMaxH3AudioVaeWeights& encoder_weights, const std::vector<float>& waveform,
+    int64_t channels, int64_t samples_per_channel, const std::vector<float>& latents_mean,
+    const std::vector<float>& latents_std, double noise_aug,
+    const std::vector<float>& noise_rows, MiniMaxH3RefBlock* out_block) {
+  VT_CHECK(channels == kMiniMaxH3AudioChannels,
+           "minimax_h3 ref2va: reference audio must be stereo (mono is repeated by the caller)");
+  int64_t audio_t = 0;
+  std::vector<float> rows = MiniMaxH3AudioVaeEncodeToRows(
+      encoder_config, encoder_weights, waveform, channels, samples_per_channel, latents_mean,
+      latents_std, &audio_t);
+  VT_CHECK(audio_t > 0, "minimax_h3 ref2va: the reference waveform encoded to zero latent frames");
+
+  if (out_block != nullptr) {
+    // A bare audio reference is a kAudio block: no visual extent, `ref_audio_t`
+    // latent frames per channel.
+    MiniMaxH3RefBlock b;
+    b.kind = MiniMaxH3RefBlock::Kind::kAudio;
+    b.ref_audio_t = audio_t;
+    *out_block = b;
+  }
+  if (noise_aug >= 1.0 || noise_rows.empty()) return rows;
+  return MiniMaxH3AudioCondNoiseAug(rows, {audio_t}, noise_aug, noise_rows);
+}
+
+std::vector<float> MiniMaxH3EncodeReferenceImages(
+    const MiniMaxH3EncoderFcn3dConfig& encoder_config,
+    const MiniMaxH3AudioVaeWeights& encoder_weights, const MiniMaxH3DitParams& dit_params,
+    const std::vector<std::vector<float>>& images, int64_t image_h, int64_t image_w,
+    std::vector<MiniMaxH3RefBlock>* out_blocks) {
+  VT_CHECK(!images.empty(), "minimax_h3 ref2va: no reference images supplied");
+  std::vector<float> rows;
+  if (out_blocks != nullptr) out_blocks->clear();
+  for (const std::vector<float>& img : images) {
+    VT_CHECK(static_cast<int64_t>(img.size()) == encoder_config.in_channels * image_h * image_w,
+             "minimax_h3 ref2va: reference image is not [in_channels, H, W]");
+    // The encoder consumes IMAGENET-NORMALIZED pixels (vae.py:659), not [-1, 1].
+    std::vector<float> norm = img;
+    MiniMaxH3VideoNormalizePixels(norm, encoder_config.in_channels, image_h * image_w);
+    MiniMaxH3EncoderFcn3dConfig cfg = encoder_config;
+    cfg.t = 1;
+    cfg.h = image_h;
+    cfg.w = image_w;
+    MiniMaxH3VideoFrameShape ls{};
+    const std::vector<float> latent =
+        MiniMaxH3VideoVaeEncodeToLatent(cfg, encoder_weights, norm, &ls);
+    const std::vector<float> patched = MiniMaxH3PatchifyVideoLatent(
+        latent, /*batch=*/1, dit_params.latents_dim, ls.t, ls.h, ls.w, dit_params.patch_size_t,
+        dit_params.patch_size_h, dit_params.patch_size_w);
+    rows.insert(rows.end(), patched.begin(), patched.end());
+    if (out_blocks != nullptr) {
+      // The block declares the PATCHED grid, which is what occupies packed rows.
+      MiniMaxH3RefBlock b;
+      b.kind = MiniMaxH3RefBlock::Kind::kImage;
+      b.latent_t = ls.t / dit_params.patch_size_t;
+      b.latent_h = ls.h / dit_params.patch_size_h;
+      b.latent_w = ls.w / dit_params.patch_size_w;
+      out_blocks->push_back(b);
+    }
+  }
+  return rows;
+}
+
+std::vector<float> MiniMaxH3EncodeKeyframeCondRows(
+    const MiniMaxH3EncoderFcn3dConfig& encoder_config, const MiniMaxH3AudioVaeWeights& encoder_weights,
+    const MiniMaxH3DitParams& dit_params, const std::vector<std::vector<float>>& images,
+    int64_t image_h, int64_t image_w, int64_t target_latent_t, double noise_aug,
+    const std::vector<float>& noise_rows) {
+  VT_CHECK(!images.empty(), "minimax_h3 keyframe: no images supplied");
+  std::vector<float> rows;
+  std::vector<int64_t> condition_shapes;
+  for (const std::vector<float>& img : images) {
+    VT_CHECK(static_cast<int64_t>(img.size()) == encoder_config.in_channels * image_h * image_w,
+             "minimax_h3 keyframe: image is not [in_channels, H, W]");
+    // The encoder consumes IMAGENET-NORMALIZED pixels (vae.py:659), not [-1, 1].
+    std::vector<float> norm = img;
+    MiniMaxH3VideoNormalizePixels(norm, encoder_config.in_channels, image_h * image_w);
+    MiniMaxH3EncoderFcn3dConfig cfg = encoder_config;
+    cfg.t = 1;  // a single frame is a valid causal clip
+    cfg.h = image_h;
+    cfg.w = image_w;
+    MiniMaxH3VideoFrameShape ls{};
+    const std::vector<float> latent =
+        MiniMaxH3VideoVaeEncodeToLatent(cfg, encoder_weights, norm, &ls);
+    // [C, t, h, w] -> packed rows with the DiT's patch volume.
+    std::vector<float> patched = MiniMaxH3PatchifyVideoLatent(
+        latent, /*batch=*/1, dit_params.latents_dim, ls.t, ls.h, ls.w, dit_params.patch_size_t,
+        dit_params.patch_size_h, dit_params.patch_size_w);
+    rows.insert(rows.end(), patched.begin(), patched.end());
+    condition_shapes.push_back(ls.t);
+    condition_shapes.push_back(ls.h);
+    condition_shapes.push_back(ls.w);
+  }
+  if (noise_aug >= 1.0 || noise_rows.empty()) return rows;
+  return MiniMaxH3ImgvidCondNoiseAug(rows, condition_shapes, target_latent_t,
+                                     static_cast<int64_t>(images.size()), noise_aug, noise_rows);
+}
+
+MiniMaxH3DenoiseResult MiniMaxH3DenoiseT2va(vt::Device device, const MiniMaxH3T2vaRequest& request,
+                                            const MiniMaxH3DitParams& dit_params,
+                                            const MiniMaxH3DitWeights& dit_weights,
+                                            const std::vector<float>& prompt_embeds,
+                                            const std::vector<float>& initial_video_rows,
+                                            const std::vector<float>& initial_audio_rows,
+                                            vt::DType compute_dtype,
+                                            const MiniMaxH3DitDeviceWeights* prestaged) {
+  VT_CHECK(request.text_len > 0, "minimax_h3 t2va: text_len must be positive");
+  VT_CHECK(request.num_steps >= 1, "minimax_h3 t2va: num_steps must be >= 1");
+  VT_CHECK(static_cast<int64_t>(prompt_embeds.size()) == request.text_len * dit_params.text_dim,
+           "minimax_h3 t2va: prompt_embeds must be [text_len, text_dim]");
+
+  // --- 1. packed layout. fl2va is the SAME layout with keyframe conditioning
+  // switched on, so t2va is just the empty-keyframe case rather than a separate
+  // path -- upstream models it the same way (packed_sequence.py:116-239).
+  const bool has_keyframes = !request.keyframe_frame_indices.empty();
+  const bool has_refs = !request.ref_blocks.empty();
+  VT_CHECK(!(has_keyframes && has_refs),
+           "minimax_h3: keyframe (fl2va) and reference (ref2va) conditioning are exclusive");
+  MiniMaxH3DenoiseBranch branch;
+  int64_t ref_audio_rows = 0;
+  if (has_refs) {
+    // AUDIO-bearing reference blocks claim packed audio rows, and every claimed row
+    // must be BACKED by an encoded reference -- otherwise the layout would grow and
+    // the loop would pin whatever happened to be in the buffer. The rows come from
+    // MiniMaxH3EncodeReferenceAudio (the audio VAE's encoder half).
+    for (const MiniMaxH3RefBlock& b : request.ref_blocks) {
+      if (b.kind == MiniMaxH3RefBlock::Kind::kImage) continue;
+      VT_CHECK(b.ref_audio_t >= 0, "minimax_h3 ref2va: ref_audio_t cannot be negative");
+      ref_audio_rows += b.ref_audio_t * request.audio_channel;
+    }
+    VT_CHECK(static_cast<int64_t>(request.audio_ref_rows.size()) ==
+                 ref_audio_rows * dit_params.audio_latents_dim,
+             "minimax_h3 ref2va: audio_ref_rows must supply exactly the rows the reference blocks "
+             "claim (ref_audio_t * audio_channel per block) -- see "
+             "MiniMaxH3EncodeReferenceAudio");
+    branch.packed = BuildMiniMaxH3PackedSequenceRef2va(
+        request.text_len, request.latent_t, request.latent_h, request.latent_w, request.audio_t,
+        request.ref_blocks, request.audio_channel);
+  } else {
+    branch.packed = BuildMiniMaxH3PackedSequence(
+        request.text_len, request.latent_t, request.latent_h, request.latent_w, request.audio_t,
+        request.audio_channel, has_keyframes, request.keyframe_frame_indices,
+        has_keyframes ? request.num_frames : 0);
+  }
+  branch.text_embeddings = prompt_embeds;
+  branch.token_tags = branch.packed.token_tags;
+
+  // --- 2. the rectified-flow sigma schedules (video and audio shift differently) ---
+  const std::vector<double> sigmas_video =
+      MiniMaxH3TimeShiftSigmas(request.num_steps, request.video_shift);
+  const std::vector<double> sigmas_audio =
+      MiniMaxH3TimeShiftSigmas(request.num_steps, request.audio_shift);
+  VT_CHECK(sigmas_video.size() == sigmas_audio.size(),
+           "minimax_h3 t2va: the two sigma schedules must have equal length");
+
+  // --- 3. the denoise loop (one DiT forward per step) ---
+  // Keyframe conditioning ADDS condition rows to the packed layout, and the loop
+  // wants initial rows for every img position. Callers supply noise for the TARGET
+  // rows -- that is what they can know -- so the condition slots are filled in
+  // here. Their contents do not matter: the loop pins them to the keyframe anchors
+  // before the first step.
+  const int64_t video_width = dit_params.video_row_width();
+  const int64_t num_img = static_cast<int64_t>(branch.packed.img_pos.size());
+  std::vector<float> video_rows = initial_video_rows;
+  if (static_cast<int64_t>(video_rows.size()) != num_img * video_width) {
+    VT_CHECK(has_keyframes || has_refs,
+             "minimax_h3 t2va: initial video rows do not match the packed layout");
+    std::vector<float> full(static_cast<size_t>(num_img * video_width), 0.0f);
+    int64_t src = 0;
+    for (int64_t r = 0; r < num_img; ++r) {
+      if (!branch.packed.update_mask[static_cast<size_t>(r)]) continue;  // pinned anchor
+      VT_CHECK((src + 1) * video_width <= static_cast<int64_t>(initial_video_rows.size()),
+               "minimax_h3 t2va: too few initial video rows for the denoise targets");
+      std::copy(initial_video_rows.begin() + src * video_width,
+                initial_video_rows.begin() + (src + 1) * video_width,
+                full.begin() + r * video_width);
+      ++src;
+    }
+    video_rows = std::move(full);
+  }
+
+  // The audio side has the SAME shape of problem once a reference carries sound:
+  // reference audio adds PINNED rows to the layout, and callers supply noise only
+  // for the denoise TARGETS (pipeline_minimax_h3.py:937-955). Scatter theirs into
+  // the updating slots and leave the pinned ones to the anchors below.
+  const int64_t audio_width = dit_params.audio_latents_dim;
+  const int64_t num_audio = static_cast<int64_t>(branch.packed.audio_pos.size());
+  std::vector<float> audio_rows = initial_audio_rows;
+  if (static_cast<int64_t>(audio_rows.size()) != num_audio * audio_width) {
+    VT_CHECK(ref_audio_rows > 0,
+             "minimax_h3 t2va: initial audio rows do not match the packed layout");
+    std::vector<float> full(static_cast<size_t>(num_audio * audio_width), 0.0f);
+    int64_t src = 0;
+    for (int64_t r = 0; r < num_audio; ++r) {
+      if (!branch.packed.audio_update_mask.empty() &&
+          !branch.packed.audio_update_mask[static_cast<size_t>(r)]) {
+        continue;  // a pinned reference row
+      }
+      VT_CHECK((src + 1) * audio_width <= static_cast<int64_t>(initial_audio_rows.size()),
+               "minimax_h3 t2va: too few initial audio rows for the denoise targets");
+      std::copy(initial_audio_rows.begin() + src * audio_width,
+                initial_audio_rows.begin() + (src + 1) * audio_width,
+                full.begin() + r * audio_width);
+      ++src;
+    }
+    audio_rows = std::move(full);
+  }
+
+  // Both the keyframe rows and the reference-audio rows are PINNED: the loop
+  // resets them to these anchors every step, so the supplied conditioning stays
+  // put instead of being denoised away.
+  return MiniMaxH3DenoiseLoop(device, dit_params, dit_weights, branch, video_rows, audio_rows,
+                              request.keyframe_cond_rows, request.audio_ref_rows, sigmas_video,
+                              sigmas_audio, compute_dtype, prestaged);
+}
+
+MiniMaxH3T2vaResult MiniMaxH3GenerateT2va(vt::Device device, const MiniMaxH3T2vaRequest& request,
+                                          const MiniMaxH3DitParams& dit_params,
+                                          const MiniMaxH3DitWeights& dit_weights,
+                                          const MiniMaxH3VideoVaeDecoderConfig& video_config,
+                                          const MiniMaxH3AudioVaeWeights& video_weights,
+                                          const MiniMaxH3AudioVaeConfig& audio_config,
+                                          const MiniMaxH3AudioVaeWeights& audio_weights,
+                                          const std::vector<float>& prompt_embeds,
+                                          const std::vector<float>& initial_video_rows,
+                                          const std::vector<float>& initial_audio_rows,
+                                          vt::DType compute_dtype,
+                                          const MiniMaxH3DitDeviceWeights* prestaged) {
+  const MiniMaxH3DenoiseResult denoised =
+      MiniMaxH3DenoiseT2va(device, request, dit_params, dit_weights, prompt_embeds,
+                           initial_video_rows, initial_audio_rows, compute_dtype, prestaged);
+
+  // --- 4. rows -> latents ---
+  const int64_t ph = request.latent_h / dit_params.patch_size_h;
+  const int64_t pw = request.latent_w / dit_params.patch_size_w;
+  std::vector<float> video_latent = MiniMaxH3UnpatchifyVideoTokens(
+      denoised.video_rows, request.latent_t, ph, pw, dit_params.latents_dim,
+      dit_params.patch_size_t, dit_params.patch_size_h, dit_params.patch_size_w);
+  std::vector<float> audio_latent = MiniMaxH3UnpackAudioTokens(
+      denoised.audio_rows, request.audio_t * request.audio_channel, request.audio_channel,
+      dit_params.audio_latents_dim);
+
+  // --- 5. denormalize (vae.py:252-270, :341-357) ---
+  auto denormalize = [](std::vector<float>& latent, int64_t channels, int64_t per_channel,
+                        const std::vector<float>& mean, const std::vector<float>& std_dev) {
+    if (mean.empty() && std_dev.empty()) return;
+    VT_CHECK(static_cast<int64_t>(mean.size()) == channels &&
+                 static_cast<int64_t>(std_dev.size()) == channels,
+             "minimax_h3 t2va: latents_mean/std must have one value per channel");
+    for (int64_t c = 0; c < channels; ++c) {
+      for (int64_t i = 0; i < per_channel; ++i) {
+        float& value = latent[static_cast<size_t>(c * per_channel + i)];
+        value = value * std_dev[static_cast<size_t>(c)] + mean[static_cast<size_t>(c)];
+      }
+    }
+  };
+  const int64_t video_per_channel = request.latent_t * request.latent_h * request.latent_w;
+  denormalize(video_latent, dit_params.latents_dim, video_per_channel, request.video_latents_mean,
+              request.video_latents_std);
+  const int64_t audio_steps = request.audio_t / request.audio_channel;
+  denormalize(audio_latent, dit_params.audio_latents_dim, audio_steps * request.audio_channel,
+              request.audio_latents_mean, request.audio_latents_std);
+
+  // --- 6. decode ---
+  MiniMaxH3T2vaResult result;
+  // post_quant_conv (the AutoencoderKL WRAPPER's Conv3d 1x1x1 channel mix) runs on
+  // the latent BEFORE the decoder. It sits OUTSIDE ViT3DDecoder, which is why the
+  // decoder's own 8.9e-8 gate never covered it. Applied only when the weights
+  // carry it, so a synthetic/reduced-dimension weight set without it still runs --
+  // the structural t2va test does not ship one.
+  if (video_weights.Has("post_quant_conv.weight")) {
+    video_latent = MiniMaxH3VideoVaePostQuantConv(video_weights, video_latent,
+                                                  dit_params.latents_dim, video_per_channel);
+  }
+  // On a device, run the ViT3D decoder device-resident. The portable decoder is a
+  // scalar reference; at real resolutions it is the stage that does not finish. It
+  // stays the CPU path, and stays the thing the device path is gated against.
+  if (device.type != vt::DeviceType::kCPU) {
+    vt::Queue vq = vt::GetBackend(device.type).CreateQueue();
+    const MiniMaxH3VideoVaeDeviceWeights staged_vae =
+        StageMiniMaxH3VideoVaeWeights(vq, video_config, video_weights);
+    // Upstream's video path is decode_base -> decode_temporal: chunked in TIME,
+    // and NOT spatially tiled (decoder_tiling defaults false and the shipped
+    // config does not set it).
+    result.frames = MiniMaxH3VideoVaeDecodeTemporalDevice(
+        device, video_config, staged_vae, video_latent, request.latent_t, request.latent_h,
+        request.latent_w, request.num_frames, &result.frame_shape);
+  } else {
+    result.frames = MiniMaxH3VideoVaeDecode(video_config, video_weights, video_latent,
+                                            request.latent_t, request.latent_h, request.latent_w,
+                                            &result.frame_shape);
+  }
+  // The ViT decoder emits IMAGENET-NORMALIZED values; the wrapper de-normalizes
+  // them (vae.py:693). Outside the decoder, so its own gate never covered it --
+  // the same shape of omission as post_quant_conv.
+  MiniMaxH3VideoDenormalizePixels(
+      result.frames, result.frame_shape.channels,
+      result.frame_shape.t * result.frame_shape.h * result.frame_shape.w);
+
+  // The audio VAE decodes ONE channel at a time; the packed rows are channel-major.
+  result.audio_channels = request.audio_channel;
+  for (int64_t c = 0; c < request.audio_channel; ++c) {
+    std::vector<float> channel(static_cast<size_t>(dit_params.audio_latents_dim * audio_steps));
+    for (int64_t d = 0; d < dit_params.audio_latents_dim; ++d) {
+      for (int64_t t = 0; t < audio_steps; ++t) {
+        channel[static_cast<size_t>(d * audio_steps + t)] = audio_latent[static_cast<size_t>(
+            (c * dit_params.audio_latents_dim + d) * audio_steps + t)];
+      }
+    }
+    int64_t samples = 0;
+    const std::vector<float> wave =
+        MiniMaxH3AudioVaeDecode(audio_config, audio_weights, channel, audio_steps, &samples);
+    if (c == 0) {
+      result.audio_samples_per_channel = samples;
+      result.waveform.reserve(static_cast<size_t>(samples * request.audio_channel));
+    } else {
+      VT_CHECK(samples == result.audio_samples_per_channel,
+               "minimax_h3 t2va: audio channels decoded to different lengths");
+    }
+    result.waveform.insert(result.waveform.end(), wave.begin(), wave.end());
+  }
+  result.sample_rate = kMiniMaxH3AudioSampleRate;
+  return result;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_planner.cpp b/src/vllm/model_executor/models/minimax_h3_planner.cpp
new file mode 100644
index 000000000..7afc353c5
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_planner.cpp
@@ -0,0 +1,282 @@
+// MiniMax-H3 request planning: frame/latent shapes, canvas resolution, task
+// dispatch, and the rectified-flow time-shifted sigma schedule.
+// Port of vllm-project/vllm-omni, vllm_omni/diffusion/models/minimax_h3/
+// time_request.py (whole file) and pipeline_minimax_h3.py:121-122, 207-222,
+// 374-434 (`_align_multiple`, `_reference_image_shape`, `_resolve_task`,
+// `_resolve_shape`).
+//
+// This is the "what does the request actually ask for" layer — the surface that
+// decides t2va vs fl2va vs ref2va, how many frames get generated, on what canvas,
+// and with which noise schedule. It is pure integer/float logic with no weights,
+// so unlike the rest of the H3 chain it is gated EXACTLY against upstream on any
+// machine (tests/vllm/models/test_minimax_h3.cpp).
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+// Python's round() is banker's rounding (round-half-to-even); C's round() is
+// half-away-from-zero. `_align_multiple` and `_audio_latent_t` both go through
+// Python's, so the difference is load-bearing at exact .5 boundaries.
+double RoundHalfToEven(double value) {
+  const double floor_value = std::floor(value);
+  const double diff = value - floor_value;
+  if (diff > 0.5) return floor_value + 1.0;
+  if (diff < 0.5) return floor_value;
+  return (std::fmod(floor_value, 2.0) == 0.0) ? floor_value : floor_value + 1.0;
+}
+
+std::string ToLower(const std::string& value) {
+  std::string out = value;
+  for (char& c : out) {
+    if (c >= 'A' && c <= 'Z') c = static_cast<char>(c - 'A' + 'a');
+  }
+  return out;
+}
+
+}  // namespace
+
+// _align_frame_count (time_request.py:5-12).
+int64_t MiniMaxH3AlignFrameCount(int64_t frame_count) {
+  if (frame_count <= 0) return 1;
+  int64_t current = frame_count;
+  while (current % 17 != 5) ++current;
+  return current;
+}
+
+// _video_latent_t (time_request.py:15-18).
+int64_t MiniMaxH3VideoLatentT(int64_t frame_count) {
+  if (frame_count <= 5) return 2;
+  return ((frame_count - 5) / 17) * 5 + 2;
+}
+
+// _frame_count_from_video_latent_t (time_request.py:21-26).
+int64_t MiniMaxH3FrameCountFromVideoLatentT(int64_t out_t) {
+  if (out_t == 1) return 1;
+  VT_CHECK(out_t >= 2 && (out_t - 2) % 5 == 0,
+           "minimax_h3: video latent T must be 1 or match 5n+2");
+  return 17 * ((out_t - 2) / 5) + 5;
+}
+
+// _audio_latent_t (time_request.py:29-31): the 40 Hz audio latent boundary.
+int64_t MiniMaxH3AudioLatentT(double duration_seconds) {
+  return static_cast<int64_t>(RoundHalfToEven(duration_seconds * 40.0));
+}
+
+// _align_multiple (pipeline_minimax_h3.py:121-122).
+int64_t MiniMaxH3AlignMultiple(double value, int64_t multiple) {
+  VT_CHECK(multiple > 0, "minimax_h3: align multiple must be positive");
+  const int64_t snapped =
+      static_cast<int64_t>(RoundHalfToEven(value / static_cast<double>(multiple))) * multiple;
+  return std::max(multiple, snapped);
+}
+
+// _reference_image_shape (pipeline_minimax_h3.py:207-222).
+std::pair<int64_t, int64_t> MiniMaxH3ReferenceImageShape(int64_t width, int64_t height) {
+  VT_CHECK(width > 0 && height > 0, "minimax_h3: reference image dims must be positive");
+  VT_CHECK(width <= 4 * height && height <= 4 * width,
+           "minimax_h3: reference image aspect ratio must be in [1:4, 4:1]");
+  const double scale = static_cast<double>(kMiniMaxH3ReferenceImageShortEdge) /
+                       static_cast<double>(std::min(width, height));
+  return {MiniMaxH3AlignMultiple(static_cast<double>(width) * scale,
+                                 kMiniMaxH3ReferenceImageMultiple),
+          MiniMaxH3AlignMultiple(static_cast<double>(height) * scale,
+                                 kMiniMaxH3ReferenceImageMultiple)};
+}
+
+// _time_shift_sigmas (time_request.py:34-61).
+std::vector<double> MiniMaxH3TimeShiftSigmas(int64_t num_steps, double shift_scale) {
+  VT_CHECK(shift_scale > 0.0, "minimax_h3: shift_scale must be > 0");
+  VT_CHECK(num_steps > 0, "minimax_h3: num_steps must be > 0");
+
+  // torch.linspace(1, 0, n) in FLOAT32 — the schedule is built at f32 upstream,
+  // and the shift is applied to those f32 values.
+  std::vector<float> base(static_cast<size_t>(num_steps));
+  if (num_steps == 1) {
+    base[0] = 1.0f;
+  } else {
+    const double step = 1.0 / static_cast<double>(num_steps - 1);
+    for (int64_t i = 0; i < num_steps; ++i) {
+      base[static_cast<size_t>(i)] = static_cast<float>(1.0 - static_cast<double>(i) * step);
+    }
+    // torch.linspace pins both endpoints exactly.
+    base[static_cast<size_t>(num_steps - 1)] = 0.0f;
+  }
+
+  std::vector<float> shifted(static_cast<size_t>(num_steps));
+  const float s = static_cast<float>(shift_scale);
+  for (int64_t i = 0; i < num_steps; ++i) {
+    const float b = base[static_cast<size_t>(i)];
+    shifted[static_cast<size_t>(i)] = s * b / (1.0f + (s - 1.0f) * b);
+  }
+
+  // torch.unique_consecutive: collapse RUNS of equal values (not a global unique).
+  std::vector<float> collapsed;
+  collapsed.reserve(shifted.size());
+  for (float value : shifted) {
+    if (collapsed.empty() || collapsed.back() != value) collapsed.push_back(value);
+  }
+  // A one-point request stays exactly one point; otherwise the schedule must end
+  // at sigma 0 so the terminal Euler step is the identity.
+  if (num_steps > 1 && collapsed.back() > 0.0f) collapsed.push_back(0.0f);
+
+  std::vector<double> out(collapsed.size());
+  for (size_t i = 0; i < collapsed.size(); ++i) out[i] = static_cast<double>(collapsed[i]);
+  return out;
+}
+
+// _resolve_task (pipeline_minimax_h3.py:374-391).
+std::string MiniMaxH3ResolveTask(const std::string& requested, const std::string& partition,
+                                 bool has_image,
+                                 const std::vector<std::string>& supported_tasks) {
+  std::string task = requested;
+  if (task.empty()) {
+    if (partition == "ref2va") {
+      task = "ref2va";
+    } else if (has_image) {
+      task = "fl2va";
+    } else {
+      task = "t2va";
+    }
+  }
+  task = ToLower(task);
+  VT_CHECK(std::find(supported_tasks.begin(), supported_tasks.end(), task) != supported_tasks.end(),
+           "minimax_h3: this checkpoint partition does not support the requested task");
+  return task;
+}
+
+// _resolve_shape (pipeline_minimax_h3.py:393-434).
+MiniMaxH3ShapePlan MiniMaxH3ResolveShape(const std::string& task, double duration_seconds,
+                                         int64_t requested_frames, int64_t height, int64_t width,
+                                         int64_t image_width, int64_t image_height) {
+  const double fps = static_cast<double>(kMiniMaxH3Fps);
+
+  int64_t frames = 0;
+  if (duration_seconds > 0.0) {
+    frames = static_cast<int64_t>(RoundHalfToEven(duration_seconds * fps));
+  } else if (requested_frames > 1) {
+    frames = requested_frames;
+  } else {
+    frames = task == "ref2va" ? kMiniMaxH3DefaultFramesRef2va : kMiniMaxH3DefaultFramesT2va;
+  }
+
+  MiniMaxH3ShapePlan plan;
+  plan.num_frames = MiniMaxH3AlignFrameCount(frames);
+
+  if (height <= 0 || width <= 0) {
+    // fl2va inherits the keyframe's aspect on a 768 short edge; everything else
+    // falls back to the shipped 768x1344 canvas.
+    if (task == "fl2va" && image_width > 0 && image_height > 0) {
+      const double ratio = static_cast<double>(image_width) / static_cast<double>(image_height);
+      if (ratio >= 1.0) {
+        height = 768;
+        width = MiniMaxH3AlignMultiple(768.0 * ratio, 32);
+      } else {
+        width = 768;
+        height = MiniMaxH3AlignMultiple(768.0 / ratio, 32);
+      }
+    } else {
+      height = 768;
+      width = 1344;
+    }
+  }
+  // Truncate (not round) onto the 32 grid.
+  plan.height = height / 32 * 32;
+  plan.width = width / 32 * 32;
+  VT_CHECK(plan.height > 0 && plan.width > 0, "minimax_h3: invalid canvas");
+  VT_CHECK(plan.width <= 4 * plan.height && plan.height <= 4 * plan.width,
+           "minimax_h3: canvas aspect ratio must be in [1:4, 4:1]");
+
+  plan.latent_t = MiniMaxH3VideoLatentT(plan.num_frames);
+  plan.audio_t = MiniMaxH3AudioLatentT(static_cast<double>(plan.num_frames) / fps);
+  return plan;
+}
+
+// ---------------------------------------------------------------------------
+// Reference-video input geometry + frame schedule (reference_video.py)
+//
+// Only the PURE-MATH half of that module is ported here. The rest of it — probe,
+// transcode, frame extraction, audio decode — shells out to ffmpeg/soundfile and
+// is blocked on the SAME external-dependency decision as `/v1/videos` MP4 muxing:
+// one decision unlocks both reference-video INPUT decode and generated-video
+// OUTPUT encode. Recorded in .agents/specs/minimax-h3.md section 5.2.
+// ---------------------------------------------------------------------------
+
+namespace {
+
+// _nearest_multiple (reference_video.py:24-26): round-half-to-even (Python's
+// round()), floored at one multiple.
+int64_t NearestMultiple(double value, int64_t multiple) {
+  const int64_t snapped =
+      static_cast<int64_t>(RoundHalfToEven(value / static_cast<double>(multiple))) * multiple;
+  return std::max(multiple, snapped);
+}
+
+}  // namespace
+
+// _reference_video_shape (reference_video.py:84-103). Returns {width, height}.
+std::pair<int64_t, int64_t> MiniMaxH3ReferenceVideoShape(int64_t width, int64_t height) {
+  VT_CHECK(width > 0 && height > 0, "minimax_h3 reference video: dims must be positive");
+  const double ratio = static_cast<double>(width) / static_cast<double>(height);
+  VT_CHECK(ratio >= 0.25 && ratio <= 4.0,
+           "minimax_h3 reference video: aspect ratio must be in [1:4, 4:1]");
+  double target_w, target_h;
+  if (ratio >= 1.0) {
+    target_w = static_cast<double>(kMiniMaxH3RefVideoShortEdge) * ratio;
+    target_h = static_cast<double>(kMiniMaxH3RefVideoShortEdge);
+  } else {
+    target_w = static_cast<double>(kMiniMaxH3RefVideoShortEdge);
+    target_h = static_cast<double>(kMiniMaxH3RefVideoShortEdge) / ratio;
+  }
+  const double area = target_w * target_h;
+  if (area > static_cast<double>(kMiniMaxH3RefVideoMaxPixels)) {
+    const double scale = std::sqrt(static_cast<double>(kMiniMaxH3RefVideoMaxPixels) / area);
+    target_w *= scale;
+    target_h *= scale;
+  }
+  return {NearestMultiple(target_w, kMiniMaxH3RefVideoCanvasMultiple),
+          NearestMultiple(target_h, kMiniMaxH3RefVideoCanvasMultiple)};
+}
+
+// The frame schedule (reference_video.py:208-220, 253-260): resample 24 FPS down
+// to the 2 FPS Qwen video sampling rate, dropping duplicate indices, then average
+// timestamps over each temporal patch (padding the tail by REPEATING the last).
+MiniMaxH3ReferenceVideoSchedule MiniMaxH3ReferenceVideoFrameSchedule(int64_t frame_count) {
+  VT_CHECK(frame_count > 0, "minimax_h3 reference video: frame_count must be positive");
+  MiniMaxH3ReferenceVideoSchedule out;
+  const double ratio =
+      static_cast<double>(kMiniMaxH3Fps) / static_cast<double>(kMiniMaxH3QwenVideoSampleFps);
+  double cursor = 0.0;
+  while (true) {
+    const int64_t frame_index = static_cast<int64_t>(RoundHalfToEven(cursor));
+    if (frame_index >= frame_count) break;
+    if (out.indices.empty() || frame_index > out.indices.back()) out.indices.push_back(frame_index);
+    cursor += ratio;
+  }
+  VT_CHECK(!out.indices.empty(), "minimax_h3 reference video: no frames sampled");
+
+  std::vector<double> timestamps;
+  timestamps.reserve(out.indices.size() + kMiniMaxH3QwenTemporalPatch);
+  for (size_t i = 0; i < out.indices.size(); ++i) {
+    timestamps.push_back(static_cast<double>(i) /
+                         static_cast<double>(kMiniMaxH3QwenVideoSampleFps));
+  }
+  const int64_t pad = (kMiniMaxH3QwenTemporalPatch -
+                       static_cast<int64_t>(timestamps.size()) % kMiniMaxH3QwenTemporalPatch) %
+                      kMiniMaxH3QwenTemporalPatch;
+  for (int64_t i = 0; i < pad; ++i) timestamps.push_back(timestamps.back());
+  for (size_t i = 0; i < timestamps.size(); i += static_cast<size_t>(kMiniMaxH3QwenTemporalPatch)) {
+    out.block_timestamps.push_back(
+        (timestamps[i] + timestamps[i + static_cast<size_t>(kMiniMaxH3QwenTemporalPatch) - 1]) / 2.0);
+  }
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_vae_cnn.cpp b/src/vllm/model_executor/models/minimax_h3_vae_cnn.cpp
new file mode 100644
index 000000000..548a52f8f
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_vae_cnn.cpp
@@ -0,0 +1,351 @@
+// MiniMax-H3 video-VAE 3D-CNN ENCODER primitives — causal Conv3d, GroupNorm, and
+// the ResnetBlock3D that is the repeated unit of the encoder stack.
+//
+// The video VAE's DECODER is a ViT (already ported); its ENCODER is this 3D CNN.
+// The encoder is needed for image/video CONDITIONING (fl2va keyframes, ref2va
+// references) — NOT for producing output frames, so a t2va path does not use it.
+//
+// Two details that are easy to get wrong and are gated here:
+//   * the convolution is CAUSAL IN TIME: all temporal padding goes on the LEFT
+//     (`padding[0] * 2` frames), none on the right, so a frame never sees the
+//     future. Spatial padding uses the checkpoint's `reflect` mode.
+//   * GroupNorm is 32 groups at eps 1e-6 over (C/32, T, H, W) — the statistics
+//     span TIME as well as space, which is why a per-frame normalization would
+//     silently differ.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+int64_t ReflectIndex(int64_t index, int64_t size) {
+  // torch's "reflect" padding excludes the edge sample: [a b c] -> b a b c b.
+  if (size == 1) return 0;
+  while (index < 0 || index >= size) {
+    if (index < 0) index = -index;
+    if (index >= size) index = 2 * (size - 1) - index;
+  }
+  return index;
+}
+
+}  // namespace
+
+// The same reflect rule the conv uses, needed by Downsample3D's asymmetric pad.
+int64_t ReflectIndexPublic(int64_t index, int64_t size) { return ReflectIndex(index, size); }
+
+// A causal 3D convolution with `reflect` spatial padding (conv.py:12-88).
+// Input/output are [C, T, H, W]; weight is [out, in, kt, kh, kw].
+std::vector<float> MiniMaxH3CausalConv3d(const std::vector<float>& in, const MiniMaxH3Conv3dSpec& spec,
+                                         const std::vector<float>& weight,
+                                         const std::vector<float>* bias) {
+  const int64_t ci = spec.in_channels, co = spec.out_channels;
+  const int64_t t = spec.t, h = spec.h, w = spec.w;
+  const int64_t kt = spec.kernel_t, kh = spec.kernel_h, kw = spec.kernel_w;
+  const int64_t pt = spec.pad_t, ph = spec.pad_h, pw = spec.pad_w;
+  VT_CHECK(static_cast<int64_t>(in.size()) == ci * t * h * w,
+           "minimax_h3 conv3d: input size does not match [C, T, H, W]");
+  VT_CHECK(static_cast<int64_t>(weight.size()) == co * ci * kt * kh * kw,
+           "minimax_h3 conv3d: weight size does not match the kernel");
+
+  // CAUSAL: 2*pad_t frames on the LEFT, none on the right (conv.py:40-51).
+  const int64_t pad_left_t = spec.causal ? pt * 2 : pt;
+  const int64_t pad_right_t = spec.causal ? 0 : pt;
+  const int64_t padded_t = t + pad_left_t + pad_right_t;
+  const int64_t padded_h = h + 2 * ph;
+  const int64_t padded_w = w + 2 * pw;
+
+  std::vector<float> padded(static_cast<size_t>(ci * padded_t * padded_h * padded_w), 0.0f);
+  for (int64_t c = 0; c < ci; ++c) {
+    for (int64_t pti = 0; pti < padded_t; ++pti) {
+      const int64_t src_t = pti - pad_left_t;
+      // Temporal padding is CONSTANT (zeros) in causal mode.
+      if (src_t < 0 || src_t >= t) continue;
+      for (int64_t phi = 0; phi < padded_h; ++phi) {
+        const int64_t src_h = ReflectIndex(phi - ph, h);
+        for (int64_t pwi = 0; pwi < padded_w; ++pwi) {
+          const int64_t src_w = ReflectIndex(pwi - pw, w);
+          padded[static_cast<size_t>(((c * padded_t + pti) * padded_h + phi) * padded_w + pwi)] =
+              in[static_cast<size_t>(((c * t + src_t) * h + src_h) * w + src_w)];
+        }
+      }
+    }
+  }
+
+  const int64_t out_t = (padded_t - kt) / spec.stride_t + 1;
+  const int64_t out_h = (padded_h - kh) / spec.stride_h + 1;
+  const int64_t out_w = (padded_w - kw) / spec.stride_w + 1;
+  VT_CHECK(out_t > 0 && out_h > 0 && out_w > 0, "minimax_h3 conv3d: empty output");
+  std::vector<float> out(static_cast<size_t>(co * out_t * out_h * out_w));
+  for (int64_t oc = 0; oc < co; ++oc) {
+    for (int64_t ot = 0; ot < out_t; ++ot) {
+      for (int64_t oh = 0; oh < out_h; ++oh) {
+        for (int64_t ow = 0; ow < out_w; ++ow) {
+          double acc = bias != nullptr ? (*bias)[static_cast<size_t>(oc)] : 0.0;
+          for (int64_t ic = 0; ic < ci; ++ic) {
+            for (int64_t a = 0; a < kt; ++a) {
+              for (int64_t b = 0; b < kh; ++b) {
+                for (int64_t c2 = 0; c2 < kw; ++c2) {
+                  const double v = padded[static_cast<size_t>(
+                      ((ic * padded_t + ot * spec.stride_t + a) * padded_h + oh * spec.stride_h + b) *
+                          padded_w +
+                      ow * spec.stride_w + c2)];
+                  const double k = weight[static_cast<size_t>(
+                      (((oc * ci + ic) * kt + a) * kh + b) * kw + c2)];
+                  acc += v * k;
+                }
+              }
+            }
+          }
+          out[static_cast<size_t>(((oc * out_t + ot) * out_h + oh) * out_w + ow)] =
+              static_cast<float>(acc);
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// GroupNorm over [C, T, H, W]: statistics span the group's channels AND all of
+// time and space (norm.py:342-357; 32 groups, eps 1e-6, affine).
+void MiniMaxH3GroupNorm3d(std::vector<float>& x, int64_t channels, int64_t spatial,
+                          int64_t num_groups, const std::vector<float>& weight,
+                          const std::vector<float>& bias, double eps) {
+  VT_CHECK(channels % num_groups == 0,
+           "minimax_h3 groupnorm: channels must be divisible by num_groups");
+  const int64_t per_group = channels / num_groups;
+  for (int64_t g = 0; g < num_groups; ++g) {
+    const int64_t begin = g * per_group;
+    double mean = 0.0;
+    const int64_t count = per_group * spatial;
+    for (int64_t c = begin; c < begin + per_group; ++c) {
+      for (int64_t i = 0; i < spatial; ++i) mean += x[static_cast<size_t>(c * spatial + i)];
+    }
+    mean /= static_cast<double>(count);
+    double var = 0.0;
+    for (int64_t c = begin; c < begin + per_group; ++c) {
+      for (int64_t i = 0; i < spatial; ++i) {
+        const double d = x[static_cast<size_t>(c * spatial + i)] - mean;
+        var += d * d;
+      }
+    }
+    var /= static_cast<double>(count);
+    const double inv = 1.0 / std::sqrt(var + eps);
+    for (int64_t c = begin; c < begin + per_group; ++c) {
+      for (int64_t i = 0; i < spatial; ++i) {
+        const double normed = (x[static_cast<size_t>(c * spatial + i)] - mean) * inv;
+        x[static_cast<size_t>(c * spatial + i)] = static_cast<float>(
+            normed * weight[static_cast<size_t>(c)] + bias[static_cast<size_t>(c)]);
+      }
+    }
+  }
+}
+
+// ResnetBlock3D (vae_cnn.py:83-171): norm -> SiLU -> conv -> norm -> SiLU -> conv,
+// plus a 1x1x1 `nin_shortcut` when the channel count changes.
+std::vector<float> MiniMaxH3ResnetBlock3dForward(const MiniMaxH3ResnetBlock3dConfig& config,
+                                                 const MiniMaxH3AudioVaeWeights& weights,
+                                                 const std::string& prefix,
+                                                 const std::vector<float>& x) {
+  const int64_t ci = config.in_channels, co = config.out_channels;
+  const int64_t t = config.t, h = config.h, w = config.w;
+  const int64_t spatial = t * h * w;
+  VT_CHECK(static_cast<int64_t>(x.size()) == ci * spatial,
+           "minimax_h3 resnet3d: input size does not match [C, T, H, W]");
+
+  auto conv_spec = [&](int64_t in_ch, int64_t out_ch, int64_t kernel, int64_t pad) {
+    MiniMaxH3Conv3dSpec spec;
+    spec.in_channels = in_ch;
+    spec.out_channels = out_ch;
+    spec.t = t;
+    spec.h = h;
+    spec.w = w;
+    spec.kernel_t = spec.kernel_h = spec.kernel_w = kernel;
+    spec.pad_t = spec.pad_h = spec.pad_w = pad;
+    spec.causal = true;
+    return spec;
+  };
+
+  std::vector<float> hbuf = x;
+  MiniMaxH3GroupNorm3d(hbuf, ci, spatial, config.num_groups, weights.Get(prefix + ".norm1.weight"),
+                       weights.Get(prefix + ".norm1.bias"), config.eps);
+  for (float& v : hbuf) v = v / (1.0f + std::exp(-v));  // SiLU
+  hbuf = MiniMaxH3CausalConv3d(hbuf, conv_spec(ci, co, 3, 1), weights.Get(prefix + ".conv1.weight"),
+                               &weights.Get(prefix + ".conv1.bias"));
+
+  MiniMaxH3GroupNorm3d(hbuf, co, spatial, config.num_groups, weights.Get(prefix + ".norm2.weight"),
+                       weights.Get(prefix + ".norm2.bias"), config.eps);
+  for (float& v : hbuf) v = v / (1.0f + std::exp(-v));
+  hbuf = MiniMaxH3CausalConv3d(hbuf, conv_spec(co, co, 3, 1), weights.Get(prefix + ".conv2.weight"),
+                               &weights.Get(prefix + ".conv2.bias"));
+
+  std::vector<float> residual = x;
+  if (ci != co) {
+    // A 1x1x1 conv with NO padding — the causal path is a no-op at pad 0.
+    residual = MiniMaxH3CausalConv3d(x, conv_spec(ci, co, 1, 0),
+                                     weights.Get(prefix + ".nin_shortcut.weight"),
+                                     &weights.Get(prefix + ".nin_shortcut.bias"));
+  }
+  VT_CHECK(residual.size() == hbuf.size(), "minimax_h3 resnet3d: residual and main-branch shapes must match");
+  for (size_t i = 0; i < hbuf.size(); ++i) hbuf[i] += residual[i];
+  return hbuf;
+}
+
+// Downsample3D (vae_cnn.py:34-81). When the spatial stride is 2 the input is
+// first padded by ONE on the RIGHT of W and the BOTTOM of H (an ASYMMETRIC pad,
+// `F.pad(x, (0,1,0,1,0,0))`), and only then convolved with padding (1, 0, 0).
+// Padding symmetrically instead shifts the whole sampling lattice by half a pixel.
+std::vector<float> MiniMaxH3Downsample3d(const std::vector<float>& x,
+                                         const MiniMaxH3Downsample3dConfig& config,
+                                         const std::vector<float>& weight,
+                                         const std::vector<float>& bias) {
+  VT_CHECK(config.time_stride == 1 || config.time_stride == 2,
+           "minimax_h3 downsample3d: time_stride must be 1 or 2");
+  VT_CHECK(config.space_stride >= 1 && config.space_stride <= 3,
+           "minimax_h3 downsample3d: space_stride must be 1, 2 or 3");
+
+  std::vector<float> input = x;
+  int64_t h = config.h, w = config.w;
+  if (config.space_stride == 2) {
+    const int64_t nh = h + 1, nw = w + 1;
+    std::vector<float> padded(static_cast<size_t>(config.in_channels * config.t * nh * nw), 0.0f);
+    for (int64_t c = 0; c < config.in_channels; ++c) {
+      for (int64_t ti = 0; ti < config.t; ++ti) {
+        for (int64_t hi = 0; hi < nh; ++hi) {
+          for (int64_t wi = 0; wi < nw; ++wi) {
+            // `reflect` on the added right/bottom edge, matching pad_mode.
+            const int64_t sh = hi < h ? hi : ReflectIndexPublic(hi, h);
+            const int64_t sw = wi < w ? wi : ReflectIndexPublic(wi, w);
+            padded[static_cast<size_t>(((c * config.t + ti) * nh + hi) * nw + wi)] =
+                x[static_cast<size_t>(((c * config.t + ti) * h + sh) * w + sw)];
+          }
+        }
+      }
+    }
+    input.swap(padded);
+    h = nh;
+    w = nw;
+  }
+
+  MiniMaxH3Conv3dSpec spec;
+  spec.in_channels = config.in_channels;
+  spec.out_channels = config.out_channels;
+  spec.t = config.t;
+  spec.h = h;
+  spec.w = w;
+  spec.kernel_t = spec.kernel_h = spec.kernel_w = 3;
+  spec.pad_t = 1;
+  spec.pad_h = spec.pad_w = 0;  // padding=(1, 0, 0)
+  spec.stride_t = config.time_stride;
+  spec.stride_h = spec.stride_w = config.space_stride;
+  spec.causal = true;
+  return MiniMaxH3CausalConv3d(input, spec, weight, &bias);
+}
+
+// EncoderFCN3D (vae_cnn.py:177-297): conv_in -> per level [N x ResnetBlock3D,
+// then an optional Downsample3D or a 1x1x1 channel-matching conv] -> GroupNorm ->
+// SiLU -> conv_out. Channel plan per level i:
+//   block_mid[i] = ch * ch_mult[i];  block_in[0] = block_mid[0];
+//   block_in[i>0] = block_mid[i-1];  block_out[i] = block_mid[i].
+// A level gets a Downsample3D when space_down[i]*time_down[i] > 1; otherwise it
+// gets a 1x1x1 conv ONLY if its output channel count differs, and nothing at all
+// when it does not.
+std::vector<float> MiniMaxH3EncoderFcn3dForward(const MiniMaxH3EncoderFcn3dConfig& config,
+                                                const MiniMaxH3AudioVaeWeights& weights,
+                                                const std::vector<float>& x,
+                                                MiniMaxH3VideoFrameShape* out_shape) {
+  const int64_t levels = static_cast<int64_t>(config.ch_mult.size());
+  VT_CHECK(levels > 0, "minimax_h3 encoder3d: ch_mult must not be empty");
+  VT_CHECK(static_cast<int64_t>(config.space_down.size()) == levels &&
+               static_cast<int64_t>(config.time_down.size()) == levels,
+           "minimax_h3 encoder3d: space_down/time_down must match ch_mult");
+
+  std::vector<int64_t> block_mid(static_cast<size_t>(levels));
+  for (int64_t i = 0; i < levels; ++i) block_mid[static_cast<size_t>(i)] = config.ch * config.ch_mult[static_cast<size_t>(i)];
+  std::vector<int64_t> block_in(static_cast<size_t>(levels));
+  block_in[0] = block_mid[0];
+  for (int64_t i = 1; i < levels; ++i) block_in[static_cast<size_t>(i)] = block_mid[static_cast<size_t>(i - 1)];
+
+  int64_t t = config.t, h = config.h, w = config.w;
+  auto conv_spec = [&](int64_t in_ch, int64_t out_ch, int64_t kernel, int64_t pad) {
+    MiniMaxH3Conv3dSpec spec;
+    spec.in_channels = in_ch;
+    spec.out_channels = out_ch;
+    spec.t = t;
+    spec.h = h;
+    spec.w = w;
+    spec.kernel_t = spec.kernel_h = spec.kernel_w = kernel;
+    spec.pad_t = spec.pad_h = spec.pad_w = pad;
+    spec.causal = true;
+    return spec;
+  };
+
+  std::vector<float> hbuf =
+      MiniMaxH3CausalConv3d(x, conv_spec(config.in_channels, block_in[0], 3, 1),
+                            weights.Get("conv_in.weight"), &weights.Get("conv_in.bias"));
+  int64_t channels = block_in[0];
+
+  for (int64_t level = 0; level < levels; ++level) {
+    for (int64_t b = 0; b < config.num_res_blocks; ++b) {
+      MiniMaxH3ResnetBlock3dConfig block;
+      block.in_channels = (b == 0) ? block_in[static_cast<size_t>(level)]
+                                   : block_mid[static_cast<size_t>(level)];
+      block.out_channels = block_mid[static_cast<size_t>(level)];
+      block.t = t;
+      block.h = h;
+      block.w = w;
+      block.num_groups = config.num_groups;
+      block.eps = config.eps;
+      hbuf = MiniMaxH3ResnetBlock3dForward(
+          block, weights,
+          "down." + std::to_string(level) + ".block." + std::to_string(b), hbuf);
+      channels = block.out_channels;
+    }
+
+    const int64_t sd = config.space_down[static_cast<size_t>(level)];
+    const int64_t td = config.time_down[static_cast<size_t>(level)];
+    const std::string prefix = "down." + std::to_string(level) + ".downsample";
+    if (sd * td > 1) {
+      MiniMaxH3Downsample3dConfig down;
+      down.in_channels = channels;
+      down.out_channels = block_mid[static_cast<size_t>(level)];
+      down.t = t;
+      down.h = h;
+      down.w = w;
+      down.time_stride = td;
+      down.space_stride = sd;
+      hbuf = MiniMaxH3Downsample3d(hbuf, down, weights.Get(prefix + ".conv.weight"),
+                                   weights.Get(prefix + ".conv.bias"));
+      // The causal temporal pad means T shrinks by the stride like H and W do.
+      t = (t + 2 - 3) / td + 1;
+      h = (h + 1 - 3) / sd + 1;
+      w = (w + 1 - 3) / sd + 1;
+      channels = down.out_channels;
+    } else if (block_mid[static_cast<size_t>(level)] != channels) {
+      hbuf = MiniMaxH3CausalConv3d(hbuf, conv_spec(channels, block_mid[static_cast<size_t>(level)], 1, 0),
+                                   weights.Get(prefix + ".weight"), &weights.Get(prefix + ".bias"));
+      channels = block_mid[static_cast<size_t>(level)];
+    }
+  }
+
+  MiniMaxH3GroupNorm3d(hbuf, channels, t * h * w, config.num_groups,
+                       weights.Get("norm_out.weight"), weights.Get("norm_out.bias"), config.eps);
+  for (float& v : hbuf) v = v / (1.0f + std::exp(-v));
+  hbuf = MiniMaxH3CausalConv3d(hbuf, conv_spec(channels, config.z_channels, 3, 1),
+                               weights.Get("conv_out.weight"), &weights.Get("conv_out.bias"));
+  if (out_shape != nullptr) {
+    out_shape->channels = config.z_channels;
+    out_shape->t = t;
+    out_shape->h = h;
+    out_shape->w = w;
+  }
+  return hbuf;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_vae_loader.cpp b/src/vllm/model_executor/models/minimax_h3_vae_loader.cpp
new file mode 100644
index 000000000..2f66f0cb5
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_vae_loader.cpp
@@ -0,0 +1,553 @@
+// MiniMax-H3 VAE checkpoint loaders — materializing the shipped safetensors files
+// into the weight structs the (already gated) VAE forwards consume.
+//
+// The forwards were gated against the checkpoint's OWN remote code at reduced
+// dimensions, with weights rebuilt from the shared PRNG. That proved the MATH.
+// What it could not prove is that the SHIPPED file's tensors bind onto those
+// structs — and for the audio VAE they do not, not directly. Both mismatches were
+// found by reading the real 1087-tensor header (an HTTP range request over the
+// file's first 2 MiB, no payload downloaded) and are gated against it:
+//
+//   1. WEIGHT-NORM SPELLING. The checkpoint ships torch's LEGACY weight_norm pair
+//      `weight_g` / `weight_v`. The decoder reads the PARAMETRIZATION spelling
+//      `parametrizations.weight.original0` / `original1`, because the generator
+//      that produced its goldens ran the checkpoint's remote code under a modern
+//      torch, where weight_norm is a parametrization. Same tensors, different era.
+//   2. PREFIX. Every BigVGAN tensor lives under `decoder.`, but `dec_in_proj.*` —
+//      the Conv1d that runs BEFORE BigVGAN — sits at the top level.
+//
+// Either mismatch alone yields a loader that throws by name (best case) or, if a
+// future refactor made lookups lenient, a decoder reading zeros. The mapping is
+// therefore asserted against the real manifest in the test, not just exercised.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <map>
+#include <utility>
+#include <string>
+#include <vector>
+
+#include "vllm/model_executor/model_loader/safetensors_reader.h"
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+float Bf16ToF32(uint16_t bits) {
+  const uint32_t widened = static_cast<uint32_t>(bits) << 16;
+  float out;
+  std::memcpy(&out, &widened, sizeof(out));
+  return out;
+}
+
+float F16ToF32(uint16_t bits) {
+  const uint32_t sign = static_cast<uint32_t>(bits & 0x8000u) << 16;
+  const uint32_t exp = (bits >> 10) & 0x1Fu;
+  const uint32_t mant = bits & 0x3FFu;
+  uint32_t out_bits;
+  if (exp == 0) {
+    if (mant == 0) {
+      out_bits = sign;  // +/- zero
+    } else {
+      // Subnormal: renormalize into the f32 exponent range.
+      uint32_t e = 0;
+      uint32_t m = mant;
+      while ((m & 0x400u) == 0) {
+        m <<= 1;
+        ++e;
+      }
+      m &= 0x3FFu;
+      out_bits = sign | ((127 - 15 - e) << 23) | (m << 13);
+    }
+  } else if (exp == 0x1Fu) {
+    out_bits = sign | 0x7F800000u | (mant << 13);  // inf / nan
+  } else {
+    out_bits = sign | ((exp - 15 + 127) << 23) | (mant << 13);
+  }
+  float out;
+  std::memcpy(&out, &out_bits, sizeof(out));
+  return out;
+}
+
+}  // namespace
+
+std::vector<float> MiniMaxH3ReadSafetensorF32(const StTensor& tensor) {
+  int64_t numel = 1;
+  for (int64_t d : tensor.shape) numel *= d;
+  std::vector<float> out(static_cast<size_t>(numel));
+  if (tensor.dtype == "F32") {
+    VT_CHECK(tensor.nbytes == static_cast<size_t>(numel) * 4,
+             "minimax_h3: F32 tensor span does not match its shape");
+    std::memcpy(out.data(), tensor.data, tensor.nbytes);
+  } else if (tensor.dtype == "BF16") {
+    VT_CHECK(tensor.nbytes == static_cast<size_t>(numel) * 2,
+             "minimax_h3: BF16 tensor span does not match its shape");
+    const uint16_t* src = reinterpret_cast<const uint16_t*>(tensor.data);
+    for (int64_t i = 0; i < numel; ++i) out[static_cast<size_t>(i)] = Bf16ToF32(src[i]);
+  } else if (tensor.dtype == "F16") {
+    VT_CHECK(tensor.nbytes == static_cast<size_t>(numel) * 2,
+             "minimax_h3: F16 tensor span does not match its shape");
+    const uint16_t* src = reinterpret_cast<const uint16_t*>(tensor.data);
+    for (int64_t i = 0; i < numel; ++i) out[static_cast<size_t>(i)] = F16ToF32(src[i]);
+  } else {
+    VT_CHECK(false, "minimax_h3: unsupported tensor dtype (expected F32/BF16/F16)");
+  }
+  return out;
+}
+
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3AudioVaeWeights(const SafetensorsFile& file) {
+  MiniMaxH3AudioVaeWeights out;
+  for (const std::string& name : file.Names()) {
+    // The audio ENCODER shares this file, as do the VAE's mean/logvar heads and
+    // pre_block in repackaged copies. Generation only decodes, so none are loaded.
+    if (name.rfind("encoder.", 0) == 0) continue;
+    if (name.rfind("mean_proj.", 0) == 0 || name.rfind("logs_proj.", 0) == 0) continue;
+    if (name.rfind("pre_block.", 0) == 0) continue;
+
+    std::string key = name;
+    if (key.rfind("decoder.", 0) == 0) key = key.substr(std::strlen("decoder."));
+
+    // The kaiser-sinc anti-aliasing filters are COMPUTED at load
+    // (MiniMaxH3KaiserSincFilter1d), never read.
+    if (key.size() >= 7 && key.compare(key.size() - 7, 7, ".filter") == 0) continue;
+
+    const StTensor& tensor = file.Get(name);
+
+    // --- the three weight-norm spellings this decoder must accept ---
+    // (1) LEGACY  `weight_g` / `weight_v`  — the OFFICIAL MiniMax-H3 checkpoint.
+    // (2) MODERN  `parametrizations.weight.original0/1` — what the decoder reads,
+    //     and what the generator produced (it ran the remote code under a torch
+    //     where weight_norm is a parametrization).
+    // (3) MATERIALIZED plain `weight` — repackaged community bundles, which folded
+    //     the norm at conversion time.
+    const std::string g = ".weight_g", v = ".weight_v";
+    if (key.size() > g.size() && key.compare(key.size() - g.size(), g.size(), g) == 0) {
+      key = key.substr(0, key.size() - g.size()) + ".parametrizations.weight.original0";
+    } else if (key.size() > v.size() && key.compare(key.size() - v.size(), v.size(), v) == 0) {
+      key = key.substr(0, key.size() - v.size()) + ".parametrizations.weight.original1";
+    } else if (key.size() > 7 && key.compare(key.size() - 7, 7, ".weight") == 0 &&
+               key != "dec_in_proj.weight" && tensor.shape.size() == 3) {
+      // (3) Reconstruct an EXACT pair rather than an approximate one: with v = w and
+      // g = per-dim-0-slice ||w||, the decoder's own g * v / ||v|| returns w.
+      // dec_in_proj is a PLAIN Conv1d (not weight-normalized), so it is excluded.
+      const std::string base = key.substr(0, key.size() - 7);
+      std::vector<float> w = MiniMaxH3ReadSafetensorF32(tensor);
+      const int64_t rows = tensor.shape[0];
+      VT_CHECK(rows > 0 && static_cast<int64_t>(w.size()) % rows == 0,
+               "minimax_h3 audio vae: materialized conv weight has an implausible shape");
+      const int64_t per_row = static_cast<int64_t>(w.size()) / rows;
+      std::vector<float> mag(static_cast<size_t>(rows));
+      for (int64_t r = 0; r < rows; ++r) {
+        double sum = 0.0;
+        for (int64_t i = 0; i < per_row; ++i) {
+          const double e = w[static_cast<size_t>(r * per_row + i)];
+          sum += e * e;
+        }
+        mag[static_cast<size_t>(r)] = static_cast<float>(std::sqrt(sum));
+      }
+      VT_CHECK(out.tensors.count(base + ".parametrizations.weight.original1") == 0,
+               "minimax_h3 audio vae: two checkpoint tensors map to the same name");
+      out.tensors[base + ".parametrizations.weight.original1"] = std::move(w);
+      out.tensors[base + ".parametrizations.weight.original0"] = std::move(mag);
+      continue;
+    }
+
+    VT_CHECK(out.tensors.count(key) == 0,
+             "minimax_h3 audio vae: two checkpoint tensors map to the same name");
+    out.tensors[key] = MiniMaxH3ReadSafetensorF32(tensor);
+  }
+  VT_CHECK(!out.tensors.empty(), "minimax_h3 audio vae: checkpoint contained no decoder tensors");
+  return out;
+}
+
+// The ENCODER half of the SAME audio-VAE file — the half the decoder loader above
+// skips outright. ref2va needs it: an audio reference is a waveform, and the rows
+// the DiT is conditioned on come out of this stack.
+//
+// It carries the decoder loader's rules over unchanged, because the file is the
+// same file:
+//   * PREFIX. The DAC encoder is under `encoder.`, stripped so the forward reads
+//     bare `block.N...`. `pre_block.*` and `mean_proj.*` sit at the TOP level and
+//     are kept verbatim — the same split `dec_in_proj` has on the decoder side.
+//   * WEIGHT-NORM SPELLING. All three: legacy `weight_g`/`weight_v` (what the
+//     official checkpoint ships), the modern `parametrizations.weight.originalN`
+//     (what the forward reads, and what a modern-torch generator produces), and a
+//     plain MATERIALIZED `weight` (repackaged bundles).
+//
+// `logs_proj.*` is deliberately NOT loaded. Conditioning takes the distribution
+// MEAN; carrying the log-variance head would imply something is sampled, and a
+// sampled reference would condition differently on every run. `decoder.*` and
+// `dec_in_proj.*` are the synthesis half and are skipped.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3AudioVaeEncoderWeights(const SafetensorsFile& file) {
+  MiniMaxH3AudioVaeWeights out;
+  for (const std::string& name : file.Names()) {
+    const bool is_encoder = name.rfind("encoder.", 0) == 0;
+    const bool is_pre_block = name.rfind("pre_block.", 0) == 0;
+    const bool is_mean = name.rfind("mean_proj.", 0) == 0;
+    if (!is_encoder && !is_pre_block && !is_mean) continue;
+
+    std::string key = name;
+    if (is_encoder) key = key.substr(std::strlen("encoder."));
+
+    const StTensor& tensor = file.Get(name);
+
+    // `mean_proj` and every `pre_block` Linear are PLAIN modules, so their bare
+    // `.weight` must NOT be reinterpreted as a materialized weight-norm pair. Only
+    // the encoder's own convs are weight-normalized.
+    const std::string g = ".weight_g", v = ".weight_v";
+    if (key.size() > g.size() && key.compare(key.size() - g.size(), g.size(), g) == 0) {
+      key = key.substr(0, key.size() - g.size()) + ".parametrizations.weight.original0";
+    } else if (key.size() > v.size() && key.compare(key.size() - v.size(), v.size(), v) == 0) {
+      key = key.substr(0, key.size() - v.size()) + ".parametrizations.weight.original1";
+    } else if (is_encoder && key.size() > 7 && key.compare(key.size() - 7, 7, ".weight") == 0 &&
+               tensor.shape.size() == 3) {
+      // Reconstruct an EXACT (g, v) pair: with v = w and g = per-output-channel
+      // ||w||, the forward's own g * v / ||v|| returns w.
+      const std::string base = key.substr(0, key.size() - 7);
+      std::vector<float> w = MiniMaxH3ReadSafetensorF32(tensor);
+      const int64_t rows = tensor.shape[0];
+      VT_CHECK(rows > 0 && static_cast<int64_t>(w.size()) % rows == 0,
+               "minimax_h3 audio encoder: materialized conv weight has an implausible shape");
+      const int64_t per_row = static_cast<int64_t>(w.size()) / rows;
+      std::vector<float> mag(static_cast<size_t>(rows));
+      for (int64_t r = 0; r < rows; ++r) {
+        double sum = 0.0;
+        for (int64_t i = 0; i < per_row; ++i) {
+          const double e = w[static_cast<size_t>(r * per_row + i)];
+          sum += e * e;
+        }
+        mag[static_cast<size_t>(r)] = static_cast<float>(std::sqrt(sum));
+      }
+      VT_CHECK(out.tensors.count(base + ".parametrizations.weight.original1") == 0,
+               "minimax_h3 audio encoder: two checkpoint tensors map to the same name");
+      out.tensors[base + ".parametrizations.weight.original1"] = std::move(w);
+      out.tensors[base + ".parametrizations.weight.original0"] = std::move(mag);
+      continue;
+    }
+
+    VT_CHECK(out.tensors.count(key) == 0,
+             "minimax_h3 audio encoder: two checkpoint tensors map to the same name");
+    out.tensors[key] = MiniMaxH3ReadSafetensorF32(tensor);
+  }
+  VT_CHECK(out.tensors.count("block.0.parametrizations.weight.original1") != 0,
+           "minimax_h3 audio encoder: checkpoint contained no encoder tensors");
+  VT_CHECK(out.tensors.count("mean_proj.weight") != 0,
+           "minimax_h3 audio encoder: checkpoint is missing mean_proj (the latent MEAN head)");
+  return out;
+}
+
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3VideoVaeDecoderWeights(const SafetensorsFile& file) {
+  MiniMaxH3AudioVaeWeights out;
+  for (const std::string& name : file.Names()) {
+    // The 3D-CNN ENCODER shares this file (conditioning only), and `quant_conv`
+    // is its output stage. Generation decodes, so neither is loaded.
+    if (name.rfind("encoder.", 0) == 0) continue;
+    if (name.rfind("quant_conv.", 0) == 0) continue;
+
+    std::string key = name;
+    if (key.rfind("decoder.", 0) == 0) key = key.substr(std::strlen("decoder."));
+    VT_CHECK(out.tensors.count(key) == 0,
+             "minimax_h3 video vae: two checkpoint tensors map to the same name");
+    out.tensors[key] = MiniMaxH3ReadSafetensorF32(file.Get(name));
+  }
+  VT_CHECK(!out.tensors.empty(), "minimax_h3 video vae: checkpoint contained no decoder tensors");
+  return out;
+}
+
+// The ENCODER half of the same file — the piece the decoder loader deliberately
+// skips. Needed for CONDITIONING (fl2va keyframes, ref2va references): turning a
+// supplied image or clip into the latent the DiT is conditioned on.
+//
+// Mirrors the decoder loader's one mapping rule in reverse: strip `encoder.`,
+// because MiniMaxH3EncoderFcn3dForward reads bare names (`conv_in.weight`,
+// `down.N.block.M...`). `quant_conv` IS kept — it is the encoder's output stage,
+// projecting conv_out's 48 channels to the 48 that split into mean|logvar.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3VideoVaeEncoderWeights(const SafetensorsFile& file) {
+  MiniMaxH3AudioVaeWeights out;
+  for (const std::string& name : file.Names()) {
+    const bool is_encoder = name.rfind("encoder.", 0) == 0;
+    const bool is_quant = name.rfind("quant_conv.", 0) == 0;
+    if (!is_encoder && !is_quant) continue;  // the ViT decoder half
+    std::string key = name;
+    if (is_encoder) key = key.substr(std::strlen("encoder."));
+    VT_CHECK(out.tensors.count(key) == 0,
+             "minimax_h3 video vae encoder: two checkpoint tensors map to the same name");
+    out.tensors[key] = MiniMaxH3ReadSafetensorF32(file.Get(name));
+  }
+  VT_CHECK(!out.tensors.empty(),
+           "minimax_h3 video vae: checkpoint contained no encoder tensors");
+  return out;
+}
+
+// Encode frames [in_channels, T, H, W] in [-1, 1] to the conditioning latent.
+//
+// The 3D CNN emits 2*z_channels (mean | logvar); `quant_conv` mixes those 48
+// channels, and conditioning takes the DISTRIBUTION MEAN rather than a sample --
+// a sample would make the same reference image produce a different conditioning
+// on every run, which is not what a reference is for.
+std::vector<float> MiniMaxH3VideoVaeEncodeToLatent(const MiniMaxH3EncoderFcn3dConfig& config,
+                                                   const MiniMaxH3AudioVaeWeights& weights,
+                                                   const std::vector<float>& frames,
+                                                   MiniMaxH3VideoFrameShape* out_shape) {
+  MiniMaxH3VideoFrameShape shape{};
+  std::vector<float> moments = MiniMaxH3EncoderFcn3dForward(config, weights, frames, &shape);
+  // `z_channels` is the MOMENTS width, not the latent width: the encoder's final
+  // conv emits it directly, and the real checkpoint has conv_out -> 48 with a
+  // 24-channel latent. So the latent is half of it (mean | logvar).
+  const int64_t two_z = config.z_channels;
+  VT_CHECK(two_z % 2 == 0,
+           "minimax_h3 vae encode: z_channels must be even (it carries mean|logvar)");
+  const int64_t latent_ch = two_z / 2;
+  const int64_t per_channel = shape.t * shape.h * shape.w;
+  VT_CHECK(static_cast<int64_t>(moments.size()) == two_z * per_channel,
+           "minimax_h3 vae encode: encoder output is not [2 * z_channels, T, H, W]");
+
+  // quant_conv: a 1x1x1 Conv3d over the 2*z channels, same shape as the decoder's
+  // post_quant_conv but on the encoder side.
+  if (weights.Has("quant_conv.weight")) {
+    const std::vector<float>& w = weights.Get("quant_conv.weight");
+    const std::vector<float>& b = weights.Get("quant_conv.bias");
+    VT_CHECK(static_cast<int64_t>(w.size()) == two_z * two_z &&
+                 static_cast<int64_t>(b.size()) == two_z,
+             "minimax_h3 vae encode: quant_conv must be [2Z, 2Z, 1, 1, 1] with a 2Z bias");
+    std::vector<float> mixed(moments.size());
+    for (int64_t o = 0; o < two_z; ++o) {
+      for (int64_t p = 0; p < per_channel; ++p) {
+        double acc = b[static_cast<size_t>(o)];
+        for (int64_t i = 0; i < two_z; ++i) {
+          acc += static_cast<double>(w[static_cast<size_t>(o * two_z + i)]) *
+                 moments[static_cast<size_t>(i * per_channel + p)];
+        }
+        mixed[static_cast<size_t>(o * per_channel + p)] = static_cast<float>(acc);
+      }
+    }
+    moments = std::move(mixed);
+  }
+
+  // DiagonalGaussianDistribution.mean == the first half of the moments.
+  std::vector<float> latent(static_cast<size_t>(latent_ch * per_channel));
+  std::copy(moments.begin(), moments.begin() + latent.size(), latent.begin());
+  if (out_shape != nullptr) *out_shape = shape;
+  return latent;
+}
+
+std::vector<float> MiniMaxH3VideoVaePostQuantConv(const MiniMaxH3AudioVaeWeights& weights,
+                                                  const std::vector<float>& latent,
+                                                  int64_t channels, int64_t elems_per_channel) {
+  const std::vector<float>& w = weights.Get("post_quant_conv.weight");
+  const std::vector<float>& b = weights.Get("post_quant_conv.bias");
+  VT_CHECK(static_cast<int64_t>(w.size()) == channels * channels,
+           "minimax_h3 post_quant_conv: weight must be [C, C, 1, 1, 1]");
+  VT_CHECK(static_cast<int64_t>(b.size()) == channels,
+           "minimax_h3 post_quant_conv: bias must have one value per channel");
+  VT_CHECK(static_cast<int64_t>(latent.size()) == channels * elems_per_channel,
+           "minimax_h3 post_quant_conv: latent size does not match [C, ...]");
+
+  // A 1x1x1 Conv3d over a CHANNEL-MAJOR latent: out[o, p] = sum_i w[o, i] * in[i, p]
+  // + b[o]. The accumulation is f32 in input-channel order, matching torch's
+  // contraction over a length-C reduction.
+  std::vector<float> out(latent.size());
+  for (int64_t o = 0; o < channels; ++o) {
+    const float bias = b[static_cast<size_t>(o)];
+    float* dst = out.data() + o * elems_per_channel;
+    for (int64_t p = 0; p < elems_per_channel; ++p) dst[p] = bias;
+    for (int64_t i = 0; i < channels; ++i) {
+      const float coeff = w[static_cast<size_t>(o * channels + i)];
+      const float* src = latent.data() + i * elems_per_channel;
+      for (int64_t p = 0; p < elems_per_channel; ++p) dst[p] += coeff * src[p];
+    }
+  }
+  return out;
+}
+
+
+// --- H3-Encoder (FL2VA/text_encoder) ---------------------------------------
+// The one loader that TRANSFORMS rather than renames: HF ships q/k/v and gate/up
+// SEPARATE, the port (like vLLM) consumes them FUSED. Row-concatenation order is
+// load-bearing — the forward slices qkv_proj at [0, q_width), [q_width,
+// q_width+kv_width), [q_width+kv_width, ...), so any other order silently feeds
+// keys into the query path.
+MiniMaxH3AudioVaeWeights LoadMiniMaxH3EncoderWeights(const std::vector<SafetensorsFile>& shards,
+                                                     int64_t max_layers) {
+  // One index over every shard, so a tensor is found wherever it lives.
+  std::map<std::string, std::pair<size_t, const StTensor*>> index;
+  for (size_t s = 0; s < shards.size(); ++s) {
+    for (const std::string& name : shards[s].Names()) {
+      VT_CHECK(index.count(name) == 0, "minimax_h3 encoder: tensor appears in two shards");
+      index.emplace(name, std::make_pair(s, &shards[s].Get(name)));
+    }
+  }
+  VT_CHECK(!index.empty(), "minimax_h3 encoder: no shards contained any tensor");
+
+  MiniMaxH3AudioVaeWeights out;
+  auto read = [&](const std::string& name) -> std::vector<float> {
+    const auto it = index.find(name);
+    VT_CHECK(it != index.end(), "minimax_h3 encoder: checkpoint is missing a required tensor");
+    return MiniMaxH3ReadSafetensorF32(*it->second.second);
+  };
+  auto has = [&](const std::string& name) { return index.count(name) != 0; };
+
+  const std::string lm = "model.language_model.";
+  const std::string vis = "model.visual.";
+
+  // --- text tower: strip the prefix, FUSE q/k/v and gate/up ---
+  for (int64_t layer = 0;; ++layer) {
+    const std::string src = lm + "layers." + std::to_string(layer) + ".";
+    if (!has(src + "input_layernorm.weight")) break;
+    if (max_layers > 0 && layer >= max_layers) break;
+    const std::string dst = "layers." + std::to_string(layer) + ".";
+
+    out.tensors[dst + "input_layernorm.weight"] = read(src + "input_layernorm.weight");
+    out.tensors[dst + "post_attention_layernorm.weight"] =
+        read(src + "post_attention_layernorm.weight");
+    out.tensors[dst + "self_attn.q_norm.weight"] = read(src + "self_attn.q_norm.weight");
+    out.tensors[dst + "self_attn.k_norm.weight"] = read(src + "self_attn.k_norm.weight");
+    out.tensors[dst + "self_attn.o_proj.weight"] = read(src + "self_attn.o_proj.weight");
+    out.tensors[dst + "mlp.down_proj.weight"] = read(src + "mlp.down_proj.weight");
+
+    // [q_all | k_all | v_all], the order the forward slices.
+    std::vector<float> q = read(src + "self_attn.q_proj.weight");
+    const std::vector<float> k = read(src + "self_attn.k_proj.weight");
+    const std::vector<float> v = read(src + "self_attn.v_proj.weight");
+    q.reserve(q.size() + k.size() + v.size());
+    q.insert(q.end(), k.begin(), k.end());
+    q.insert(q.end(), v.begin(), v.end());
+    out.tensors[dst + "self_attn.qkv_proj.weight"] = std::move(q);
+
+    // [gate | up], matching MergedColumnParallelLinear.
+    std::vector<float> gate = read(src + "mlp.gate_proj.weight");
+    const std::vector<float> up = read(src + "mlp.up_proj.weight");
+    gate.reserve(gate.size() + up.size());
+    gate.insert(gate.end(), up.begin(), up.end());
+    out.tensors[dst + "mlp.gate_up_proj.weight"] = std::move(gate);
+  }
+  VT_CHECK(out.tensors.count("layers.0.self_attn.qkv_proj.weight") != 0,
+           "minimax_h3 encoder: no text-tower layers were loaded");
+
+  if (has(lm + "embed_tokens.weight")) {
+    // Kept: the text forward takes inputs_embeds, so a caller needs this to embed.
+    out.tensors["embed_tokens.weight"] = read(lm + "embed_tokens.weight");
+  }
+  // `model.language_model.norm.weight` is deliberately NOT loaded — H3 reads the
+  // UNNORMALIZED truncated output, and carrying the tensor would imply otherwise.
+
+  // --- vision tower: prefix strip only; HF already ships qkv fused ---
+  for (const auto& kv : index) {
+    const std::string& name = kv.first;
+    if (name.rfind(vis, 0) != 0) continue;
+    const std::string dst = name.substr(vis.size());
+    VT_CHECK(out.tensors.count(dst) == 0, "minimax_h3 encoder: vision name collides");
+    out.tensors[dst] = MiniMaxH3ReadSafetensorF32(*kv.second.second);
+  }
+  return out;
+}
+
+
+// --- config.json parsing ----------------------------------------------------
+namespace {
+
+void ReadStats(const nlohmann::json& config, MiniMaxH3LatentStats* stats) {
+  if (stats == nullptr) return;
+  auto read = [&](const char* key, std::vector<float>& into) {
+    if (!config.contains(key) || !config.at(key).is_array()) return;
+    for (const auto& v : config.at(key)) into.push_back(v.get<float>());
+  };
+  read("latents_mean", stats->mean);
+  read("latents_std", stats->std_dev);
+  VT_CHECK(stats->mean.size() == stats->std_dev.size(),
+           "minimax_h3 config: latents_mean and latents_std must have equal length");
+}
+
+std::vector<int64_t> ReadIntArray(const nlohmann::json& config, const char* key,
+                                  const std::vector<int64_t>& fallback) {
+  if (!config.contains(key) || !config.at(key).is_array()) return fallback;
+  std::vector<int64_t> out;
+  for (const auto& v : config.at(key)) out.push_back(v.get<int64_t>());
+  return out;
+}
+
+}  // namespace
+
+MiniMaxH3AudioVaeConfig ParseMiniMaxH3AudioVaeConfig(const nlohmann::json& config,
+                                                     MiniMaxH3LatentStats* stats) {
+  MiniMaxH3AudioVaeConfig out;
+  // `latent_dim` is the mel count BigVGAN consumes (2048), NOT `latent_channels`
+  // (32) — that one is the VAE's own latent width, which dec_in_proj maps FROM.
+  if (config.contains("latent_dim")) out.num_mels = config.at("latent_dim").get<int64_t>();
+  if (config.contains("decoder_dim")) {
+    out.upsample_initial_channel = config.at("decoder_dim").get<int64_t>();
+  }
+  out.upsample_rates = ReadIntArray(config, "decoder_rates", out.upsample_rates);
+  out.upsample_kernel_sizes =
+      ReadIntArray(config, "decoder_kernel_sizes", out.upsample_kernel_sizes);
+  out.resblock_kernel_sizes =
+      ReadIntArray(config, "resblock_kernel_sizes", out.resblock_kernel_sizes);
+  if (config.contains("resblock_dilation_sizes") &&
+      config.at("resblock_dilation_sizes").is_array()) {
+    out.resblock_dilation_sizes.clear();
+    for (const auto& row : config.at("resblock_dilation_sizes")) {
+      std::vector<int64_t> dil;
+      for (const auto& v : row) dil.push_back(v.get<int64_t>());
+      out.resblock_dilation_sizes.push_back(std::move(dil));
+    }
+  }
+  VT_CHECK(out.upsample_rates.size() == out.upsample_kernel_sizes.size(),
+           "minimax_h3 audio vae config: decoder_rates and decoder_kernel_sizes differ in length");
+  VT_CHECK(out.resblock_kernel_sizes.size() == out.resblock_dilation_sizes.size(),
+           "minimax_h3 audio vae config: resblock kernels and dilations differ in length");
+  ReadStats(config, stats);
+  return out;
+}
+
+MiniMaxH3VideoVaeDecoderConfig ParseMiniMaxH3VideoVaeDecoderConfig(const nlohmann::json& config,
+                                                                   MiniMaxH3LatentStats* stats) {
+  MiniMaxH3VideoVaeDecoderConfig out;
+  if (config.contains("decoder_num_layers")) {
+    out.num_layers = config.at("decoder_num_layers").get<int64_t>();
+  }
+  if (config.contains("latent_channels")) {
+    out.in_channels = config.at("latent_channels").get<int64_t>();
+  }
+  if (config.contains("out_channels")) out.out_channels = config.at("out_channels").get<int64_t>();
+  if (config.contains("decoder_num_register_tokens")) {
+    out.num_register_tokens = config.at("decoder_num_register_tokens").get<int64_t>();
+  }
+  if (config.contains("decoder_rope_theta")) {
+    out.rope_theta = config.at("decoder_rope_theta").get<double>();
+  }
+  const int64_t heads = config.contains("decoder_num_attention_heads")
+                            ? config.at("decoder_num_attention_heads").get<int64_t>()
+                            : out.block.heads;
+  const int64_t dim_head = config.contains("decoder_attention_head_dim")
+                               ? config.at("decoder_attention_head_dim").get<int64_t>()
+                               : out.block.dim_head;
+  out.block.heads = heads;
+  out.block.dim_head = dim_head;
+  out.block.dim = heads * dim_head;
+  const int64_t ffn_mult = config.contains("decoder_ffn_mult")
+                               ? config.at("decoder_ffn_mult").get<int64_t>()
+                               : 4;
+  out.block.ff_inner = out.block.dim * ffn_mult;
+  if (config.contains("clip_length")) out.clip_length = config.at("clip_length").get<int64_t>();
+  if (config.contains("token_drop")) out.token_drop = config.at("token_drop").get<int64_t>();
+  if (config.contains("temporal_downsample_factors")) {
+    // vae_ratio_t = prod(time_down) (klvae.py:1148).
+    int64_t prod = 1;
+    for (const auto& v : config.at("temporal_downsample_factors")) prod *= v.get<int64_t>();
+    if (prod > 0) out.vae_ratio_t = prod;
+  }
+  if (config.contains("decoder_norm_eps")) {
+    out.block.eps = config.at("decoder_norm_eps").get<double>();
+  }
+  // rope_apply_dim = int(dim_head * rope_dim_ratio), the checkpoint's own formula.
+  const double ratio = config.contains("decoder_rope_dim_ratio")
+                           ? config.at("decoder_rope_dim_ratio").get<double>()
+                           : 0.75;
+  out.rope_apply_dim = static_cast<int64_t>(static_cast<double>(dim_head) * ratio);
+  ReadStats(config, stats);
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_video_vae.cpp b/src/vllm/model_executor/models/minimax_h3_video_vae.cpp
new file mode 100644
index 000000000..ea878099b
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_video_vae.cpp
@@ -0,0 +1,450 @@
+// MiniMax-H3 VIDEO VAE decoder block — the repeated unit of the ViT3D decoder.
+//
+// Like the audio VAE, the video VAE is checkpoint REMOTE CODE
+// (`FL2VA/video_vae/*.py` under `trust_remote_code`), so it must be REIMPLEMENTED
+// rather than adapted. The real 560-tensor manifest
+// (tests/vllm/models/minimax_h3_video_vae_manifest.inc) shows the split:
+//   * the ENCODER is the 3D CNN (116 tensors, rank-5 Conv3d down blocks);
+//   * the DECODER — the only half generation needs — is a **36-block TRANSFORMER**
+//     (440 tensors), which is what this file ports.
+//
+// Per block (base_module.py:200-281), all in fp32:
+//   h = h + scale1 * Attention(RMSNorm(h))
+//   h = h + scale2 * FeedForward(RMSNorm(h))
+// with `scale1`/`scale2` LEARNED PER-CHANNEL VECTORS (not scalars), a gated SiLU
+// feed-forward (`w1` produces [gate | up], `w2` projects back), and per-head RMS
+// q/k normalization with NO affine weight.
+//
+// THE TRAP: this ViT's `to_qkv` output is PER-HEAD INTERLEAVED. Upstream does
+// `qkv.view(B, S, -1, 3 * dim_head)` then `chunk(3, dim=-1)` (attention.py), so the
+// layout is [head0_q | head0_k | head0_v | head1_q | ...] — NOT the
+// [q_all | k_all | v_all] that the H3 DiT's fused qkv uses. Reading it the DiT way
+// silently produces a plausible-but-wrong image.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+// nn.RMSNorm over the last dim, fp32 accumulation. `weight` may be empty, which
+// is the qk-norm case (elementwise_affine=False).
+void RmsNormLastDim(std::vector<float>& x, int64_t rows, int64_t width,
+                    const std::vector<float>* weight, double eps) {
+  for (int64_t r = 0; r < rows; ++r) {
+    float* row = x.data() + r * width;
+    double sum = 0.0;
+    for (int64_t i = 0; i < width; ++i) sum += static_cast<double>(row[i]) * row[i];
+    const double inv = 1.0 / std::sqrt(sum / static_cast<double>(width) + eps);
+    for (int64_t i = 0; i < width; ++i) {
+      double value = row[i] * inv;
+      if (weight != nullptr) value *= (*weight)[static_cast<size_t>(i)];
+      row[i] = static_cast<float>(value);
+    }
+  }
+}
+
+float SiluF(float x) { return x / (1.0f + std::exp(-x)); }
+
+// y = x @ W^T + b, with W [out, in].
+std::vector<float> LinearRows(const std::vector<float>& x, int64_t rows, int64_t in_features,
+                              const std::vector<float>& weight, const std::vector<float>* bias,
+                              int64_t out_features) {
+  std::vector<float> out(static_cast<size_t>(rows * out_features));
+  for (int64_t r = 0; r < rows; ++r) {
+    for (int64_t o = 0; o < out_features; ++o) {
+      double acc = bias != nullptr ? (*bias)[static_cast<size_t>(o)] : 0.0;
+      for (int64_t i = 0; i < in_features; ++i) {
+        acc += static_cast<double>(x[static_cast<size_t>(r * in_features + i)]) *
+               static_cast<double>(weight[static_cast<size_t>(o * in_features + i)]);
+      }
+      out[static_cast<size_t>(r * out_features + o)] = static_cast<float>(acc);
+    }
+  }
+  return out;
+}
+
+}  // namespace
+
+// One decoder TransformerBlock (base_module.py:200-281). `hidden` is [seq, dim].
+std::vector<float> MiniMaxH3VideoVaeBlockForward(const MiniMaxH3VideoVaeBlockConfig& config,
+                                                 const MiniMaxH3AudioVaeWeights& weights,
+                                                 const std::string& prefix,
+                                                 const std::vector<float>& hidden, int64_t seq,
+                                                 const float* rope_cos, const float* rope_sin,
+                                                 int64_t rot_dim) {
+  const int64_t dim = config.dim;
+  const int64_t heads = config.heads;
+  const int64_t dim_head = config.dim_head;
+  const int64_t inner = heads * dim_head;
+  VT_CHECK(dim > 0 && heads > 0 && dim_head > 0, "minimax_h3 video vae: bad block geometry");
+  VT_CHECK(static_cast<int64_t>(hidden.size()) == seq * dim,
+           "minimax_h3 video vae: hidden size does not match [seq, dim]");
+
+  std::vector<float> h = hidden;
+
+  // --- attention branch ---
+  {
+    std::vector<float> normed = h;
+    RmsNormLastDim(normed, seq, dim, &weights.Get(prefix + ".norm1.weight"), config.eps);
+
+    const std::vector<float> qkv =
+        LinearRows(normed, seq, dim, weights.Get(prefix + ".attn.to_qkv.weight"),
+                   &weights.Get(prefix + ".attn.to_qkv.bias"), 3 * inner);
+
+    // PER-HEAD INTERLEAVED: [head][q|k|v] within each row.
+    std::vector<float> q(static_cast<size_t>(seq * inner));
+    std::vector<float> k(static_cast<size_t>(seq * inner));
+    std::vector<float> v(static_cast<size_t>(seq * inner));
+    for (int64_t s = 0; s < seq; ++s) {
+      for (int64_t head = 0; head < heads; ++head) {
+        const int64_t src = s * 3 * inner + head * 3 * dim_head;
+        const int64_t dst = s * inner + head * dim_head;
+        for (int64_t d = 0; d < dim_head; ++d) {
+          q[static_cast<size_t>(dst + d)] = qkv[static_cast<size_t>(src + d)];
+          k[static_cast<size_t>(dst + d)] = qkv[static_cast<size_t>(src + dim_head + d)];
+          v[static_cast<size_t>(dst + d)] = qkv[static_cast<size_t>(src + 2 * dim_head + d)];
+        }
+      }
+    }
+    // qk RMSNorm has NO affine weight in this checkpoint.
+    RmsNormLastDim(q, seq * heads, dim_head, nullptr, config.eps);
+    RmsNormLastDim(k, seq * heads, dim_head, nullptr, config.eps);
+
+    // 3D RoPE. cos/sin are per TOKEN (shared across heads) and cover only the
+    // first rot_dim head dims; the rest pass through (func.py:82-102).
+    if (rope_cos != nullptr && rot_dim > 0) {
+      const int64_t half = rot_dim / 2;
+      for (int64_t s = 0; s < seq; ++s) {
+        const float* cos = rope_cos + s * rot_dim;
+        const float* sin = rope_sin + s * rot_dim;
+        for (int64_t head = 0; head < heads; ++head) {
+          for (std::vector<float>* target : {&q, &k}) {
+            float* v = target->data() + (s * heads + head) * dim_head;
+            for (int64_t i = 0; i < half; ++i) {
+              const float lo = v[i], hi = v[i + half];
+              v[i] = lo * cos[i] - hi * sin[i];
+              v[i + half] = hi * cos[i + half] + lo * sin[i + half];
+            }
+          }
+        }
+      }
+    }
+
+    // Full (non-causal) attention per head.
+    const double scale = 1.0 / std::sqrt(static_cast<double>(dim_head));
+    std::vector<float> attn(static_cast<size_t>(seq * inner), 0.0f);
+    std::vector<double> probs(static_cast<size_t>(seq));
+    for (int64_t head = 0; head < heads; ++head) {
+      for (int64_t i = 0; i < seq; ++i) {
+        double max_score = -1e30;
+        for (int64_t j = 0; j < seq; ++j) {
+          double dot = 0.0;
+          for (int64_t d = 0; d < dim_head; ++d) {
+            dot += static_cast<double>(q[static_cast<size_t>((i * heads + head) * dim_head + d)]) *
+                   static_cast<double>(k[static_cast<size_t>((j * heads + head) * dim_head + d)]);
+          }
+          probs[static_cast<size_t>(j)] = dot * scale;
+          max_score = std::max(max_score, probs[static_cast<size_t>(j)]);
+        }
+        double denom = 0.0;
+        for (int64_t j = 0; j < seq; ++j) {
+          probs[static_cast<size_t>(j)] = std::exp(probs[static_cast<size_t>(j)] - max_score);
+          denom += probs[static_cast<size_t>(j)];
+        }
+        for (int64_t d = 0; d < dim_head; ++d) {
+          double acc = 0.0;
+          for (int64_t j = 0; j < seq; ++j) {
+            acc += probs[static_cast<size_t>(j)] *
+                   static_cast<double>(v[static_cast<size_t>((j * heads + head) * dim_head + d)]);
+          }
+          attn[static_cast<size_t>((i * heads + head) * dim_head + d)] =
+              static_cast<float>(acc / denom);
+        }
+      }
+    }
+
+    const std::vector<float> projected =
+        LinearRows(attn, seq, inner, weights.Get(prefix + ".attn.to_out.weight"),
+                   &weights.Get(prefix + ".attn.to_out.bias"), dim);
+    // scale1 is a learned PER-CHANNEL vector.
+    const std::vector<float>& scale1 = weights.Get(prefix + ".scale1");
+    for (int64_t s = 0; s < seq; ++s) {
+      for (int64_t d = 0; d < dim; ++d) {
+        h[static_cast<size_t>(s * dim + d)] +=
+            projected[static_cast<size_t>(s * dim + d)] * scale1[static_cast<size_t>(d)];
+      }
+    }
+  }
+
+  // --- feed-forward branch (gated SiLU) ---
+  {
+    std::vector<float> normed = h;
+    RmsNormLastDim(normed, seq, dim, &weights.Get(prefix + ".norm2.weight"), config.eps);
+
+    const int64_t ff_inner = config.ff_inner;
+    const std::vector<float> fused =
+        LinearRows(normed, seq, dim, weights.Get(prefix + ".ff.w1.weight"),
+                   &weights.Get(prefix + ".ff.w1.bias"), 2 * ff_inner);
+    std::vector<float> act(static_cast<size_t>(seq * ff_inner));
+    for (int64_t s = 0; s < seq; ++s) {
+      const float* row = fused.data() + s * 2 * ff_inner;
+      for (int64_t i = 0; i < ff_inner; ++i) {
+        // chunk(2) gives [gate, up]; the gate is the FIRST half.
+        act[static_cast<size_t>(s * ff_inner + i)] = SiluF(row[i]) * row[ff_inner + i];
+      }
+    }
+    const std::vector<float> projected =
+        LinearRows(act, seq, ff_inner, weights.Get(prefix + ".ff.w2.weight"),
+                   &weights.Get(prefix + ".ff.w2.bias"), dim);
+    const std::vector<float>& scale2 = weights.Get(prefix + ".scale2");
+    for (int64_t s = 0; s < seq; ++s) {
+      for (int64_t d = 0; d < dim; ++d) {
+        h[static_cast<size_t>(s * dim + d)] +=
+            projected[static_cast<size_t>(s * dim + d)] * scale2[static_cast<size_t>(d)];
+      }
+    }
+  }
+  return h;
+}
+
+// ---------------------------------------------------------------------------
+// The whole ViT3D decoder (vae_vit.py:216-365)
+// ---------------------------------------------------------------------------
+
+// RotaryEmbeddingND (base_module.py:157-196) + create_token_ids
+// (func.py:12-47, "length_normalized"): coordinates are (i + 0.5)/n scaled to
+// [-1, 1), the angle scale is 2*pi (use_angle=True), and the per-axis frequency
+// blocks are concatenated then TILED twice to fill rot_dim.
+void MiniMaxH3VideoVaeRope(int64_t latent_t, int64_t latent_h, int64_t latent_w,
+                           int64_t num_suffix, int64_t rope_apply_dim, double rope_theta,
+                           std::vector<float>* cos_out, std::vector<float>* sin_out) {
+  constexpr int64_t kNDim = 3;
+  VT_CHECK(rope_apply_dim % (2 * kNDim) == 0,
+           "minimax_h3 video vae: rope dim must be divisible by 2 * n_dim");
+  const int64_t freqs = rope_apply_dim / (2 * kNDim);  // arange(0, 1, 2*n/dim) length
+  const int64_t rot_dim = 2 * kNDim * freqs;           // == rope_apply_dim
+  const int64_t patches = latent_t * latent_h * latent_w;
+  const int64_t seq = patches + num_suffix;
+
+  std::vector<double> inv_freq(static_cast<size_t>(freqs));
+  for (int64_t i = 0; i < freqs; ++i) {
+    const double step = static_cast<double>(2 * kNDim) / static_cast<double>(rope_apply_dim);
+    inv_freq[static_cast<size_t>(i)] = 1.0 / std::pow(rope_theta, static_cast<double>(i) * step);
+  }
+  auto coord = [](int64_t index, int64_t size) {
+    return 2.0 * ((static_cast<double>(index) + 0.5) / static_cast<double>(size)) - 1.0;
+  };
+
+  cos_out->assign(static_cast<size_t>(seq * rot_dim), 1.0f);
+  sin_out->assign(static_cast<size_t>(seq * rot_dim), 0.0f);
+  const int64_t half = kNDim * freqs;
+  for (int64_t p = 0; p < patches; ++p) {
+    const int64_t w = p % latent_w;
+    const int64_t h = (p / latent_w) % latent_h;
+    const int64_t t = p / (latent_w * latent_h);
+    const std::array<double, 3> ids = {coord(t, latent_t), coord(h, latent_h), coord(w, latent_w)};
+    for (int64_t axis = 0; axis < kNDim; ++axis) {
+      for (int64_t i = 0; i < freqs; ++i) {
+        const double angle = 2.0 * M_PI * ids[static_cast<size_t>(axis)] *
+                             inv_freq[static_cast<size_t>(i)];
+        const int64_t slot = axis * freqs + i;
+        // .tile(2): the [3 * freqs] block is repeated to fill rot_dim.
+        (*cos_out)[static_cast<size_t>(p * rot_dim + slot)] = static_cast<float>(std::cos(angle));
+        (*sin_out)[static_cast<size_t>(p * rot_dim + slot)] = static_cast<float>(std::sin(angle));
+        (*cos_out)[static_cast<size_t>(p * rot_dim + half + slot)] =
+            static_cast<float>(std::cos(angle));
+        (*sin_out)[static_cast<size_t>(p * rot_dim + half + slot)] =
+            static_cast<float>(std::sin(angle));
+      }
+    }
+  }
+  // The suffix tokens (register tokens + cls) carry id 0 => cos 1, sin 0, which
+  // the assign() above already established.
+}
+
+std::vector<float> MiniMaxH3VideoVaeDecode(const MiniMaxH3VideoVaeDecoderConfig& config,
+                                           const MiniMaxH3AudioVaeWeights& weights,
+                                           const std::vector<float>& latent, int64_t latent_t,
+                                           int64_t latent_h, int64_t latent_w,
+                                           MiniMaxH3VideoFrameShape* out_shape) {
+  const int64_t dim = config.block.dim;
+  const int64_t patches = latent_t * latent_h * latent_w;
+  const int64_t num_suffix = 1 + config.num_register_tokens;  // register tokens + cls
+  const int64_t seq = patches + num_suffix;
+  VT_CHECK(static_cast<int64_t>(latent.size()) == config.in_channels * patches,
+           "minimax_h3 video vae: latent size does not match [C, T, H, W]");
+
+  // _pack_tensors_3d(x, 1, 1): [C,T,H,W] -> [T*H*W, C] (channels last).
+  std::vector<float> tokens(static_cast<size_t>(patches * config.in_channels));
+  for (int64_t p = 0; p < patches; ++p) {
+    for (int64_t c = 0; c < config.in_channels; ++c) {
+      tokens[static_cast<size_t>(p * config.in_channels + c)] =
+          latent[static_cast<size_t>(c * patches + p)];
+    }
+  }
+
+  // x_embedder, then [patches | register_tokens | zero cls].
+  std::vector<float> hidden(static_cast<size_t>(seq * dim), 0.0f);
+  {
+    const std::vector<float> embedded =
+        LinearRows(tokens, patches, config.in_channels, weights.Get("x_embedder.weight"),
+                   &weights.Get("x_embedder.bias"), dim);
+    std::copy(embedded.begin(), embedded.end(), hidden.begin());
+    const std::vector<float>& registers = weights.Get("register_tokens");
+    VT_CHECK(static_cast<int64_t>(registers.size()) == config.num_register_tokens * dim,
+             "minimax_h3 video vae: register_tokens size mismatch");
+    std::copy(registers.begin(), registers.end(), hidden.begin() + patches * dim);
+    // the cls token is an explicit ZERO row (vae_vit.py:311-313)
+  }
+
+  std::vector<float> cos, sin;
+  MiniMaxH3VideoVaeRope(latent_t, latent_h, latent_w, num_suffix, config.rope_apply_dim,
+                        config.rope_theta, &cos, &sin);
+
+  for (int64_t layer = 0; layer < config.num_layers; ++layer) {
+    hidden = MiniMaxH3VideoVaeBlockForward(
+        config.block, weights, "transformer_blocks." + std::to_string(layer), hidden, seq,
+        cos.data(), sin.data(), config.rope_apply_dim);
+  }
+
+  // norm_out is a LAYER norm here (not RMS): subtract the mean too.
+  for (int64_t s = 0; s < seq; ++s) {
+    float* row = hidden.data() + s * dim;
+    double mean = 0.0;
+    for (int64_t i = 0; i < dim; ++i) mean += row[i];
+    mean /= static_cast<double>(dim);
+    double var = 0.0;
+    for (int64_t i = 0; i < dim; ++i) var += (row[i] - mean) * (row[i] - mean);
+    var /= static_cast<double>(dim);
+    const double inv = 1.0 / std::sqrt(var + config.block.eps);
+    const std::vector<float>& w = weights.Get("norm_out.weight");
+    const bool has_bias = weights.Has("norm_out.bias");
+    for (int64_t i = 0; i < dim; ++i) {
+      double value = (row[i] - mean) * inv * w[static_cast<size_t>(i)];
+      if (has_bias) value += weights.Get("norm_out.bias")[static_cast<size_t>(i)];
+      row[i] = static_cast<float>(value);
+    }
+  }
+
+  // proj_out, then drop the suffix rows.
+  const int64_t patch_dim =
+      config.out_channels * config.patch_size_t * config.patch_size * config.patch_size;
+  const std::vector<float> projected =
+      LinearRows(hidden, seq, dim, weights.Get("proj_out.weight"), &weights.Get("proj_out.bias"),
+                 patch_dim);
+
+  // _unpack_tensors_3d: [patches, C*pt*ps*ps] -> [C, T*pt, H*ps, W*ps].
+  const int64_t pt = config.patch_size_t, ps = config.patch_size;
+  const int64_t video_t = latent_t * pt, video_h = latent_h * ps, video_w = latent_w * ps;
+  std::vector<float> frames(
+      static_cast<size_t>(config.out_channels * video_t * video_h * video_w));
+  for (int64_t ti = 0; ti < latent_t; ++ti) {
+    for (int64_t hi = 0; hi < latent_h; ++hi) {
+      for (int64_t wi = 0; wi < latent_w; ++wi) {
+        const int64_t row = (ti * latent_h + hi) * latent_w + wi;
+        int64_t k = 0;
+        for (int64_t c = 0; c < config.out_channels; ++c) {
+          for (int64_t r = 0; r < pt; ++r) {
+            for (int64_t p = 0; p < ps; ++p) {
+              for (int64_t q = 0; q < ps; ++q) {
+                const int64_t dst =
+                    ((c * video_t + ti * pt + r) * video_h + hi * ps + p) * video_w + wi * ps + q;
+                frames[static_cast<size_t>(dst)] =
+                    projected[static_cast<size_t>(row * patch_dim + k)];
+                ++k;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (out_shape != nullptr) {
+    out_shape->channels = config.out_channels;
+    out_shape->t = video_t;
+    out_shape->h = video_h;
+    out_shape->w = video_w;
+  }
+  return frames;
+}
+
+// ---------------------------------------------------------------------------
+// Spatial tiling (klvae.py:192-250)
+//
+// The video VAE decodes large canvases in overlapping tiles and cross-fades the
+// seams. The shipped config is tile_size 256 / tile_overlap_min 64 / vae_ratio 16
+// (the product of `space_down` [2,2,2,2,1,1] — the "f16" in f16t4).
+//
+// The tile plan is not a simple stride: it picks the SMALLEST tile count whose
+// minimum overlaps still cover the input, then distributes the leftover slack in
+// whole `vae_ratio` units ROUND-ROBIN across the seams. Getting that distribution
+// wrong shifts every tile after the first and shows up as seam artifacts, not as
+// an error.
+// ---------------------------------------------------------------------------
+
+MiniMaxH3TilePlan MiniMaxH3SplitTiles(int64_t input_len, int64_t tile_size,
+                                      int64_t tile_overlap_min, int64_t vae_ratio) {
+  VT_CHECK(input_len > 0, "minimax_h3 tiling: input_len must be positive");
+  VT_CHECK(tile_size > 0 && vae_ratio > 0, "minimax_h3 tiling: tile_size/vae_ratio must be positive");
+  VT_CHECK(tile_overlap_min >= 0, "minimax_h3 tiling: tile_overlap_min must be >= 0");
+
+  MiniMaxH3TilePlan plan;
+  if (tile_size >= input_len) {
+    // A single tile covers the whole axis; there are no seams to blend.
+    plan.starts = {0};
+    plan.lengths = {input_len};
+    return plan;
+  }
+
+  int64_t n = (input_len + tile_size - 1) / tile_size;  // ceil
+  int64_t remaining = 0;
+  while (true) {
+    remaining = tile_size * n - tile_overlap_min * (n - 1) - input_len;
+    if (remaining >= 0) break;
+    ++n;
+  }
+  plan.overlaps.assign(static_cast<size_t>(n - 1), tile_overlap_min);
+  const int64_t remaining_units = remaining / vae_ratio;
+  for (int64_t i = 0; i < remaining_units; ++i) {
+    plan.overlaps[static_cast<size_t>(i % (n - 1))] += vae_ratio;
+  }
+
+  plan.starts.push_back(0);
+  for (int64_t i = 0; i < n - 1; ++i) {
+    plan.starts.push_back(plan.starts.back() + tile_size - plan.overlaps[static_cast<size_t>(i)]);
+  }
+  plan.lengths.assign(static_cast<size_t>(n), tile_size);
+  return plan;
+}
+
+// blend (klvae.py:220-250): a linear cross-fade over `blend_extent` elements
+// along one axis, followed by the remainder of `b`. `stride` is the distance
+// between consecutive elements along that axis.
+std::vector<float> MiniMaxH3BlendTiles(const std::vector<float>& a, const std::vector<float>& b,
+                                       int64_t blend_extent) {
+  const int64_t a_len = static_cast<int64_t>(a.size());
+  const int64_t b_len = static_cast<int64_t>(b.size());
+  blend_extent = std::min({a_len, b_len, blend_extent});
+  VT_CHECK(blend_extent > 0, "minimax_h3 tiling: blend_extent must be positive");
+
+  std::vector<float> out;
+  out.reserve(static_cast<size_t>(b_len));
+  for (int64_t i = 0; i < blend_extent; ++i) {
+    const double wb = static_cast<double>(i) / static_cast<double>(blend_extent);
+    const double wa = 1.0 - wb;
+    out.push_back(static_cast<float>(a[static_cast<size_t>(a_len - blend_extent + i)] * wa +
+                                     b[static_cast<size_t>(i)] * wb));
+  }
+  for (int64_t i = blend_extent; i < b_len; ++i) out.push_back(b[static_cast<size_t>(i)]);
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_video_vae_device.cpp b/src/vllm/model_executor/models/minimax_h3_video_vae_device.cpp
new file mode 100644
index 000000000..2af274c09
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_video_vae_device.cpp
@@ -0,0 +1,761 @@
+// MiniMax-H3 VIDEO VAE decoder, device-resident.
+//
+// The portable decoder in minimax_h3_video_vae.cpp is a CORRECTNESS reference:
+// scalar triple loops, double accumulation, one key at a time. That is the right
+// shape for a golden, and the wrong shape for a 36-layer ViT3D over thousands of
+// tokens -- it is what made a 256x256 decode time out. This is the same graph with
+// every activation on the device and every heavy step routed to the tuned shared
+// ops.
+//
+// NO NEW KERNELS. The mapping, mirroring minimax_h3_device.cpp's for the DiT:
+//
+//   Linear                  -> vt::MatmulBT + vt::Add (rank-1 row-broadcast bias)
+//   RMSNorm                 -> vt::RmsNorm
+//   qk-norm (no affine)     -> vt::RmsNorm with a ones weight
+//   qkv split               -> vt::QkvSplit
+//   3D RoPE                 -> vt::RopeFromCache over a prebuilt [seq, rot_dim] cache
+//   gated SiLU feed-forward -> vt::SiluAndMul
+//   attention               -> vt::DFlashBlockAttention(causal=false), one document
+//   LayerNorm (norm_out)    -> vt::LayerNorm
+//   residual add            -> vt::Add
+//
+// TWO LOAD-TIME WEIGHT FOLDS make that mapping possible, and both are exact
+// rearrangements rather than approximations:
+//
+// 1. QKV ROW REORDER. This checkpoint stores to_qkv PER-HEAD INTERLEAVED
+//    ([head][q|k|v] within a row), while vt::QkvSplit -- and every other model in
+//    this tree -- expects [q_all | k_all | v_all]. Permuting the weight ROWS (and
+//    the bias) once at stage time puts the GEMM output directly in QkvSplit's
+//    layout. The alternative, a bespoke interleaved-split kernel, would buy nothing.
+//
+// 2. PER-CHANNEL SCALE FOLD. Each branch ends `h += scale * (x @ W^T + b)` with a
+//    LEARNED PER-OUTPUT-CHANNEL `scale`. Since `scale` indexes the output channel,
+//    scaling row d of W and element d of b by scale[d] is algebraically identical
+//    and leaves a plain vt::Add. This is a fold of a rank-1 diagonal into a GEMM,
+//    not a numerical shortcut -- but it does REASSOCIATE the rounding (the scale is
+//    applied to the weights before the dot product rather than to the sum after
+//    it), so this path is held to the decoder's tolerance gate, not to bit-equality
+//    with the reference. That is the same standing the DiT device forward has.
+//
+// The reference accumulates its dot products in DOUBLE; the shared ops accumulate
+// in f32, which is what upstream torch does. So this is deliberately not
+// bit-identical to the portable decoder and is gated against the same goldens.
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "vllm/model_executor/models/dense_device_glue.h"
+#include "vllm/model_executor/models/minimax_h3.h"
+#include "vt/backend.h"
+#include "vt/dtype.h"
+#include "vt/ops.h"
+
+namespace vllm {
+namespace {
+
+using dense_attn::DBuf;
+using dense_attn::Dev;
+using dense_attn::MakeTensor;
+using vt::DType;
+using vt::Tensor;
+
+// Upload one f32 parameter and record its owner in `storage`, the same
+// ownership shape StageMiniMaxH3DitWeights uses: the struct holds plain Tensor
+// VIEWS, and `storage` keeps the allocations alive for exactly as long.
+Tensor Upload(vt::Backend& backend, vt::Queue& queue, const std::vector<float>& host,
+              const std::vector<int64_t>& shape,
+              std::vector<std::shared_ptr<void>>* storage) {
+  int64_t numel = 1;
+  for (const int64_t s : shape) numel *= s;
+  VT_CHECK(static_cast<int64_t>(host.size()) == numel,
+           "minimax_h3 video vae device: host buffer does not match the requested shape");
+  const size_t bytes = static_cast<size_t>(numel) * sizeof(float);
+  void* p = backend.Alloc(bytes);
+  std::shared_ptr<void> owner(p, [&backend](void* q) { backend.Free(q); });
+  backend.Copy(queue, p, host.data(), bytes);
+  storage->push_back(std::move(owner));
+  return MakeTensor(p, DType::kF32, queue.device, shape);
+}
+
+// vt::MatmulBT + optional rank-1 bias -- the device twin of the reference Linear.
+void LinearDev(Dev d, const Tensor& in, int64_t rows, int64_t in_features, const Tensor& weight,
+               const Tensor* bias, Tensor& out) {
+  VT_CHECK(weight.rank == 2 && weight.shape[1] == in_features,
+           "minimax_h3 video vae device: weight shape does not match input width");
+  Tensor a = dense_attn::Reshape(in, {rows, in_features});
+  Tensor o = dense_attn::Reshape(out, {rows, weight.shape[0]});
+  vt::MatmulBT(d.q, o, a, weight);
+  if (bias != nullptr && bias->data != nullptr) vt::Add(d.q, o, o, *bias);
+}
+
+// Fold #1: [head][q|k|v] rows -> [q_all | k_all | v_all] rows. Applies to both the
+// to_qkv weight (row-major [3*inner, dim]) and its bias ([3*inner]).
+std::vector<float> ReorderQkvRows(const std::vector<float>& src, int64_t heads, int64_t dim_head,
+                                  int64_t width) {
+  const int64_t inner = heads * dim_head;
+  VT_CHECK(static_cast<int64_t>(src.size()) == 3 * inner * width,
+           "minimax_h3 video vae device: to_qkv parameter is not [3 * heads * dim_head, width]");
+  std::vector<float> out(src.size());
+  for (int64_t head = 0; head < heads; ++head) {
+    for (int64_t part = 0; part < 3; ++part) {
+      // source rows for (head, part) are contiguous: head * 3 * dim_head + part * dim_head
+      const int64_t src_row = head * 3 * dim_head + part * dim_head;
+      const int64_t dst_row = part * inner + head * dim_head;
+      for (int64_t r = 0; r < dim_head; ++r) {
+        for (int64_t c = 0; c < width; ++c) {
+          out[static_cast<size_t>((dst_row + r) * width + c)] =
+              src[static_cast<size_t>((src_row + r) * width + c)];
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// Fold #2: scale row d of a [out, in] weight (or element d of a bias) by scale[d].
+std::vector<float> FoldPerChannelScale(const std::vector<float>& src,
+                                       const std::vector<float>& scale, int64_t width) {
+  VT_CHECK(static_cast<int64_t>(src.size()) == static_cast<int64_t>(scale.size()) * width,
+           "minimax_h3 video vae device: per-channel scale does not match the parameter rows");
+  std::vector<float> out(src.size());
+  for (size_t d = 0; d < scale.size(); ++d) {
+    for (int64_t c = 0; c < width; ++c) {
+      out[d * static_cast<size_t>(width) + static_cast<size_t>(c)] =
+          src[d * static_cast<size_t>(width) + static_cast<size_t>(c)] * scale[d];
+    }
+  }
+  return out;
+}
+
+}  // namespace
+
+// ---------------------------------------------------------------------------
+// Staged weights
+// ---------------------------------------------------------------------------
+
+MiniMaxH3VideoVaeDeviceWeights StageMiniMaxH3VideoVaeWeights(
+    vt::Queue& queue, const MiniMaxH3VideoVaeDecoderConfig& config,
+    const MiniMaxH3AudioVaeWeights& weights) {
+  vt::Backend& backend = vt::GetBackend(queue.device.type);
+  const int64_t dim = config.block.dim;
+  const int64_t heads = config.block.heads;
+  const int64_t dim_head = config.block.dim_head;
+  const int64_t inner = heads * dim_head;
+  const int64_t ff_inner = config.block.ff_inner;
+  const int64_t patch_dim =
+      config.out_channels * config.patch_size_t * config.patch_size * config.patch_size;
+
+  MiniMaxH3VideoVaeDeviceWeights out;
+  auto up = [&](const std::vector<float>& host, const std::vector<int64_t>& shape) {
+    return Upload(backend, queue, host, shape, &out.storage);
+  };
+
+  out.blocks.reserve(static_cast<size_t>(config.num_layers));
+  for (int64_t layer = 0; layer < config.num_layers; ++layer) {
+    const std::string p = "transformer_blocks." + std::to_string(layer);
+    const std::vector<float>& scale1 = weights.Get(p + ".scale1");
+    const std::vector<float>& scale2 = weights.Get(p + ".scale2");
+    MiniMaxH3VideoVaeDeviceBlock b;
+    b.norm1 = up(weights.Get(p + ".norm1.weight"), {dim});
+    b.norm2 = up(weights.Get(p + ".norm2.weight"), {dim});
+    b.qkv_weight = up(ReorderQkvRows(weights.Get(p + ".attn.to_qkv.weight"), heads, dim_head, dim),
+                      {3 * inner, dim});
+    b.qkv_bias =
+        up(ReorderQkvRows(weights.Get(p + ".attn.to_qkv.bias"), heads, dim_head, 1), {3 * inner});
+    b.out_weight =
+        up(FoldPerChannelScale(weights.Get(p + ".attn.to_out.weight"), scale1, inner), {dim, inner});
+    b.out_bias = up(FoldPerChannelScale(weights.Get(p + ".attn.to_out.bias"), scale1, 1), {dim});
+    b.w1_weight = up(weights.Get(p + ".ff.w1.weight"), {2 * ff_inner, dim});
+    b.w1_bias = up(weights.Get(p + ".ff.w1.bias"), {2 * ff_inner});
+    b.w2_weight =
+        up(FoldPerChannelScale(weights.Get(p + ".ff.w2.weight"), scale2, ff_inner), {dim, ff_inner});
+    b.w2_bias = up(FoldPerChannelScale(weights.Get(p + ".ff.w2.bias"), scale2, 1), {dim});
+    out.blocks.push_back(std::move(b));
+  }
+
+  out.x_embedder_weight = up(weights.Get("x_embedder.weight"), {dim, config.in_channels});
+  out.x_embedder_bias = up(weights.Get("x_embedder.bias"), {dim});
+  out.register_tokens = up(weights.Get("register_tokens"), {config.num_register_tokens, dim});
+  out.norm_out_weight = up(weights.Get("norm_out.weight"), {dim});
+  out.has_norm_out_bias = weights.Has("norm_out.bias");
+  if (out.has_norm_out_bias) out.norm_out_bias = up(weights.Get("norm_out.bias"), {dim});
+  out.proj_out_weight = up(weights.Get("proj_out.weight"), {patch_dim, dim});
+  out.proj_out_bias = up(weights.Get("proj_out.bias"), {patch_dim});
+  out.qk_norm_ones = up(std::vector<float>(static_cast<size_t>(dim_head), 1.0f), {dim_head});
+  backend.Synchronize(queue);
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// The decode
+// ---------------------------------------------------------------------------
+
+std::vector<float> MiniMaxH3VideoVaeDecodeDevice(vt::Device device,
+                                                 const MiniMaxH3VideoVaeDecoderConfig& config,
+                                                 const MiniMaxH3VideoVaeDeviceWeights& staged,
+                                                 const std::vector<float>& latent, int64_t latent_t,
+                                                 int64_t latent_h, int64_t latent_w,
+                                                 MiniMaxH3VideoFrameShape* out_shape) {
+  vt::Backend& backend = vt::GetBackend(device.type);
+  vt::Queue queue = backend.CreateQueue();
+  Dev d{backend, queue};
+
+  const int64_t dim = config.block.dim;
+  const int64_t heads = config.block.heads;
+  const int64_t dim_head = config.block.dim_head;
+  const int64_t inner = heads * dim_head;
+  const int64_t ff_inner = config.block.ff_inner;
+  const int64_t patches = latent_t * latent_h * latent_w;
+  const int64_t num_suffix = 1 + config.num_register_tokens;  // register tokens + cls
+  const int64_t seq = patches + num_suffix;
+  const int64_t patch_dim =
+      config.out_channels * config.patch_size_t * config.patch_size * config.patch_size;
+  VT_CHECK(static_cast<int64_t>(latent.size()) == config.in_channels * patches,
+           "minimax_h3 video vae device: latent size does not match [C, T, H, W]");
+
+  // _pack_tensors_3d(x, 1, 1): [C,T,H,W] -> [T*H*W, C]. Cheap and host-side; the
+  // cost that mattered was never this transpose.
+  std::vector<float> tokens(static_cast<size_t>(patches * config.in_channels));
+  for (int64_t p = 0; p < patches; ++p) {
+    for (int64_t c = 0; c < config.in_channels; ++c) {
+      tokens[static_cast<size_t>(p * config.in_channels + c)] =
+          latent[static_cast<size_t>(c * patches + p)];
+    }
+  }
+
+  // hidden = [x_embedder(tokens) | register_tokens | zero cls row]. The cls row is
+  // an explicit ZERO (vae_vit.py:311-313), which the zero-fill below provides.
+  DBuf hidden(d, DType::kF32, {seq, dim});
+  backend.Memset(queue, hidden.t().data, 0, hidden.t().Bytes());
+  {
+    DBuf tok(d, DType::kF32, {patches, config.in_channels}, tokens.data());
+    Tensor embedded = MakeTensor(hidden.t().data, DType::kF32, device, {patches, dim});
+    LinearDev(d, tok.t(), patches, config.in_channels, staged.x_embedder_weight,
+              &staged.x_embedder_bias, embedded);
+    backend.Copy(queue, static_cast<char*>(hidden.t().data) + patches * dim * sizeof(float),
+                 staged.register_tokens.data,
+                 static_cast<size_t>(config.num_register_tokens * dim) * sizeof(float));
+  }
+
+  // The RoPE cache. vt::RopeFromCache consumes [P, rot_dim] laid out as
+  // [cos(half) | sin(half)] and indexes it by position, so the reference's own
+  // cos/sin tables -- which are already per-token and already tiled so that
+  // cos[i + half] == cos[i] -- transcribe straight into it with no rope kernel.
+  const int64_t rot_dim = config.rope_apply_dim;
+  std::vector<float> cos_tab, sin_tab;
+  MiniMaxH3VideoVaeRope(latent_t, latent_h, latent_w, num_suffix, rot_dim, config.rope_theta,
+                        &cos_tab, &sin_tab);
+  const int64_t half = rot_dim / 2;
+  std::vector<float> rope_cache(static_cast<size_t>(seq * rot_dim));
+  for (int64_t s = 0; s < seq; ++s) {
+    for (int64_t i = 0; i < half; ++i) {
+      rope_cache[static_cast<size_t>(s * rot_dim + i)] =
+          cos_tab[static_cast<size_t>(s * rot_dim + i)];
+      rope_cache[static_cast<size_t>(s * rot_dim + half + i)] =
+          sin_tab[static_cast<size_t>(s * rot_dim + i)];
+    }
+  }
+  DBuf rope_dev(d, DType::kF32, {seq, rot_dim}, rope_cache.data());
+  std::vector<int32_t> positions_host(static_cast<size_t>(seq));
+  for (int64_t s = 0; s < seq; ++s) positions_host[static_cast<size_t>(s)] = static_cast<int32_t>(s);
+  DBuf positions(d, DType::kI32, {seq}, positions_host.data());
+
+  // One document of length `seq`, bidirectional.
+  const int32_t cu_seqlens[2] = {0, static_cast<int32_t>(seq)};
+
+  vt::RmsNormArgs norm_args;
+  norm_args.eps = static_cast<float>(config.block.eps);
+
+  for (int64_t layer = 0; layer < config.num_layers; ++layer) {
+    const MiniMaxH3VideoVaeDeviceBlock& b = staged.blocks[static_cast<size_t>(layer)];
+
+    // --- attention branch ---
+    {
+      DBuf normed(d, DType::kF32, {seq, dim});
+      vt::RmsNorm(d.q, normed.t(), hidden.t(), b.norm1, norm_args);
+
+      DBuf qkv(d, DType::kF32, {seq, 3 * inner});
+      LinearDev(d, normed.t(), seq, dim, b.qkv_weight, &b.qkv_bias, qkv.t());
+
+      DBuf qb(d, DType::kF32, {seq, inner});
+      DBuf kb(d, DType::kF32, {seq, inner});
+      DBuf vb(d, DType::kF32, {seq, inner});
+      vt::QkvSplit(d.q, qb.t(), kb.t(), vb.t(), qkv.t());
+
+      // qk RMSNorm over dim_head, WITHOUT affine -- a ones weight is the exact
+      // elementwise_affine=False case and costs one multiply by 1.0.
+      Tensor qn = dense_attn::Reshape(qb.t(), {seq * heads, dim_head});
+      Tensor kn = dense_attn::Reshape(kb.t(), {seq * heads, dim_head});
+      vt::RmsNorm(d.q, qn, qn, staged.qk_norm_ones, norm_args);
+      vt::RmsNorm(d.q, kn, kn, staged.qk_norm_ones, norm_args);
+
+      if (rot_dim > 0) {
+        Tensor q3 = dense_attn::Reshape(qb.t(), {seq, heads, dim_head});
+        Tensor k3 = dense_attn::Reshape(kb.t(), {seq, heads, dim_head});
+        vt::RopeArgs rope;
+        rope.rotary_dim = static_cast<int>(rot_dim);
+        rope.is_neox_style = true;
+        vt::RopeFromCache(d.q, q3, &k3, positions.t(), rope_dev.t(), rope);
+      }
+
+      Tensor tq = dense_attn::Reshape(qb.t(), {seq, heads, dim_head});
+      Tensor tk = dense_attn::Reshape(kb.t(), {seq, heads, dim_head});
+      Tensor tv = dense_attn::Reshape(vb.t(), {seq, heads, dim_head});
+      DBuf attn(d, DType::kF32, {seq, heads, dim_head});
+      vt::DFlashBlockAttentionArgs args;
+      args.scale = static_cast<float>(1.0 / std::sqrt(static_cast<double>(dim_head)));
+      args.causal = false;
+      args.sliding_window = 0;
+      args.cu_seqlens = cu_seqlens;
+      args.num_reqs = 1;
+      vt::DFlashBlockAttention(d.q, attn.t(), tq, tk, tv, args);
+
+      // scale1 is already folded into out_weight/out_bias, so this is a plain add.
+      DBuf projected(d, DType::kF32, {seq, dim});
+      LinearDev(d, attn.t(), seq, inner, b.out_weight, &b.out_bias, projected.t());
+      vt::Add(d.q, hidden.t(), hidden.t(), projected.t());
+    }
+
+    // --- feed-forward branch (gated SiLU) ---
+    {
+      DBuf normed(d, DType::kF32, {seq, dim});
+      vt::RmsNorm(d.q, normed.t(), hidden.t(), b.norm2, norm_args);
+
+      // w1 emits [gate | up] per row, which is exactly vt::SiluAndMul's layout.
+      DBuf fused(d, DType::kF32, {seq, 2 * ff_inner});
+      LinearDev(d, normed.t(), seq, dim, b.w1_weight, &b.w1_bias, fused.t());
+      DBuf act(d, DType::kF32, {seq, ff_inner});
+      vt::SiluAndMul(d.q, act.t(), fused.t());
+
+      DBuf projected(d, DType::kF32, {seq, dim});
+      LinearDev(d, act.t(), seq, ff_inner, b.w2_weight, &b.w2_bias, projected.t());
+      vt::Add(d.q, hidden.t(), hidden.t(), projected.t());
+    }
+  }
+
+  // norm_out is a LAYER norm here, not an RMS norm.
+  {
+    vt::LayerNormArgs ln;
+    ln.eps = static_cast<float>(config.block.eps);
+    vt::LayerNorm(d.q, hidden.t(), hidden.t(), &staged.norm_out_weight,
+                  staged.has_norm_out_bias ? &staged.norm_out_bias : nullptr, ln);
+  }
+
+  DBuf projected(d, DType::kF32, {seq, patch_dim});
+  LinearDev(d, hidden.t(), seq, dim, staged.proj_out_weight, &staged.proj_out_bias,
+            projected.t());
+
+  // Only the PATCH rows are unpacked; the register and cls rows are dropped.
+  std::vector<float> projected_host(static_cast<size_t>(patches * patch_dim));
+  backend.Copy(queue, projected_host.data(), projected.t().data,
+               projected_host.size() * sizeof(float));
+  backend.Synchronize(queue);
+
+  // _unpack_tensors_3d: [patches, C*pt*ps*ps] -> [C, T*pt, H*ps, W*ps].
+  const int64_t pt = config.patch_size_t, ps = config.patch_size;
+  const int64_t video_t = latent_t * pt, video_h = latent_h * ps, video_w = latent_w * ps;
+  std::vector<float> frames(
+      static_cast<size_t>(config.out_channels * video_t * video_h * video_w));
+  for (int64_t ti = 0; ti < latent_t; ++ti) {
+    for (int64_t hi = 0; hi < latent_h; ++hi) {
+      for (int64_t wi = 0; wi < latent_w; ++wi) {
+        const int64_t row = (ti * latent_h + hi) * latent_w + wi;
+        int64_t k = 0;
+        for (int64_t c = 0; c < config.out_channels; ++c) {
+          for (int64_t r = 0; r < pt; ++r) {
+            for (int64_t p = 0; p < ps; ++p) {
+              for (int64_t q = 0; q < ps; ++q) {
+                const int64_t dst =
+                    ((c * video_t + ti * pt + r) * video_h + hi * ps + p) * video_w + wi * ps + q;
+                frames[static_cast<size_t>(dst)] =
+                    projected_host[static_cast<size_t>(row * patch_dim + k)];
+                ++k;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (out_shape != nullptr) {
+    out_shape->channels = config.out_channels;
+    out_shape->t = video_t;
+    out_shape->h = video_h;
+    out_shape->w = video_w;
+  }
+  return frames;
+}
+
+
+// ---------------------------------------------------------------------------
+// SPATIAL TILING (klvae.py:192-250)
+//
+// This is NOT a memory strategy, which is how it first reads. The ViT3D decoder's
+// RoPE coordinates are LENGTH-NORMALIZED -- `2*((i + 0.5)/n) - 1` over whatever
+// grid it is handed (MiniMaxH3VideoVaeRope) -- so the grid EXTENT is part of the
+// input, not an implementation detail. Upstream always decodes in 256-pixel tiles
+// (16 latent units); handing the decoder a 32x32 latent instead of the 16x16 it
+// was trained on gives every token a position the model has never seen.
+//
+// Observed, not theorized: at 512x512 (which upstream plans as 3 tiles per axis)
+// an untiled decode produced globally-correct frames covered in a grid of small
+// squares, while 256x256 -- the one size where tile_size >= input, so tiled and
+// untiled are the SAME computation -- came out clean.
+//
+// Every plan value is a whole number of `vae_ratio` units (tile_size 256 = 16*16,
+// and the slack is distributed in whole vae_ratio steps), so the pixel plan slices
+// the latent exactly.
+namespace {
+
+// Cross-fade `b` onto `a` along the LAST axis of a [C, T, H, W] buffer, reusing the
+// gated 1-D MiniMaxH3BlendTiles per scanline. Result width is wa - extent + wb.
+std::vector<float> BlendAlongW(const std::vector<float>& a, const std::vector<float>& b, int64_t c,
+                               int64_t t, int64_t h, int64_t wa, int64_t wb, int64_t extent) {
+  const int64_t wout = wa - extent + wb;
+  std::vector<float> out(static_cast<size_t>(c * t * h * wout));
+  std::vector<float> la(static_cast<size_t>(wa)), lb(static_cast<size_t>(wb));
+  for (int64_t i = 0; i < c * t * h; ++i) {
+    for (int64_t x = 0; x < wa; ++x) la[static_cast<size_t>(x)] = a[static_cast<size_t>(i * wa + x)];
+    for (int64_t x = 0; x < wb; ++x) lb[static_cast<size_t>(x)] = b[static_cast<size_t>(i * wb + x)];
+    const std::vector<float> merged = MiniMaxH3BlendTiles(la, lb, extent);
+    // `merged` covers the region starting at (wa - extent); everything before it is
+    // `a` untouched.
+    for (int64_t x = 0; x < wa - extent; ++x) {
+      out[static_cast<size_t>(i * wout + x)] = la[static_cast<size_t>(x)];
+    }
+    for (size_t x = 0; x < merged.size(); ++x) {
+      out[static_cast<size_t>(i * wout + wa - extent) + x] = merged[x];
+    }
+  }
+  return out;
+}
+
+// The same cross-fade along H. Lines are strided by W, so they are gathered.
+std::vector<float> BlendAlongH(const std::vector<float>& a, const std::vector<float>& b, int64_t c,
+                               int64_t t, int64_t ha, int64_t hb, int64_t w, int64_t extent) {
+  const int64_t hout = ha - extent + hb;
+  std::vector<float> out(static_cast<size_t>(c * t * hout * w));
+  std::vector<float> la(static_cast<size_t>(ha)), lb(static_cast<size_t>(hb));
+  for (int64_t plane = 0; plane < c * t; ++plane) {
+    for (int64_t x = 0; x < w; ++x) {
+      for (int64_t y = 0; y < ha; ++y) {
+        la[static_cast<size_t>(y)] = a[static_cast<size_t>((plane * ha + y) * w + x)];
+      }
+      for (int64_t y = 0; y < hb; ++y) {
+        lb[static_cast<size_t>(y)] = b[static_cast<size_t>((plane * hb + y) * w + x)];
+      }
+      const std::vector<float> merged = MiniMaxH3BlendTiles(la, lb, extent);
+      for (int64_t y = 0; y < ha - extent; ++y) {
+        out[static_cast<size_t>((plane * hout + y) * w + x)] = la[static_cast<size_t>(y)];
+      }
+      for (size_t y = 0; y < merged.size(); ++y) {
+        out[static_cast<size_t>((plane * hout + (ha - extent) + static_cast<int64_t>(y)) * w + x)] =
+            merged[y];
+      }
+    }
+  }
+  return out;
+}
+
+}  // namespace
+
+std::vector<float> MiniMaxH3VideoVaeDecodeTiledDevice(
+    vt::Device device, const MiniMaxH3VideoVaeDecoderConfig& config,
+    const MiniMaxH3VideoVaeDeviceWeights& staged, const std::vector<float>& latent,
+    int64_t latent_t, int64_t latent_h, int64_t latent_w, MiniMaxH3VideoFrameShape* out_shape) {
+  const int64_t ratio = kMiniMaxH3VaeRatio;
+  const MiniMaxH3TilePlan plan_h = MiniMaxH3SplitTiles(
+      latent_h * ratio, kMiniMaxH3VaeTileSize, kMiniMaxH3VaeTileOverlapMin, ratio);
+  const MiniMaxH3TilePlan plan_w = MiniMaxH3SplitTiles(
+      latent_w * ratio, kMiniMaxH3VaeTileSize, kMiniMaxH3VaeTileOverlapMin, ratio);
+
+  // A single tile is the untiled decode, bit for bit -- no slicing, no blending.
+  if (plan_h.starts.size() == 1 && plan_w.starts.size() == 1) {
+    return MiniMaxH3VideoVaeDecodeDevice(device, config, staged, latent, latent_t, latent_h,
+                                         latent_w, out_shape);
+  }
+
+  const int64_t channels = config.in_channels;
+  const int64_t ps = config.patch_size, pt = config.patch_size_t;
+  const int64_t frames_t = latent_t * pt;
+
+  std::vector<float> assembled;  // [out_channels, frames_t, H, W] as it grows
+  int64_t assembled_h = 0, assembled_w = 0;
+
+  for (size_t i = 0; i < plan_h.starts.size(); ++i) {
+    const int64_t h0 = plan_h.starts[i] / ratio, hl = plan_h.lengths[i] / ratio;
+    std::vector<float> row;
+    int64_t row_w = 0;
+    for (size_t j = 0; j < plan_w.starts.size(); ++j) {
+      const int64_t w0 = plan_w.starts[j] / ratio, wl = plan_w.lengths[j] / ratio;
+      VT_CHECK(h0 + hl <= latent_h && w0 + wl <= latent_w,
+               "minimax_h3 video vae tiling: tile exceeds the latent grid");
+
+      std::vector<float> sub(static_cast<size_t>(channels * latent_t * hl * wl));
+      for (int64_t c = 0; c < channels; ++c) {
+        for (int64_t tt = 0; tt < latent_t; ++tt) {
+          for (int64_t y = 0; y < hl; ++y) {
+            for (int64_t x = 0; x < wl; ++x) {
+              sub[static_cast<size_t>(((c * latent_t + tt) * hl + y) * wl + x)] =
+                  latent[static_cast<size_t>(((c * latent_t + tt) * latent_h + h0 + y) * latent_w +
+                                             w0 + x)];
+            }
+          }
+        }
+      }
+      MiniMaxH3VideoFrameShape tile_shape;
+      const std::vector<float> tile = MiniMaxH3VideoVaeDecodeDevice(
+          device, config, staged, sub, latent_t, hl, wl, &tile_shape);
+      const int64_t tw = wl * ps;
+      if (j == 0) {
+        row = tile;
+        row_w = tw;
+      } else {
+        // The plan is in CANVAS pixels (vae_ratio per latent unit); the blend
+        // happens in the DECODER'S output pixels (patch_size per latent unit).
+        // They are both 16 on the real checkpoint, so converting through latent
+        // units matters only for reduced-dimension configs -- which is exactly
+        // where the gates run.
+        const int64_t ov = (plan_w.overlaps[j - 1] / ratio) * ps;
+        row = BlendAlongW(row, tile, config.out_channels, frames_t, hl * ps, row_w, tw, ov);
+        row_w = row_w - ov + tw;
+      }
+    }
+    const int64_t th = hl * ps;
+    if (i == 0) {
+      assembled = std::move(row);
+      assembled_h = th;
+      assembled_w = row_w;
+    } else {
+      VT_CHECK(row_w == assembled_w, "minimax_h3 video vae tiling: tile rows disagree on width");
+      const int64_t ov = (plan_h.overlaps[i - 1] / ratio) * ps;
+      assembled = BlendAlongH(assembled, row, config.out_channels, frames_t, assembled_h, th,
+                              assembled_w, ov);
+      assembled_h = assembled_h - ov + th;
+    }
+  }
+
+  if (out_shape != nullptr) {
+    out_shape->channels = config.out_channels;
+    out_shape->t = frames_t;
+    out_shape->h = assembled_h;
+    out_shape->w = assembled_w;
+  }
+  return assembled;
+}
+
+
+// ---------------------------------------------------------------------------
+// TEMPORAL CHUNKING (klvae.py decode_temporal, :678-786)
+//
+// This is the real shape of upstream's video decode, and the one thing our port
+// was missing: `decode_base` routes video through `decode_temporal`, NOT through
+// a single pass. The ViT sees `tokens_chunk_size + token_overlap` temporal tokens
+// at a time -- 7 for the shipped config -- never the whole latent.
+//
+// It matters for the same reason the spatial extent does: the decoder's RoPE is
+// LENGTH-NORMALIZED over the grid it is handed (MiniMaxH3VideoVaeRope takes
+// latent_t/h/w), so the temporal EXTENT is part of the input. Handing it 12
+// tokens when it was trained on 7 gives every token a position the model never
+// saw. Every reduced-dimension gate in this tree runs at latent_t = 2 -- below one
+// chunk, where chunked and unchunked decode are the SAME computation -- which is
+// exactly why the suite could not see this.
+//
+// Shipped config (clip_length 17, token_drop 3, vae_ratio_t 4) gives
+// tokens_chunk_size 5, token_overlap 2, frame_pre_padding 3, frame_overlap 5.
+// isolated_first_frame / isolated_last_frame default FALSE and the shipped config
+// sets neither, so the head/tail isolation branches are not taken; they are
+// deliberately NOT implemented rather than implemented untested.
+std::vector<float> MiniMaxH3VideoVaeDecodeTemporalDevice(
+    vt::Device device, const MiniMaxH3VideoVaeDecoderConfig& config,
+    const MiniMaxH3VideoVaeDeviceWeights& staged, const std::vector<float>& latent,
+    int64_t latent_t, int64_t latent_h, int64_t latent_w, int64_t target_frames,
+    MiniMaxH3VideoFrameShape* out_shape) {
+  const int64_t chan = config.in_channels;
+  const int64_t ratio_t = config.vae_ratio_t;
+  const int64_t chunk_tokens = config.tokens_chunk_size();
+  const int64_t overlap_tokens = config.token_overlap();
+  const int64_t pre_pad = config.frame_pre_padding();
+  const int64_t frame_ov = config.frame_overlap();
+  VT_CHECK(chunk_tokens > 0 && ratio_t > 0, "minimax_h3 temporal decode: bad chunk geometry");
+
+  // pseudo_total_tokens = T - isolated + token_drop, padded up to a whole number
+  // of chunks by REPEATING the last latent frame (klvae.py:688-696).
+  int64_t pseudo_total = latent_t + config.token_drop;
+  const int64_t remainder = pseudo_total % chunk_tokens;
+  const int64_t pad_tokens = remainder == 0 ? 0 : chunk_tokens - remainder;
+  pseudo_total += pad_tokens;
+  const int64_t num_chunks = pseudo_total / chunk_tokens - (config.token_drop > 0 ? 1 : 0);
+  // A latent shorter than one chunk yields num_chunks == 0 (latent_t 2 gives
+  // pseudo 5, i.e. exactly one chunk, minus the token_drop chunk). There is no
+  // chunking to do, so decode it directly rather than aborting -- this is the
+  // regime the reduced-dimension gates run in.
+  if (num_chunks < 1) {
+    MiniMaxH3VideoFrameShape s{};
+    std::vector<float> whole =
+        config.decoder_tiling
+            ? MiniMaxH3VideoVaeDecodeTiledDevice(device, config, staged, latent, latent_t, latent_h,
+                                                 latent_w, &s)
+            : MiniMaxH3VideoVaeDecodeDevice(device, config, staged, latent, latent_t, latent_h,
+                                            latent_w, &s);
+    if (out_shape != nullptr) *out_shape = s;
+    return whole;
+  }
+
+  std::vector<float> z = latent;
+  int64_t z_t = latent_t;
+  if (pad_tokens > 0) {
+    // repeat the LAST temporal token pad_tokens times
+    std::vector<float> padded(static_cast<size_t>(chan * (z_t + pad_tokens) * latent_h * latent_w));
+    const int64_t plane = latent_h * latent_w;
+    for (int64_t c = 0; c < chan; ++c) {
+      for (int64_t tt = 0; tt < z_t + pad_tokens; ++tt) {
+        const int64_t src_t = std::min(tt, z_t - 1);
+        for (int64_t i = 0; i < plane; ++i) {
+          padded[static_cast<size_t>((c * (z_t + pad_tokens) + tt) * plane + i)] =
+              z[static_cast<size_t>((c * z_t + src_t) * plane + i)];
+        }
+      }
+    }
+    z = std::move(padded);
+    z_t += pad_tokens;
+  }
+
+  const int64_t ps = config.patch_size;
+  const int64_t out_h = latent_h * ps, out_w = latent_w * ps;
+  const int64_t chunk_dec = chunk_tokens * ratio_t;
+  const int64_t plane = out_h * out_w;
+  const int64_t chans = config.out_channels;
+
+  // Decode each chunk, then walk upstream's j-loop: slice `chunk_dec` frames at a
+  // time, drop `frame_pre_padding` leading frames, cross-fade the carried overlap.
+  std::vector<std::vector<float>> pieces;  // each [C, f, H, W]
+  std::vector<int64_t> piece_frames;
+  std::vector<float> carry;  // dec_overlap
+  int64_t carry_frames = 0;
+
+  for (int64_t i = 0; i < num_chunks; ++i) {
+    const int64_t t0 = i * chunk_tokens;
+    const int64_t t1 = std::min(t0 + chunk_tokens + overlap_tokens, z_t);
+    const int64_t nt = t1 - t0;
+    VT_CHECK(nt > 0, "minimax_h3 temporal decode: empty chunk");
+
+    std::vector<float> sub(static_cast<size_t>(chan * nt * latent_h * latent_w));
+    const int64_t lplane = latent_h * latent_w;
+    for (int64_t c = 0; c < chan; ++c) {
+      for (int64_t k = 0; k < nt; ++k) {
+        for (int64_t e = 0; e < lplane; ++e) {
+          sub[static_cast<size_t>((c * nt + k) * lplane + e)] =
+              z[static_cast<size_t>((c * z_t + t0 + k) * lplane + e)];
+        }
+      }
+    }
+    // Upstream's chunk loop calls `self._adaptive_decode(clip_z)` -- so when
+    // decoder tiling is on, each TEMPORAL chunk is ALSO spatially tiled. The two
+    // compose; they are not alternatives. Tiled decode falls through to the
+    // untiled one bit-for-bit when the canvas fits in a single tile, so this is a
+    // no-op below 256 px and matches upstream's tiled mode above it.
+    MiniMaxH3VideoFrameShape cs{};
+    const std::vector<float> dec =
+        config.decoder_tiling
+            ? MiniMaxH3VideoVaeDecodeTiledDevice(device, config, staged, sub, nt, latent_h,
+                                                 latent_w, &cs)
+            : MiniMaxH3VideoVaeDecodeDevice(device, config, staged, sub, nt, latent_h, latent_w,
+                                            &cs);
+    const int64_t dec_frames = cs.t;
+
+    for (int64_t j = 0; j < (config.token_drop > 0 ? 2 : 1); ++j) {
+      const int64_t f0 = j * chunk_dec;
+      if (f0 >= dec_frames) break;
+      const int64_t f1 = std::min(f0 + chunk_dec, dec_frames);
+      const int64_t keep0 = f0 + pre_pad;
+      if (keep0 >= f1) continue;
+      const int64_t nf = f1 - keep0;
+
+      std::vector<float> piece(static_cast<size_t>(chans * nf * plane));
+      for (int64_t c = 0; c < chans; ++c) {
+        for (int64_t f = 0; f < nf; ++f) {
+          for (int64_t e = 0; e < plane; ++e) {
+            piece[static_cast<size_t>((c * nf + f) * plane + e)] =
+                dec[static_cast<size_t>((c * dec_frames + keep0 + f) * plane + e)];
+          }
+        }
+      }
+
+      if (j == 0) {
+        if (carry_frames > 0) {
+          // blend(dec_overlap, piece, frame_overlap) along the FRAME axis
+          const int64_t ext = std::min({carry_frames, nf, frame_ov});
+          for (int64_t c = 0; c < chans; ++c) {
+            for (int64_t e = 0; e < plane; ++e) {
+              for (int64_t f = 0; f < ext; ++f) {
+                const double wb = static_cast<double>(f) / static_cast<double>(ext);
+                const float a_v = carry[static_cast<size_t>(
+                    (c * carry_frames + carry_frames - ext + f) * plane + e)];
+                float& b_v = piece[static_cast<size_t>((c * nf + f) * plane + e)];
+                b_v = static_cast<float>(a_v * (1.0 - wb) + b_v * wb);
+              }
+            }
+          }
+          carry.clear();
+          carry_frames = 0;
+        }
+        pieces.push_back(std::move(piece));
+        piece_frames.push_back(nf);
+      } else {
+        carry = std::move(piece);
+        carry_frames = nf;
+      }
+    }
+  }
+  if (carry_frames > 0) {
+    pieces.push_back(std::move(carry));
+    piece_frames.push_back(carry_frames);
+  }
+
+  int64_t total = 0;
+  for (const int64_t f : piece_frames) total += f;
+  std::vector<float> out(static_cast<size_t>(chans * total * plane));
+  int64_t at = 0;
+  for (size_t k = 0; k < pieces.size(); ++k) {
+    const int64_t nf = piece_frames[k];
+    for (int64_t c = 0; c < chans; ++c) {
+      for (int64_t f = 0; f < nf; ++f) {
+        for (int64_t e = 0; e < plane; ++e) {
+          out[static_cast<size_t>((c * total + at + f) * plane + e)] =
+              pieces[k][static_cast<size_t>((c * nf + f) * plane + e)];
+        }
+      }
+    }
+    at += nf;
+  }
+
+  // trim_output (klvae.py:452-459): non-causal decoders CENTER-crop to the frame
+  // count the request asked for.
+  if (target_frames > 0 && target_frames < total) {
+    const int64_t start = (total - target_frames) / 2;
+    std::vector<float> trimmed(static_cast<size_t>(chans * target_frames * plane));
+    for (int64_t c = 0; c < chans; ++c) {
+      for (int64_t f = 0; f < target_frames; ++f) {
+        for (int64_t e = 0; e < plane; ++e) {
+          trimmed[static_cast<size_t>((c * target_frames + f) * plane + e)] =
+              out[static_cast<size_t>((c * total + start + f) * plane + e)];
+        }
+      }
+    }
+    out = std::move(trimmed);
+    total = target_frames;
+  }
+
+  if (out_shape != nullptr) {
+    out_shape->channels = chans;
+    out_shape->t = total;
+    out_shape->h = out_h;
+    out_shape->w = out_w;
+  }
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vllm/model_executor/models/minimax_h3_wav.cpp b/src/vllm/model_executor/models/minimax_h3_wav.cpp
new file mode 100644
index 000000000..16aa959e2
--- /dev/null
+++ b/src/vllm/model_executor/models/minimax_h3_wav.cpp
@@ -0,0 +1,150 @@
+// MiniMax-H3 audio output: RIFF/WAVE serialization of the decoded waveform.
+//
+// The audio VAE emits a CHANNEL-MAJOR float waveform (all of channel 0, then all
+// of channel 1) at 32 kHz. Every consumer wants interleaved PCM, so this does the
+// interleave and the container in one place.
+//
+// WHY THIS EXISTS SEPARATELY FROM MP4 MUXING. `/v1/videos` ultimately returns MP4
+// (H.264 video + audio), and how this project should obtain a muxer is an open
+// DEPENDENCY DECISION (upstream vLLM-Omni shells out to ffmpeg; this tree has no
+// subprocess precedent in the core library). WAV needs none of that: it is a
+// 44-byte header plus samples, it is dependency-free, and it is required under
+// EITHER outcome of that decision — a muxer will take PCM, and a standalone audio
+// artifact is useful on its own. So it is implemented now and the container
+// question stays open.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "vt/dtype.h"
+
+namespace vllm {
+namespace {
+
+void PutU32(std::string& out, uint32_t value) {
+  for (int i = 0; i < 4; ++i) out.push_back(static_cast<char>((value >> (8 * i)) & 0xFF));
+}
+
+void PutU16(std::string& out, uint16_t value) {
+  for (int i = 0; i < 2; ++i) out.push_back(static_cast<char>((value >> (8 * i)) & 0xFF));
+}
+
+}  // namespace
+
+std::string MiniMaxH3WriteWav(const std::vector<float>& waveform, int64_t channels,
+                              int64_t samples_per_channel, int64_t sample_rate) {
+  VT_CHECK(channels > 0 && samples_per_channel > 0 && sample_rate > 0,
+           "minimax_h3 wav: channels, samples and sample_rate must be positive");
+  VT_CHECK(static_cast<int64_t>(waveform.size()) == channels * samples_per_channel,
+           "minimax_h3 wav: waveform size does not match channels * samples_per_channel");
+
+  const int64_t total = channels * samples_per_channel;
+  const uint32_t data_bytes = static_cast<uint32_t>(total * 2);  // 16-bit PCM
+  const uint16_t block_align = static_cast<uint16_t>(channels * 2);
+
+  std::string out;
+  out.reserve(44 + static_cast<size_t>(data_bytes));
+  out += "RIFF";
+  PutU32(out, 36u + data_bytes);  // chunk size = header remainder + payload
+  out += "WAVE";
+  out += "fmt ";
+  PutU32(out, 16u);                                        // PCM fmt chunk size
+  PutU16(out, 1u);                                         // format = PCM
+  PutU16(out, static_cast<uint16_t>(channels));
+  PutU32(out, static_cast<uint32_t>(sample_rate));
+  PutU32(out, static_cast<uint32_t>(sample_rate) * block_align);  // byte rate
+  PutU16(out, block_align);
+  PutU16(out, 16u);                                        // bits per sample
+  out += "data";
+  PutU32(out, data_bytes);
+
+  // The VAE's layout is CHANNEL-MAJOR; WAV is INTERLEAVED. Getting this backwards
+  // produces audio that plays but with the channels time-smeared into each other.
+  for (int64_t s = 0; s < samples_per_channel; ++s) {
+    for (int64_t c = 0; c < channels; ++c) {
+      float value = waveform[static_cast<size_t>(c * samples_per_channel + s)];
+      value = std::min(1.0f, std::max(-1.0f, value));
+      // Symmetric scaling by 32767 so +1.0 and -1.0 map to the extremes without
+      // wrapping; -32768 is never produced.
+      const int32_t quantized = static_cast<int32_t>(std::lround(value * 32767.0f));
+      PutU16(out, static_cast<uint16_t>(static_cast<int16_t>(quantized)));
+    }
+  }
+  return out;
+}
+
+// The INVERSE, needed once REFERENCE AUDIO became expressible: a ref2va request
+// conditions on a supplied waveform, and the waveform arrives as a file.
+//
+// Deliberately NOT a resampler. The checkpoint's audio VAE is 32 kHz; encoding a
+// 44.1 kHz file as if it were 32 kHz would silently shift every latent frame, so a
+// rate mismatch is REFUSED and the caller resamples. Upstream can be lax here only
+// because it has torchaudio (vae.py:298-306); this library has no audio dependency
+// and will not pretend to.
+std::vector<float> MiniMaxH3ReadWav(const std::string& bytes, int64_t want_channels,
+                                    int64_t want_sample_rate, int64_t* out_samples_per_channel) {
+  VT_CHECK(want_channels > 0, "minimax_h3 wav: want_channels must be positive");
+  VT_CHECK(bytes.size() >= 44, "minimax_h3 wav: too short to be a RIFF/WAVE file");
+  VT_CHECK(bytes.compare(0, 4, "RIFF") == 0 && bytes.compare(8, 4, "WAVE") == 0,
+           "minimax_h3 wav: not a RIFF/WAVE file");
+
+  auto u16 = [&](size_t at) -> uint32_t {
+    return static_cast<uint32_t>(static_cast<unsigned char>(bytes[at])) |
+           (static_cast<uint32_t>(static_cast<unsigned char>(bytes[at + 1])) << 8);
+  };
+  auto u32 = [&](size_t at) -> uint32_t { return u16(at) | (u16(at + 2) << 16); };
+
+  int64_t channels = 0, sample_rate = 0, bits = 0;
+  bool have_fmt = false;
+  size_t data_at = 0, data_len = 0;
+  // Walk the CHUNK LIST rather than assuming a 44-byte header: real files carry
+  // LIST/fact chunks before `data`, and a fixed offset would read metadata as audio.
+  for (size_t at = 12; at + 8 <= bytes.size();) {
+    const size_t len = u32(at + 4);
+    const size_t body = at + 8;
+    if (bytes.compare(at, 4, "fmt ") == 0 && len >= 16 && body + 16 <= bytes.size()) {
+      VT_CHECK(u16(body) == 1u, "minimax_h3 wav: only uncompressed PCM is supported");
+      channels = u16(body + 2);
+      sample_rate = u32(body + 4);
+      bits = u16(body + 14);
+      have_fmt = true;
+    } else if (bytes.compare(at, 4, "data") == 0) {
+      data_at = body;
+      data_len = std::min(len, bytes.size() - body);
+      break;
+    }
+    at = body + len + (len & 1u);  // chunks are word-aligned
+  }
+  VT_CHECK(have_fmt, "minimax_h3 wav: no fmt chunk");
+  VT_CHECK(data_at != 0, "minimax_h3 wav: no data chunk");
+  VT_CHECK(bits == 16, "minimax_h3 wav: only 16-bit PCM is supported");
+  VT_CHECK(channels > 0, "minimax_h3 wav: the fmt chunk declares no channels");
+  VT_CHECK(want_sample_rate <= 0 || sample_rate == want_sample_rate,
+           "minimax_h3 wav: sample rate does not match the model's (resample the file first; "
+           "this reader deliberately does not)");
+
+  const int64_t frames = static_cast<int64_t>(data_len) / (2 * channels);
+  VT_CHECK(frames > 0, "minimax_h3 wav: the data chunk holds no samples");
+
+  // Interleaved -> CHANNEL-MAJOR, the layout every other H3 audio surface uses.
+  // A MONO source is REPEATED across the model's channels and anything wider is
+  // truncated, mirroring vae.py:305-313.
+  std::vector<float> out(static_cast<size_t>(want_channels * frames), 0.0f);
+  for (int64_t t = 0; t < frames; ++t) {
+    for (int64_t c = 0; c < want_channels; ++c) {
+      const int64_t src = channels == 1 ? 0 : std::min<int64_t>(c, channels - 1);
+      const int16_t pcm = static_cast<int16_t>(static_cast<uint16_t>(
+          u16(data_at + static_cast<size_t>((t * channels + src) * 2))));
+      out[static_cast<size_t>(c * frames + t)] = static_cast<float>(pcm) / 32768.0f;
+    }
+  }
+  if (out_samples_per_channel != nullptr) *out_samples_per_channel = frames;
+  return out;
+}
+
+}  // namespace vllm
diff --git a/src/vt/cpu/cpu_minimax_h3.cpp b/src/vt/cpu/cpu_minimax_h3.cpp
new file mode 100644
index 000000000..5ca9945b8
--- /dev/null
+++ b/src/vt/cpu/cpu_minimax_h3.cpp
@@ -0,0 +1,112 @@
+// CPU half of the MiniMax-H3 DiT device-forward glue table (vt::OpId::kMiniMaxH3).
+//
+// Three small ops the shared vt:: surface does not cover; see
+// include/vllm/model_executor/models/minimax_h3_device.h for why the table is this
+// short (everything else in the DiT forward reuses tuned shared ops).
+//
+// Each kernel is a 1:1 transcription of the host reference it stands in for
+// (minimax_h3.cpp: ModulateScaleShift / ModulateGate / Silu), in the same
+// arithmetic order. The CUDA sibling lives in src/vt/cuda/cuda_minimax_h3.cu.
+//
+// DTYPE: arithmetic is ALWAYS f32; only the load/store width varies. A bf16 stream
+// therefore rounds on STORE, which is exactly upstream's cast point -- no separate
+// rounding pass, and no way for the fused store to drift from it.
+//
+// Registering this on kCPU (Laguna's equivalent table is CUDA-only) is what lets
+// the whole device-forward code path be covered by CPU CI, so a GPU is needed to
+// gate the KERNELS, not the port's structure.
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+
+#include "vllm/model_executor/models/minimax_h3_device.h"
+#include "vt/ops.h"  // OpId, RegisterOp, DeviceType
+
+namespace vt::cpu {
+namespace {
+
+// bf16 is stored as the high 16 bits of the f32 pattern; round-to-nearest-even on
+// store, matching torch's `.to(bfloat16)` and minimax_h3.cpp's RoundBf16.
+inline float LoadBf16(const void* p, int64_t i) {
+  const uint32_t bits = static_cast<uint32_t>(static_cast<const uint16_t*>(p)[i]) << 16;
+  float out;
+  std::memcpy(&out, &bits, sizeof(out));
+  return out;
+}
+
+inline void StoreBf16(void* p, int64_t i, float v) {
+  uint32_t bits;
+  std::memcpy(&bits, &v, sizeof(bits));
+  if ((bits & 0x7F800000u) == 0x7F800000u) {  // inf/nan pass through
+    bits &= 0xFFFF0000u;
+  } else {
+    const uint32_t lsb = (bits >> 16) & 1u;
+    bits = (bits + 0x7FFFu + lsb) & 0xFFFF0000u;
+  }
+  static_cast<uint16_t*>(p)[i] = static_cast<uint16_t>(bits >> 16);
+}
+
+inline float Load(const void* p, int64_t i, bool bf16) {
+  return bf16 ? LoadBf16(p, i) : static_cast<const float*>(p)[i];
+}
+
+inline void Store(void* p, int64_t i, float v, bool bf16) {
+  if (bf16) {
+    StoreBf16(p, i, v);
+  } else {
+    static_cast<float*>(p)[i] = v;
+  }
+}
+
+// _modulate_scale_shift (minimax_h3_transformer.py:183-192).
+void MiniMaxH3ModulateScaleShift(Queue&, void* x, const void* shift, const void* scale,
+                                 const int32_t* idx, int64_t rows, int64_t width,
+                                 int64_t src_stride, DType dtype) {
+  const bool bf16 = dtype == DType::kBF16;
+  for (int64_t r = 0; r < rows; ++r) {
+    const int64_t row = idx[r];
+    for (int64_t i = 0; i < width; ++i) {
+      const float v = Load(x, r * width + i, bf16) * (1.0f + Load(scale, row * src_stride + i, bf16)) +
+                      Load(shift, row * src_stride + i, bf16);
+      Store(x, r * width + i, v, bf16);
+    }
+  }
+}
+
+// _modulate_gate (minimax_h3_transformer.py:195-204).
+void MiniMaxH3ModulateGate(Queue&, void* residual, const void* gate, const void* other,
+                           const int32_t* idx, int64_t rows, int64_t width, int64_t src_stride,
+                           DType dtype) {
+  const bool bf16 = dtype == DType::kBF16;
+  for (int64_t r = 0; r < rows; ++r) {
+    const int64_t row = idx[r];
+    for (int64_t i = 0; i < width; ++i) {
+      const float v = Load(residual, r * width + i, bf16) +
+                      Load(gate, row * src_stride + i, bf16) * Load(other, r * width + i, bf16);
+      Store(residual, r * width + i, v, bf16);
+    }
+  }
+}
+
+// Matches minimax_h3.cpp's Silu EXACTLY (x / (1 + exp(-x))); the algebraically
+// equivalent x * sigmoid(x) is NOT bit-identical, and this path is gated against
+// the host reference.
+void MiniMaxH3Silu(Queue&, float* x, int64_t n) {
+  for (int64_t i = 0; i < n; ++i) x[i] = x[i] / (1.0f + std::exp(-x[i]));
+}
+
+const vllm::minimax_h3::MiniMaxH3DeviceKernels kKernels{
+    &MiniMaxH3ModulateScaleShift,
+    &MiniMaxH3ModulateGate,
+    &MiniMaxH3Silu,
+};
+
+struct Registrar {
+  Registrar() {
+    RegisterOp(OpId::kMiniMaxH3, DeviceType::kCPU,
+               const_cast<void*>(static_cast<const void*>(&kKernels)));
+  }
+} registrar;
+
+}  // namespace
+}  // namespace vt::cpu
diff --git a/src/vt/cuda/cuda_minimax_h3.cu b/src/vt/cuda/cuda_minimax_h3.cu
new file mode 100644
index 000000000..4f03f7a43
--- /dev/null
+++ b/src/vt/cuda/cuda_minimax_h3.cu
@@ -0,0 +1,164 @@
+// CUDA half of the MiniMax-H3 DiT device-forward glue table (vt::OpId::kMiniMaxH3).
+//
+// Three small ops the shared vt:: surface does not cover; see
+// include/vllm/model_executor/models/minimax_h3_device.h for why the table is this
+// short. Each is a 1:1 CUDA port of the host reference it stands in for
+// (minimax_h3.cpp: ModulateScaleShift / ModulateGate / Silu), and is gated against
+// that reference through the SAME upstream goldens the CPU forward uses.
+//
+// All three are elementwise over independent (row, column) pairs — the indexed
+// AdaLN row lookup is a READ of a shared row, never a write — so a flat
+// grid-stride loop is both correct and the natural shape. There is no reduction
+// here, hence no reduction-order question: these kernels are bit-identical to the
+// CPU sibling. (The device forward as a whole is NOT bit-identical to the CPU
+// reference, but that comes from the tuned SHARED ops it reuses -- notably
+// vt::RmsNorm's f32 reduction vs the reference's double -- not from this file.)
+#include <cuda_runtime.h>
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+
+#include "vllm/model_executor/models/minimax_h3_device.h"
+#include "vt/ops.h"  // OpId, RegisterOp, DeviceType
+
+namespace vllm::minimax_h3 {
+namespace {
+
+using vt::DeviceType;
+using vt::OpId;
+using vt::Queue;
+using vt::RegisterOp;
+
+constexpr int kBlock = 256;
+
+cudaStream_t AsStream(Queue& q) { return static_cast<cudaStream_t>(q.handle); }
+
+unsigned GridFor(int64_t n) {
+  const int64_t blocks = (n + kBlock - 1) / kBlock;
+  const int64_t capped = blocks > 65535 ? 65535 : blocks;
+  return static_cast<unsigned>(capped < 1 ? 1 : capped);
+}
+
+void Check(cudaError_t e, const char* what) {
+  if (e != cudaSuccess) {
+    throw std::runtime_error(std::string("vt cuda minimax_h3: ") + what + ": " +
+                             cudaGetErrorString(e));
+  }
+}
+
+// bf16 is the high 16 bits of the f32 pattern; round-to-nearest-even on store,
+// matching torch's `.to(bfloat16)` and minimax_h3.cpp's RoundBf16. Done with
+// integer ops rather than __nv_bfloat16 converts so the rule is EXACTLY the
+// reference's -- the bf16 gate compares cast points, so a different rounding rule
+// would be indistinguishable from a misplaced cast.
+__device__ __forceinline__ float LoadBf16(const void* p, int64_t i) {
+  return __uint_as_float(static_cast<unsigned int>(static_cast<const unsigned short*>(p)[i]) << 16);
+}
+
+__device__ __forceinline__ void StoreBf16(void* p, int64_t i, float v) {
+  unsigned int bits = __float_as_uint(v);
+  if ((bits & 0x7F800000u) == 0x7F800000u) {
+    bits &= 0xFFFF0000u;
+  } else {
+    const unsigned int lsb = (bits >> 16) & 1u;
+    bits = (bits + 0x7FFFu + lsb) & 0xFFFF0000u;
+  }
+  static_cast<unsigned short*>(p)[i] = static_cast<unsigned short>(bits >> 16);
+}
+
+__device__ __forceinline__ float LoadAny(const void* p, int64_t i, bool bf16) {
+  return bf16 ? LoadBf16(p, i) : static_cast<const float*>(p)[i];
+}
+
+__device__ __forceinline__ void StoreAny(void* p, int64_t i, float v, bool bf16) {
+  if (bf16) {
+    StoreBf16(p, i, v);
+  } else {
+    static_cast<float*>(p)[i] = v;
+  }
+}
+
+// _modulate_scale_shift (minimax_h3_transformer.py:183-192):
+//   x[r, i] = x[r, i] * (1 + scale[idx[r], i]) + shift[idx[r], i]
+__global__ void ModulateScaleShiftKernel(void* x, const void* shift, const void* scale,
+                                         const int32_t* idx, int64_t rows, int64_t width,
+                                         int64_t src_stride, bool bf16) {
+  const int64_t n = rows * width;
+  const int64_t step = static_cast<int64_t>(gridDim.x) * blockDim.x;
+  for (int64_t t = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x; t < n; t += step) {
+    const int64_t r = t / width, i = t % width;
+    const int64_t row = idx[r];
+    const float v = LoadAny(x, t, bf16) * (1.0f + LoadAny(scale, row * src_stride + i, bf16)) +
+                    LoadAny(shift, row * src_stride + i, bf16);
+    StoreAny(x, t, v, bf16);
+  }
+}
+
+// _modulate_gate (minimax_h3_transformer.py:195-204):
+//   residual[r, i] += gate[idx[r], i] * other[r, i]
+__global__ void ModulateGateKernel(void* residual, const void* gate, const void* other,
+                                   const int32_t* idx, int64_t rows, int64_t width,
+                                   int64_t src_stride, bool bf16) {
+  const int64_t n = rows * width;
+  const int64_t step = static_cast<int64_t>(gridDim.x) * blockDim.x;
+  for (int64_t t = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x; t < n; t += step) {
+    const int64_t r = t / width, i = t % width;
+    const int64_t row = idx[r];
+    const float v = LoadAny(residual, t, bf16) +
+                    LoadAny(gate, row * src_stride + i, bf16) * LoadAny(other, t, bf16);
+    StoreAny(residual, t, v, bf16);
+  }
+}
+
+// x / (1 + exp(-x)) -- the SAME form as the host Silu, not the algebraically
+// equivalent x * sigmoid(x), which would not reproduce its bits. expf, NOT the
+// __expf fast intrinsic, for the same reason.
+__global__ void SiluKernel(float* x, int64_t n) {
+  const int64_t step = static_cast<int64_t>(gridDim.x) * blockDim.x;
+  for (int64_t t = static_cast<int64_t>(blockIdx.x) * blockDim.x + threadIdx.x; t < n; t += step) {
+    x[t] = x[t] / (1.0f + expf(-x[t]));
+  }
+}
+
+void ModulateScaleShiftCuda(Queue& q, void* x, const void* shift, const void* scale,
+                            const int32_t* idx, int64_t rows, int64_t width, int64_t src_stride,
+                            vt::DType dtype) {
+  const int64_t n = rows * width;
+  if (n == 0) return;
+  ModulateScaleShiftKernel<<<GridFor(n), kBlock, 0, AsStream(q)>>>(
+      x, shift, scale, idx, rows, width, src_stride, dtype == vt::DType::kBF16);
+  Check(cudaGetLastError(), "modulate_scale_shift launch");
+}
+
+void ModulateGateCuda(Queue& q, void* residual, const void* gate, const void* other,
+                      const int32_t* idx, int64_t rows, int64_t width, int64_t src_stride,
+                      vt::DType dtype) {
+  const int64_t n = rows * width;
+  if (n == 0) return;
+  ModulateGateKernel<<<GridFor(n), kBlock, 0, AsStream(q)>>>(
+      residual, gate, other, idx, rows, width, src_stride, dtype == vt::DType::kBF16);
+  Check(cudaGetLastError(), "modulate_gate launch");
+}
+
+void SiluCuda(Queue& q, float* x, int64_t n) {
+  if (n == 0) return;
+  SiluKernel<<<GridFor(n), kBlock, 0, AsStream(q)>>>(x, n);
+  Check(cudaGetLastError(), "silu launch");
+}
+
+const MiniMaxH3DeviceKernels kKernels{
+    &ModulateScaleShiftCuda,
+    &ModulateGateCuda,
+    &SiluCuda,
+};
+
+struct Registrar {
+  Registrar() {
+    RegisterOp(OpId::kMiniMaxH3, DeviceType::kCUDA,
+               const_cast<void*>(static_cast<const void*>(&kKernels)));
+  }
+} registrar;
+
+}  // namespace
+}  // namespace vllm::minimax_h3
diff --git a/src/vt/cuda/cuda_ops.cu b/src/vt/cuda/cuda_ops.cu
index a95e502bd..6b4494e39 100644
--- a/src/vt/cuda/cuda_ops.cu
+++ b/src/vt/cuda/cuda_ops.cu
@@ -44,6 +44,40 @@ __device__ inline void Store(__nv_bfloat16* p, int64_t i, float v) {
   p[i] = __float2bfloat16(v);  // round-to-nearest-even, same as host F32ToBF16
 }
 
+// VECTOR load of N CONSECUTIVE elements into f32, for the attention inner loops.
+// N is a compile-time width, so N==4/2 collapse to one LDG.128/LDG.64 (f32) or
+// LDG.64/LDG.32 (bf16) instead of N separate scalar loads. Callers guarantee the
+// element offset is a multiple of N, which is what makes the wide load legal.
+template <int N>
+__device__ inline void LoadVec(const float* p, int64_t i, float* o) {
+  if (N == 4) {
+    const float4 v = *reinterpret_cast<const float4*>(p + i);
+    o[0] = v.x; o[1] = v.y; o[2] = v.z; o[3] = v.w;
+  } else if (N == 2) {
+    const float2 v = *reinterpret_cast<const float2*>(p + i);
+    o[0] = v.x; o[1] = v.y;
+  } else {
+#pragma unroll
+    for (int c = 0; c < N; ++c) o[c] = p[i + c];
+  }
+}
+template <int N>
+__device__ inline void LoadVec(const __nv_bfloat16* p, int64_t i, float* o) {
+  if (N == 4) {
+    const uint2 raw = *reinterpret_cast<const uint2*>(p + i);
+    const float2 a = __bfloat1622float2(*reinterpret_cast<const __nv_bfloat162*>(&raw.x));
+    const float2 b = __bfloat1622float2(*reinterpret_cast<const __nv_bfloat162*>(&raw.y));
+    o[0] = a.x; o[1] = a.y; o[2] = b.x; o[3] = b.y;
+  } else if (N == 2) {
+    const unsigned raw = *reinterpret_cast<const unsigned*>(p + i);
+    const float2 a = __bfloat1622float2(*reinterpret_cast<const __nv_bfloat162*>(&raw));
+    o[0] = a.x; o[1] = a.y;
+  } else {
+#pragma unroll
+    for (int c = 0; c < N; ++c) o[c] = __bfloat162float(p[i + c]);
+  }
+}
+
 // Round-trip a f32 value through the residual store dtype so the variance below
 // squares the SAME rounded value that gets written back to the residual stream —
 // mirrors vLLM fused_add_rms_norm, whose bf16 residual add (`z += residual`) rounds
@@ -1583,6 +1617,1007 @@ __global__ void DFlashBlockAttentionKernel(Tout* out, const Tin* query, const Ti
   for (int64_t e = threadIdx.x; e < d; e += blockDim.x) Store(out, qoff + e, acc[e] * inv);
 }
 
+// WARP-PER-QUERY fast path for the common head_dim (a multiple of the warp width).
+//
+// The general kernel above spends one block per query row and walks keys ONE AT A
+// TIME, doing a shared-memory tree reduction plus ~11 __syncthreads() PER KEY. At
+// seq 3264 that is ~36k barriers per query row, and Q is re-read from global for
+// every key — measured ~36 GFLOP/s, which made attention dominate everything at
+// realistic sequence lengths.
+//
+// Here ONE WARP owns a query row: Q and the output accumulator live in REGISTERS
+// (d/32 each per lane), the dot product is a warp shuffle reduction, and the online
+// softmax runs inside the warp. No __syncthreads at all, and Q is read once.
+//
+// The arithmetic is deliberately IDENTICAL to the general kernel — same sequential
+// key order, same online-softmax recurrence (m/corr/p/l), same f32 accumulation — so
+// this is a scheduling change, not a numerics change.
+// Q-BLOCKED warp attention: one warp carries kQ queries at once.
+//
+// *** MEASURED NEGATIVE ON sm_110 AND DELIBERATELY NOT DISPATCHED. Do not wire
+// *** this up again on this hardware without re-reading the numbers below.
+//
+// The idea: the one-query-per-warp kernel re-reads every K and V row for EVERY
+// query, so global traffic is O(seq^2 * d) per head -- ~341 TB per step at H3's
+// default canvas (seq 15424, 56 heads, 50 layers, d 64) against Thor's 273 GB/s.
+// Holding kQ queries per warp loads each K/V row ONCE and reuses it kQ times.
+//
+// It was dispatched, gated (all five DFlash/attention suites green at kQ 4 and 8,
+// with a RED proof that the kernel really produced the output) and MEASURED on the
+// real H3 denoise loop, 2 paired reps per arm, order reversed between reps:
+//
+//   864x480/124f, seq 15424:  per-query 557.80 s   kQ=4 553.14 s (-0.84%)   kQ=8 765.57 s (+37%)
+//   512x512/33f,  seq  3264:  per-query  28.04 s   kQ=4  28.98 s (+3.3%)    kQ=8  36.33 s (+30%)
+//
+// So the premise is WRONG here, and the reason is the same one that killed the
+// shared-memory tiling attempt: the K/V re-reads were never coming from HBM. One
+// head's K+V at seq 15424 is 15424*64*2*2 B = 3.9 MB against Thor's 32 MB L2, and
+// every warp on a given blockIdx.y streams the SAME rows, so the traffic this
+// kernel removes was already L2-resident and nearly free. What it does NOT remove
+// is the per-key warp-shuffle reduction -- it still performs kQ of them per K row
+// loaded, i.e. exactly as many in total as before. It only adds cost: registers go
+// 64 -> 108 (kQ 4 -> 8) at kPerLane 2, which cuts occupancy, and the kQ online-
+// softmax updates per key form a serial expf dependency chain, which is why kQ=8
+// is far worse than kQ=4 rather than twice as good.
+//
+// Kept as source (it compiles to nothing while uninstantiated) because the
+// conclusion is HARDWARE-SPECIFIC: on a part with a small L2 relative to one head's
+// K/V the arithmetic could flip. Full disposition in docs/BENCHMARKS.md.
+//
+// Deliberately uses NO SHARED MEMORY. A previous attempt staged K/V tiles in
+// shared and measured 23% SLOWER: 32 KB per block against Thor's 48 KB/block limit
+// allowed ~one block per SM and occupancy collapsed. Registers cost nothing here --
+// kQ * kPerLane accumulators plus the same for Q, which fits comfortably.
+//
+// Per-query key ranges are computed up front, so causal, sliding-window and
+// multi-request layouts all work: the mask is warp-UNIFORM for each query (j, qs,
+// qe and ii are all warp-wide), so the skip costs no divergence.
+//
+// Arithmetic is unchanged -- same sequential key order, same online-softmax
+// recurrence, same f32 accumulation -- so this is a scheduling change.
+template <typename Tin, typename Tout, int kPerLane, int kQ>
+__global__ void DFlashAttnQBlockKernel(Tout* out, const Tin* query, const Tin* key,
+                                       const Tin* value, const int32_t* cu, int num_reqs,
+                                       int64_t rows, int64_t hq, int64_t hk, int64_t d,
+                                       float scale, bool causal, int64_t window) {
+  const int lane = threadIdx.x & 31;
+  const int64_t wid =
+      (static_cast<int64_t>(blockIdx.x) * (blockDim.x >> 5)) + (threadIdx.x >> 5);
+  const int64_t i0 = wid * kQ;
+  if (i0 >= rows) return;
+  const int64_t h = blockIdx.y;
+  const int64_t g = h / (hq / hk);
+
+  float qreg[kQ][kPerLane], acc[kQ][kPerLane], m[kQ], l[kQ];
+  int64_t jlo[kQ], jhi[kQ];
+  bool act[kQ];
+  int64_t lo = rows, hi = 0;
+
+#pragma unroll
+  for (int u = 0; u < kQ; ++u) {
+    const int64_t i = i0 + u;
+    act[u] = (i < rows);
+    m[u] = -CUDART_INF_F;
+    l[u] = 0.0f;
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) acc[u][c] = 0.0f;
+    jlo[u] = 0;
+    jhi[u] = -1;
+    if (!act[u]) continue;
+    int64_t qs = 0, qe = rows;
+    for (int r = 0; r < num_reqs; ++r) {
+      if (i >= cu[r] && i < cu[r + 1]) { qs = cu[r]; qe = cu[r + 1]; break; }
+    }
+    const int64_t ii = i - qs;
+    const int64_t rel_hi = causal ? ii : (qe - qs - 1);
+    int64_t rel_lo = 0;
+    if (causal && window > 0) rel_lo = (ii - (window - 1) > 0) ? ii - (window - 1) : 0;
+    jlo[u] = qs + rel_lo;
+    jhi[u] = qs + rel_hi;
+    lo = min(lo, jlo[u]);
+    hi = max(hi, jhi[u]);
+    const int64_t qoff = (i * hq + h) * d;
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) {
+      qreg[u][c] = Load(query, qoff + static_cast<int64_t>(c) * 32 + lane);
+    }
+  }
+  if (hi < lo) return;
+
+  for (int64_t j = lo; j <= hi; ++j) {
+    const int64_t koff = (j * hk + g) * d;
+    float kreg[kPerLane], vreg[kPerLane];
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) {
+      kreg[c] = Load(key, koff + static_cast<int64_t>(c) * 32 + lane);
+      vreg[c] = Load(value, koff + static_cast<int64_t>(c) * 32 + lane);
+    }
+#pragma unroll
+    for (int u = 0; u < kQ; ++u) {
+      if (!act[u] || j < jlo[u] || j > jhi[u]) continue;  // warp-uniform
+      float part = 0.0f;
+#pragma unroll
+      for (int c = 0; c < kPerLane; ++c) part += qreg[u][c] * kreg[c];
+#pragma unroll
+      for (int off = 16; off > 0; off >>= 1) part += __shfl_down_sync(0xFFFFFFFFu, part, off);
+      const float s = __shfl_sync(0xFFFFFFFFu, part, 0) * scale;
+      const float m_new = fmaxf(m[u], s);
+      const float corr = expf(m[u] - m_new);
+      const float pw = expf(s - m_new);
+#pragma unroll
+      for (int c = 0; c < kPerLane; ++c) acc[u][c] = acc[u][c] * corr + pw * vreg[c];
+      l[u] = l[u] * corr + pw;
+      m[u] = m_new;
+    }
+  }
+
+#pragma unroll
+  for (int u = 0; u < kQ; ++u) {
+    if (!act[u] || l[u] == 0.0f) continue;
+    const int64_t qoff = ((i0 + u) * hq + h) * d;
+    const float inv = 1.0f / l[u];
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) {
+      Store(out, qoff + static_cast<int64_t>(c) * 32 + lane, acc[u][c] * inv);
+    }
+  }
+}
+
+template <typename Tin, typename Tout, int kPerLane>
+__global__ void DFlashBlockAttentionWarpKernel(Tout* out, const Tin* query, const Tin* key,
+                                              const Tin* value, const int32_t* cu, int num_reqs,
+                                              int64_t hq, int64_t hk, int64_t d, float scale,
+                                              bool causal, int64_t window) {
+  const int lane = threadIdx.x & 31;
+  const int64_t warp_id =
+      (static_cast<int64_t>(blockIdx.x) * (blockDim.x >> 5)) + (threadIdx.x >> 5);
+  const int64_t total = gridDim.y;  // unused; kept for symmetry with the grid below
+  (void)total;
+  const int64_t i = warp_id;        // GLOBAL query row
+  const int64_t h = blockIdx.y;     // q-head
+  const int64_t rows = cu[num_reqs];
+  if (i >= rows) return;
+  const int64_t g = h / (hq / hk);
+
+  int64_t qs = 0, qe = 0;
+  for (int r = 0; r < num_reqs; ++r) {
+    if (i >= cu[r] && i < cu[r + 1]) {
+      qs = cu[r];
+      qe = cu[r + 1];
+      break;
+    }
+  }
+  const int64_t ii = i - qs;
+  const int64_t jhi = causal ? ii : (qe - qs - 1);
+  int64_t jlo = 0;
+  if (causal && window > 0) jlo = ii - (window - 1) > 0 ? ii - (window - 1) : 0;
+  const int64_t qoff = (i * hq + h) * d;
+
+  // Q and the accumulator in registers: lane L holds elements L, L+32, L+64, ...
+  float qreg[kPerLane], acc[kPerLane];
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) {
+    qreg[c] = Load(query, qoff + static_cast<int64_t>(c) * 32 + lane);
+    acc[c] = 0.0f;
+  }
+  float m = -CUDART_INF_F, l = 0.0f;
+
+  for (int64_t jj = jlo; jj <= jhi; ++jj) {
+    const int64_t koff = ((qs + jj) * hk + g) * d;
+    float part = 0.0f;
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) {
+      part += qreg[c] * Load(key, koff + static_cast<int64_t>(c) * 32 + lane);
+    }
+#pragma unroll
+    for (int off = 16; off > 0; off >>= 1) part += __shfl_down_sync(0xFFFFFFFFu, part, off);
+    float s = __shfl_sync(0xFFFFFFFFu, part, 0) * scale;
+
+    const float m_new = fmaxf(m, s);
+    const float corr = expf(m - m_new);
+    const float pw = expf(s - m_new);
+    const int64_t voff = ((qs + jj) * hk + g) * d;
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) {
+      acc[c] = acc[c] * corr + pw * Load(value, voff + static_cast<int64_t>(c) * 32 + lane);
+    }
+    l = l * corr + pw;
+    m = m_new;
+  }
+
+  const float inv = 1.0f / l;
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) {
+    Store(out, qoff + static_cast<int64_t>(c) * 32 + lane, acc[c] * inv);
+  }
+}
+
+// VT_DFLASH_ATTN_WARP=1 falls back to the older per-key warp-reduction kernel, so
+// the two forms can be A/B'd on ONE binary (same-binary A/B is the benchmark
+// protocol here). Cached once; getenv is not hot-path-safe.
+inline bool UseDflashAttnWarpKernel() {
+  static const bool on = [] {
+    const char* e = std::getenv("VT_DFLASH_ATTN_WARP");
+    return e != nullptr && e[0] == '1';
+  }();
+  return on;
+}
+
+// VT_DFLASH_ATTN_KEYLANE=1 selects the MEASURED-NEGATIVE one-key-per-lane form
+// (kept for the same-binary 3-way A/B that recorded the verdict).
+inline bool UseDflashAttnKeyLaneKernel() {
+  static const bool on = [] {
+    const char* e = std::getenv("VT_DFLASH_ATTN_KEYLANE");
+    return e != nullptr && e[0] == '1';
+  }();
+  return on;
+}
+
+// ---------------------------------------------------------------------------
+// TWO-PHASE, ONE-KEY-PER-LANE attention.
+//
+// *** MEASURED NEGATIVE ON sm_110: 28.90 s/step against 18.73 s/step for the
+// *** per-key warp kernel on the SAME binary (H3 --denoise-only, 512x512/33f,
+// *** seq 3224, 3 steps) -- 54% SLOWER. NOT the default; reachable only via
+// *** VT_DFLASH_ATTN_KEYLANE=1. It is kept because it is the experiment that
+// *** located the real constraint, and the reason is recorded below.
+// ***
+// *** WHY IT LOST. Giving each lane a WHOLE K row removes the cross-lane
+// *** reduction, exactly as intended -- but it also makes every K load
+// *** instruction 32-WAY SCATTERED (lane L addresses row base+L, one 32-byte
+// *** sector per lane, ~32 sectors per instruction against 2-4 for a coalesced
+// *** one). The rows are L1-resident so nothing goes to HBM, yet the load/store
+// *** unit still replays every one of those addresses, and the work simply moved
+// *** from the shuffle pipe to the memory pipe. The lesson is the one the
+// *** SUCCESSOR kernel below is built on: kill the per-key reduction WITHOUT
+// *** giving up lane==element coalescing.
+//
+// WHY IT WAS TRIED. The warp-per-query kernel above is 47x slower than this
+// file's own GEMMs
+// on the same chip: MEASURED 0.63 TFLOP/s of attention against 30.0 TFLOP/s of
+// cuBLASLt GEMM and a ~7.7 TFLOP/s CUDA-core f32 ceiling. Two causes, neither of
+// them memory:
+//
+//   (1) ~32% of its instructions are USEFUL. Per (query,key) pair a lane does
+//       d/32 (= 2 at H3's head_dim 64) FMAs and then a FIVE-STAGE
+//       __shfl_down_sync tree plus a broadcast to collapse them to one scalar.
+//   (2) A SERIAL DEPENDENCY CHAIN. Every key's (m, l, acc) update reads the
+//       previous key's, so the warp is LATENCY-bound: ~8% of the CUDA-core
+//       ceiling rather than the ~32% its instruction mix would allow.
+//
+// This kernel removes both. One warp still owns one query row, but keys are
+// processed 32 AT A TIME in two phases with a different lane->data mapping in
+// each, and NEITHER phase contains a cross-lane reduction of a dot product:
+//
+//   Phase A -- LANE == KEY. Lane L computes the WHOLE dot product for key
+//     base+L by looping all d elements. Q comes from SHARED, where every lane
+//     reads the SAME address (a broadcast, free). Each lane owns a complete
+//     score, so there is nothing to reduce. K is strided ACROSS lanes but each
+//     lane streams its own row contiguously in 4-element vector loads; the 32
+//     live rows are ~4-8 KB, i.e. L1-resident, so the strided form costs
+//     nothing here.
+//   Then ONE warp max + ONE warp sum + ONE online-softmax update per 32 keys.
+//     That is the 32x shortening of the dependency chain.
+//   Phase B -- LANE == ELEMENT. Lane L owns the CONTIGUOUS element block
+//     [L*kPerLane, (L+1)*kPerLane) and loops the 32 probabilities (broadcast
+//     from shared), so V loads are COALESCED and vectorized, and again no lane
+//     ever reduces against another.
+//
+// Useful-FMA accounting per 32 keys per warp: d (phase A) + d (phase B) = 2d
+// FMA instructions, against ~800 total instructions for the same work before.
+//
+// MEMORY IS NOT THE BOUND, AND TWO EARLIER ATTEMPTS PROVED IT. Shared-memory K/V
+// tiling measured 23% SLOWER (32 KB/block against Thor's 48 KB limit collapsed
+// occupancy) and register Q-blocking measured -0.84% at seq 15424 / +3.3% at seq
+// 3264 (DFlashAttnQBlockKernel above). One head's K+V at seq 15424 is 3.9 MB
+// against a 32 MB L2, so the traffic those attempts removed was already free.
+// This kernel therefore keeps its shared footprint DELIBERATELY TINY -- q (d
+// floats) + p (32 floats) per warp, ~5 KB for a 8-warp block at d=128 -- so
+// occupancy stays where the warp kernel had it.
+//
+// NUMERICS. Chunked max/sum is mathematically the same softmax but NOT bitwise
+// identical to the per-key recurrence (fewer rescalings, pairwise accumulation
+// inside a chunk -- if anything better conditioned). Gated on tolerance against
+// the CPU reference, not on bit-equality.
+//
+// MASKS. jlo/jhi are per-query GLOBAL key bounds computed exactly as the warp
+// kernel computes them, so non-causal, causal, sliding-window and multi-request
+// (cu_seqlens) layouts all work, including a warp whose neighbours live in a
+// different document -- each warp is independent, and a partial final chunk is
+// handled by the `valid` predicate rather than by a shape guard. (A previous
+// long-sequence kernel here was guarded to num_reqs == 1 and so silently never
+// ran on H3's packed {0, used, seq_len} TWO-document layout while the suite
+// stayed green; there is no such guard in this one.)
+template <typename Tin, typename Tout, int kPerLane>
+__global__ void DFlashAttnKeyLaneKernel(Tout* out, const Tin* query, const Tin* key,
+                                        const Tin* value, const int32_t* cu, int num_reqs,
+                                        int64_t hq, int64_t hk, float scale, bool causal,
+                                        int64_t window) {
+  constexpr int kD = kPerLane * 32;  // head_dim, compile-time (dispatch guarantees it)
+  extern __shared__ float dfa_smem[];
+
+  const int lane = threadIdx.x & 31;
+  const int warp = static_cast<int>(threadIdx.x >> 5);
+  const int warps = static_cast<int>(blockDim.x >> 5);
+  float* qsh = dfa_smem + static_cast<size_t>(warp) * (kD + 32);
+  float* psh = qsh + kD;
+
+  const int64_t i = static_cast<int64_t>(blockIdx.x) * warps + warp;  // GLOBAL query row
+  const int64_t rows = cu[num_reqs];
+  if (i >= rows) return;  // whole-warp exit; this kernel never uses __syncthreads
+  const int64_t h = blockIdx.y;
+  const int64_t g = h / (hq / hk);
+
+  int64_t qs = 0, qe = 0;
+  for (int r = 0; r < num_reqs; ++r) {
+    if (i >= cu[r] && i < cu[r + 1]) {
+      qs = cu[r];
+      qe = cu[r + 1];
+      break;
+    }
+  }
+  const int64_t ii = i - qs;
+  const int64_t jhi = qs + (causal ? ii : (qe - qs - 1));  // last visible GLOBAL key
+  int64_t jlo = qs;
+  if (causal && window > 0) jlo = qs + (ii - (window - 1) > 0 ? ii - (window - 1) : 0);
+
+  const int64_t qoff = (i * hq + h) * kD;
+  for (int e = lane; e < kD; e += 32) qsh[e] = Load(query, qoff + e);
+  __syncwarp();
+
+  float acc[kPerLane];
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) acc[c] = 0.0f;
+  float m = -CUDART_INF_F, l = 0.0f;
+
+  const int64_t ebase = static_cast<int64_t>(lane) * kPerLane;  // this lane's element block
+
+  for (int64_t base = jlo; base <= jhi; base += 32) {
+    // ---- Phase A: lane == key. One FULL dot product per lane, no reduction. --
+    const int64_t j = base + lane;
+    const bool valid = (j <= jhi);
+    float s = -CUDART_INF_F;
+    if (valid) {
+      const int64_t koff = (j * hk + g) * kD;
+      float a0 = 0.0f, a1 = 0.0f, a2 = 0.0f, a3 = 0.0f;  // 4 independent FMA chains
+#pragma unroll
+      for (int c = 0; c < kD; c += 4) {
+        float qv[4], kv[4];
+        LoadVec<4>(qsh, static_cast<int64_t>(c), qv);
+        LoadVec<4>(key, koff + c, kv);
+        a0 += qv[0] * kv[0];
+        a1 += qv[1] * kv[1];
+        a2 += qv[2] * kv[2];
+        a3 += qv[3] * kv[3];
+      }
+      s = ((a0 + a1) + (a2 + a3)) * scale;
+    }
+
+    // ---- ONE online-softmax update per 32 keys (the dependency-chain fix). ---
+    float mx = s;
+#pragma unroll
+    for (int off = 16; off > 0; off >>= 1) mx = fmaxf(mx, __shfl_xor_sync(0xFFFFFFFFu, mx, off));
+    const float m_new = fmaxf(m, mx);  // mx is finite: lane 0 of every chunk is valid
+    const float corr = expf(m - m_new);
+    const float p = valid ? expf(s - m_new) : 0.0f;
+    float sum = p;
+#pragma unroll
+    for (int off = 16; off > 0; off >>= 1) sum += __shfl_xor_sync(0xFFFFFFFFu, sum, off);
+    l = l * corr + sum;
+    m = m_new;
+
+    psh[lane] = p;
+    __syncwarp();
+
+    // ---- Phase B: lane == element. Coalesced V, probabilities broadcast. ----
+    const int cnt = static_cast<int>(jhi - base + 1) < 32 ? static_cast<int>(jhi - base + 1) : 32;
+    float t0[kPerLane], t1[kPerLane];
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) { t0[c] = 0.0f; t1[c] = 0.0f; }
+    int jj = 0;
+    for (; jj + 1 < cnt; jj += 2) {
+      float v0[kPerLane], v1[kPerLane];
+      LoadVec<kPerLane>(value, ((base + jj) * hk + g) * kD + ebase, v0);
+      LoadVec<kPerLane>(value, ((base + jj + 1) * hk + g) * kD + ebase, v1);
+      const float p0 = psh[jj], p1 = psh[jj + 1];
+#pragma unroll
+      for (int c = 0; c < kPerLane; ++c) {
+        t0[c] += p0 * v0[c];
+        t1[c] += p1 * v1[c];
+      }
+    }
+    if (jj < cnt) {
+      float v0[kPerLane];
+      LoadVec<kPerLane>(value, ((base + jj) * hk + g) * kD + ebase, v0);
+      const float p0 = psh[jj];
+#pragma unroll
+      for (int c = 0; c < kPerLane; ++c) t0[c] += p0 * v0[c];
+    }
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) acc[c] = acc[c] * corr + (t0[c] + t1[c]);
+    __syncwarp();  // psh is rewritten by the next chunk
+  }
+
+  const float inv = 1.0f / l;
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) Store(out, qoff + ebase + c, acc[c] * inv);
+}
+
+// The per-lane ELEMENT PARTITION used by the chunked attention kernel. Any
+// partition of the head_dim across the 32 lanes computes the same dot product,
+// so the only thing that matters is which one loads FASTEST:
+//
+//   kPerLane 2 or 4 -> CONTIGUOUS blocks ([L*n, (L+1)*n)). One vector load per
+//     lane covers the whole block, the warp reads 32*n consecutive elements, and
+//     the access is perfectly coalesced with n-times FEWER instructions.
+//   otherwise (1, 3) -> STRIDED (elements L, L+32, L+64...). A contiguous block
+//     of 3 would make each warp instruction read at a 3-element stride, spanning
+//     ~3x the sectors it needs; strided scalar loads stay perfectly coalesced.
+//     head_dim 96 -- MiniMax-H3's production shape, 5376/56 -- lands here.
+//
+// Q, K, V and the output all use the SAME partition, so it never escapes the
+// kernel.
+template <int N, typename T>
+__device__ inline void LoadLane(const T* p, int64_t row, int lane, float* o) {
+  if (N == 2 || N == 4) {
+    LoadVec<N>(p, row + static_cast<int64_t>(lane) * N, o);
+  } else {
+#pragma unroll
+    for (int c = 0; c < N; ++c) o[c] = Load(p, row + static_cast<int64_t>(c) * 32 + lane);
+  }
+}
+template <int N, typename T>
+__device__ inline void StoreLane(T* p, int64_t row, int lane, const float* v) {
+  if (N == 2 || N == 4) {
+#pragma unroll
+    for (int c = 0; c < N; ++c) Store(p, row + static_cast<int64_t>(lane) * N + c, v[c]);
+  } else {
+#pragma unroll
+    for (int c = 0; c < N; ++c) Store(p, row + static_cast<int64_t>(c) * 32 + lane, v[c]);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CHUNKED attention with a warp REDUCE-SCATTER (the D15 default).
+//
+// This is the kernel that actually beats the per-key warp form. It keeps that
+// kernel's COALESCED lane==element loads -- which is what killed the key-lane
+// variant above -- and attacks the two things the diagnosis actually named: the
+// per-key cross-lane REDUCTION and the per-key SERIAL DEPENDENCY CHAIN.
+//
+// Per warp = one query row; keys are processed 32 AT A TIME:
+//
+//   1. For each of the 32 keys in the chunk, every lane computes its PARTIAL of
+//      the dot product from the kPerLane elements it owns -- a plain coalesced
+//      vector load, exactly as before, but the partial is KEPT IN A REGISTER
+//      instead of being reduced immediately. After the chunk each lane holds a
+//      32-entry partial vector p[], indexed only by compile-time constants so it
+//      stays in registers.
+//   2. ONE butterfly REDUCE-SCATTER (5 rounds, 16+8+4+2+1 = 31 shuffles) turns
+//      that 32x32 partial matrix into "lane L holds the complete score for key
+//      base+L". The per-key form needs 5 shuffles + a broadcast for EVERY key,
+//      i.e. 192 shuffles per 32 keys; this needs 31. Each round exchanges only
+//      the half of the live range the partner is responsible for, so the array
+//      indices stay compile-time (a lane-dependent SELECT, never a
+//      lane-dependent INDEX -- a dynamic index into p[] would spill it to local
+//      memory and lose everything).
+//   3. ONE online-softmax update per 32 keys instead of 32: one warp max, one
+//      warp sum, TWO expf calls per chunk against 64. That is the 32x shortening
+//      of the (m, l, acc) dependency chain, which is why the old kernel sat at
+//      ~8% of the CUDA-core ceiling rather than the ~32% its instruction mix
+//      allowed -- it was latency-bound, not throughput-bound.
+//   4. The 32 probabilities go through shared (32 floats per warp, a broadcast
+//      read) and V is accumulated with the same coalesced lane==element mapping,
+//      into TWO alternating accumulator sets so the FMA chain has ILP.
+//
+// The element mapping is whichever of contiguous/strided LOADS FASTEST for the
+// head_dim (see LoadLane above): contiguous vector loads at head_dim 64/128,
+// strided scalar loads at 96 -- H3's production shape -- where a contiguous
+// 3-element block would span ~3x the sectors it needs.
+//
+// MEMORY IS NOT THE BOUND -- THREE MEASUREMENTS SAY SO. Shared-memory K/V
+// tiling: 23% SLOWER (32 KB/block against Thor's 48 KB limit collapsed
+// occupancy). Register Q-blocking: -0.84% at seq 15424, +3.3% at seq 3264
+// (DFlashAttnQBlockKernel above). One-key-per-lane with Q in shared
+// (DFlashAttnKeyLaneKernel above): 54% SLOWER, because giving each lane a whole
+// K row makes every load instruction 32-way scattered -- it removes the
+// reduction but pays for it in the load/store pipe. One head's K+V at seq 15424
+// is 3.9 MB against a 32 MB L2, so K/V were never coming from HBM in the first
+// place. This kernel therefore changes NOTHING about where K and V come from,
+// and its shared footprint is 32 floats per warp.
+//
+// NUMERICS. Chunked max/sum is the same softmax but not bitwise identical to the
+// per-key recurrence (far fewer rescalings, pairwise accumulation within a
+// chunk -- if anything better conditioned). Gated on tolerance against the CPU
+// reference.
+//
+// MASKS. jlo/jhi are the per-query GLOBAL key bounds, computed exactly as the
+// per-key kernel computes them, so non-causal, causal, sliding-window and
+// multi-request (cu_seqlens) layouts all work, including warps whose neighbours
+// live in a different document. Full chunks and the partial tail chunk run the
+// SAME body under a compile-time kFull flag: the tail clamps its row index to
+// stay in bounds and zeroes the out-of-range probabilities, so there is no
+// shape guard anywhere. (A previous long-sequence kernel here was guarded to
+// num_reqs == 1 and therefore silently never ran on H3's packed
+// {0, used, seq_len} TWO-document layout while the suite stayed green.)
+template <typename Tin, int kPerLane, bool kFull>
+__device__ inline void DFlashAttnChunk(const Tin* key, const Tin* value, int64_t base, int cnt,
+                                       int64_t hk, int64_t g, int lane, const float* qreg,
+                                       float scale, float* psh, float& m, float& l, float* acc) {
+  constexpr int kD = kPerLane * 32;
+
+  // (1) Per-key partials, coalesced, kept in registers.
+  float p[32];
+#pragma unroll
+  for (int t = 0; t < 32; ++t) {
+    const int ti = kFull ? t : (t < cnt ? t : cnt - 1);  // clamp keeps loads in bounds
+    float kv[kPerLane];
+    LoadLane<kPerLane>(key, ((base + ti) * hk + g) * kD, lane, kv);
+    float d0 = 0.0f;
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) d0 += qreg[c] * kv[c];
+    p[t] = (kFull || t < cnt) ? d0 : 0.0f;
+  }
+
+  // (2) Butterfly reduce-scatter: 31 shuffles total; lane L ends with key L.
+#pragma unroll
+  for (int half = 16; half >= 1; half >>= 1) {
+    const bool hi = (lane & half) != 0;
+#pragma unroll
+    for (int t = 0; t < half; ++t) {
+      const float send = hi ? p[t] : p[t + half];
+      const float keep = hi ? p[t + half] : p[t];
+      p[t] = keep + __shfl_xor_sync(0xFFFFFFFFu, send, half);
+    }
+  }
+
+  // (3) ONE online-softmax update for the whole chunk.
+  float s = p[0] * scale;
+  const bool live = kFull || (lane < cnt);
+  if (!live) s = -CUDART_INF_F;
+  float mx = s;
+#pragma unroll
+  for (int off = 16; off > 0; off >>= 1) mx = fmaxf(mx, __shfl_xor_sync(0xFFFFFFFFu, mx, off));
+  const float m_new = fmaxf(m, mx);  // mx is finite: lane 0 of every chunk is live
+  const float corr = expf(m - m_new);
+  const float pv = live ? expf(s - m_new) : 0.0f;
+  float sum = pv;
+#pragma unroll
+  for (int off = 16; off > 0; off >>= 1) sum += __shfl_xor_sync(0xFFFFFFFFu, sum, off);
+  l = l * corr + sum;
+  m = m_new;
+
+  psh[lane] = pv;
+  __syncwarp();
+
+  // (4) V accumulation, same coalesced mapping, two interleaved FMA chains.
+  float t0[kPerLane], t1[kPerLane];
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) { t0[c] = 0.0f; t1[c] = 0.0f; }
+#pragma unroll
+  for (int t = 0; t < 32; t += 2) {
+    const int i0 = kFull ? t : (t < cnt ? t : cnt - 1);
+    const int i1 = kFull ? (t + 1) : (t + 1 < cnt ? t + 1 : cnt - 1);
+    float v0[kPerLane], v1[kPerLane];
+    LoadLane<kPerLane>(value, ((base + i0) * hk + g) * kD, lane, v0);
+    LoadLane<kPerLane>(value, ((base + i1) * hk + g) * kD, lane, v1);
+    const float p0 = psh[t], p1 = psh[t + 1];  // 0 beyond cnt, so the clamp is harmless
+#pragma unroll
+    for (int c = 0; c < kPerLane; ++c) {
+      t0[c] += p0 * v0[c];
+      t1[c] += p1 * v1[c];
+    }
+  }
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) acc[c] = acc[c] * corr + (t0[c] + t1[c]);
+  __syncwarp();  // psh is rewritten by the next chunk
+}
+
+template <typename Tin, typename Tout, int kPerLane>
+__global__ void DFlashAttnChunkKernel(Tout* out, const Tin* query, const Tin* key,
+                                      const Tin* value, const int32_t* cu, int num_reqs,
+                                      int64_t hq, int64_t hk, float scale, bool causal,
+                                      int64_t window) {
+  constexpr int kD = kPerLane * 32;  // head_dim, compile-time (dispatch guarantees it)
+  extern __shared__ float dfa_smem[];
+
+  const int lane = threadIdx.x & 31;
+  const int warp = static_cast<int>(threadIdx.x >> 5);
+  const int warps = static_cast<int>(blockDim.x >> 5);
+  float* psh = dfa_smem + static_cast<size_t>(warp) * 32;
+
+  const int64_t i = static_cast<int64_t>(blockIdx.x) * warps + warp;  // GLOBAL query row
+  const int64_t rows = cu[num_reqs];
+  if (i >= rows) return;  // whole-warp exit; this kernel never uses __syncthreads
+  const int64_t h = blockIdx.y;
+  const int64_t g = h / (hq / hk);
+
+  int64_t qs = 0, qe = 0;
+  for (int r = 0; r < num_reqs; ++r) {
+    if (i >= cu[r] && i < cu[r + 1]) {
+      qs = cu[r];
+      qe = cu[r + 1];
+      break;
+    }
+  }
+  const int64_t ii = i - qs;
+  const int64_t jhi = qs + (causal ? ii : (qe - qs - 1));  // last visible GLOBAL key
+  int64_t jlo = qs;
+  if (causal && window > 0) jlo = qs + (ii - (window - 1) > 0 ? ii - (window - 1) : 0);
+
+  const int64_t qoff = (i * hq + h) * kD;
+  float qreg[kPerLane], acc[kPerLane];
+  LoadLane<kPerLane>(query, qoff, lane, qreg);
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) acc[c] = 0.0f;
+  float m = -CUDART_INF_F, l = 0.0f;
+
+  const int64_t nkeys = jhi - jlo + 1;
+  const int64_t tail = jlo + (nkeys & ~static_cast<int64_t>(31));  // first partial-chunk base
+  for (int64_t base = jlo; base < tail; base += 32) {
+    DFlashAttnChunk<Tin, kPerLane, true>(key, value, base, 32, hk, g, lane, qreg, scale, psh, m,
+                                         l, acc);
+  }
+  if (tail <= jhi) {
+    DFlashAttnChunk<Tin, kPerLane, false>(key, value, tail, static_cast<int>(jhi - tail + 1), hk,
+                                          g, lane, qreg, scale, psh, m, l, acc);
+  }
+
+  const float inv = 1.0f / l;
+  float res[kPerLane];
+#pragma unroll
+  for (int c = 0; c < kPerLane; ++c) res[c] = acc[c] * inv;
+  StoreLane<kPerLane>(out, qoff, lane, res);
+}
+
+// ---------------------------------------------------------------------------
+// TENSOR-CORE (bf16 mma.sync) FlashAttention — the D16 default for bf16 streams.
+//
+// Every kernel above computes attention on the CUDA CORES: at head_dim 128 the
+// chunked reduce-scatter form measured 1.13 TFLOP/s against a ~7.7 TFLOP/s f32
+// CUDA-core ceiling and 30.0 TFLOP/s of cuBLASLt GEMM on the SAME chip. That gap
+// is not a scheduling problem any more — it is the wrong MATH UNIT. This kernel
+// moves both GEMMs of attention onto the bf16 tensor cores with
+// `mma.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32`, which is Ampere-and-later
+// (it assembles, launches and accumulates on sm_110; the FP4 `kind::mxf4nvf4`
+// restriction recorded for this box applies to the block-scaled FP4 MMA ONLY).
+//
+// SHAPE. One WARP owns 16 query rows and the FULL head_dim of output; a block is
+// kMmaWarps warps, so 64 query rows share one staged K/V tile of kMmaKeys keys.
+//
+//   S[16q x 32k] = Q[16q x d] · Kᵀ[d x 32k]   — d/16 k-steps x 4 n-tiles
+//   O[16q x d]  += P[16q x 32k] · V[32k x d]  — 2 k-steps x d/8 n-tiles
+//
+// SHARED MEMORY IS A FIRST-CLASS CONSTRAINT here, because the previous
+// shared-memory attempt in this file died of occupancy (32 KB/block, 23% SLOWER).
+// So ONLY K and V are staged: 2 * 32 * (d+8) * 2 B = 17.4 KB/block at d=128,
+// 4.6 KB at d=64. S, P and the whole O accumulator stay in REGISTERS. That is
+// possible because the m16n8k16 C fragment maps EXACTLY onto the next MMA's A
+// fragment: the accumulator lane layout (rows groupID / groupID+8, cols
+// threadInGroup*2 + {0,1}) is the same partition the A operand wants, so P needs
+// zero shuffles and zero shared round-trip — the reason FlashAttention-2 uses raw
+// mma.sync rather than the nvcuda::wmma API (whose fragments are opaque and must
+// go through memory; see PagedFlashWmmaKernel in cuda_paged_attn.cu, which pays
+// exactly that cost).
+//
+// FRAGMENT LAYOUT (PTX ISA "Matrix Fragments for mma.m16n8k16"), gid = lane>>2,
+// tig = lane&3:
+//   A (16x16 row): reg0={row gid, col tig*2, +1}   reg1={row gid+8, same cols}
+//                  reg2={row gid, col tig*2+8, +9} reg3={row gid+8, same cols}
+//   B (16x8 col):  reg0={col gid, row tig*2, +1}   reg1={col gid, row tig*2+8, +9}
+//   C (16x8 f32):  c0,c1={row gid,   col tig*2, +1}
+//                  c2,c3={row gid+8, col tig*2, +1}
+// So every lane owns exactly TWO query rows for its whole lifetime, and the online
+// softmax state (m, l) is two registers reduced across the 4 lanes of a QUAD
+// (__shfl_xor 1 and 2) — no block barrier, no shared scratch.
+//
+// SHARED BANKS. K/V rows are padded to d+8 elements. d is a multiple of 16, so the
+// row stride in 4-byte banks is (d+8)/2 = an ODD multiple of 4, and the 8 distinct
+// rows a warp touches land on banks 4*gid (mod 32) — all distinct — while tig adds
+// 0..3. The K fragment load is therefore CONFLICT-FREE. The V fragment reads a
+// COLUMN (b0/b1 are consecutive KEYS, not consecutive elements), so it costs four
+// 16-bit shared loads with a 2-way conflict; that is the one structural tax of
+// keeping V row-major, and it is paid against 2x the MMA work it feeds.
+//
+// MASKS. Identical bookkeeping to the chunked kernel, evaluated per (row, key)
+// on the f32 S fragment: non-causal, causal, sliding-window and multi-request
+// (cu_seqlens) all work, including a warp whose 16 rows straddle a document
+// boundary. The block walks the UNION of its 64 rows' key ranges so the staged
+// tile is block-uniform (every barrier is reached by every warp), and rows mask
+// out what they cannot see. Query rows past cu[num_reqs] clamp their row index
+// and skip the store.
+//
+// NUMERICS. Q, K and V are already bf16 in the production stream, so QKᵀ loses
+// NOTHING (bf16 in, f32 accumulate — the CUDA-core path converts the same bf16 to
+// f32 and accumulates in f32). The PV GEMM must round P to bf16, exactly as
+// FlashAttention does; that is a real ~2^-9 relative error on the probabilities
+// and it is why this path is gated at a bf16 tolerance rather than the f32 path's
+// 2e-5. f32 inputs therefore stay on DFlashAttnChunkKernel, whose f32 tolerance
+// this could not hold.
+__device__ __forceinline__ void MmaBf16M16N8K16(float* c, const unsigned* a, const unsigned* b) {
+#if __CUDA_ARCH__ >= 800
+  asm volatile(
+      "mma.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32 "
+      "{%0,%1,%2,%3}, {%4,%5,%6,%7}, {%8,%9}, {%0,%1,%2,%3};\n"
+      : "+f"(c[0]), "+f"(c[1]), "+f"(c[2]), "+f"(c[3])
+      : "r"(a[0]), "r"(a[1]), "r"(a[2]), "r"(a[3]), "r"(b[0]), "r"(b[1]));
+#else
+  (void)c;
+  (void)a;
+  (void)b;
+#endif
+}
+
+constexpr int kMmaWarps = 4;   // warps per block (4 * 16 = 64 query rows per block)
+constexpr int kMmaQ = 16;      // query rows per warp = the MMA's M
+constexpr int kMmaKeys = 32;   // keys per staged K/V tile = 4 n-tiles of the QKᵀ MMA
+constexpr int kMmaPad = 8;     // shared row padding, in elements (see SHARED BANKS)
+
+// kDT = head_dim / 16 (the QKᵀ k-step count). head_dim = 16 * kDT is a compile-time
+// constant so every fragment index below is a compile-time index into a register
+// array — a dynamic index would spill the accumulator to local memory.
+template <typename Tout, int kDT>
+__global__ __launch_bounds__(kMmaWarps * 32) void DFlashAttnMmaKernel(
+    Tout* out, const __nv_bfloat16* query, const __nv_bfloat16* key,
+    const __nv_bfloat16* value, const int32_t* cu, int num_reqs, int64_t hq, int64_t hk,
+    float scale, bool causal, int64_t window) {
+#if __CUDA_ARCH__ >= 800
+  constexpr int kD = kDT * 16;        // head_dim
+  constexpr int kNT = kD / 8;         // P·V n-tiles (8 output columns each)
+  constexpr int kStride = kD + kMmaPad;
+
+  extern __shared__ uint4 dfa_mma_smem[];  // uint4 => guaranteed 16-byte aligned
+  __nv_bfloat16* ksh = reinterpret_cast<__nv_bfloat16*>(dfa_mma_smem);
+  __nv_bfloat16* vsh = ksh + kMmaKeys * kStride;
+  const unsigned short* vsh_u = reinterpret_cast<const unsigned short*>(vsh);
+
+  const int tid = static_cast<int>(threadIdx.x);
+  const int lane = tid & 31;
+  const int warp = tid >> 5;
+  const int gid = lane >> 2;  // 0..7 : which of the 8 row-pairs this lane owns
+  const int tig = lane & 3;   // 0..3 : which column pair
+
+  const int64_t rows = cu[num_reqs];
+  const int64_t h = blockIdx.y;
+  const int64_t g = h / (hq / hk);
+  const int64_t qblk = static_cast<int64_t>(blockIdx.x) * (kMmaWarps * kMmaQ);
+  if (qblk >= rows) return;  // block-uniform
+
+  // --- block-wide key range: the UNION over this block's 64 query rows ------
+  const int64_t qend = (qblk + kMmaWarps * kMmaQ < rows) ? (qblk + kMmaWarps * kMmaQ) : rows;
+  int64_t klo = rows, khi = -1;
+  for (int r = 0; r < num_reqs; ++r) {
+    const int64_t rs = cu[r], re = cu[r + 1];
+    const int64_t lo = rs > qblk ? rs : qblk;
+    const int64_t hi = (re < qend ? re : qend) - 1;
+    if (lo > hi) continue;
+    const int64_t jhi = causal ? hi : (re - 1);
+    int64_t jlo = rs;
+    if (causal && window > 0) {
+      const int64_t ii = lo - rs;
+      jlo = rs + (ii - (window - 1) > 0 ? ii - (window - 1) : 0);
+    }
+    if (jlo < klo) klo = jlo;
+    if (jhi > khi) khi = jhi;
+  }
+  if (khi < klo) return;  // block-uniform
+
+  // --- this lane's TWO query rows and their per-row mask bounds -------------
+  const int64_t qbase = qblk + static_cast<int64_t>(warp) * kMmaQ;
+  int64_t qrow[2], rlo[2], rhi[2];
+  bool live[2];
+#pragma unroll
+  for (int u = 0; u < 2; ++u) {
+    const int64_t i = qbase + gid + 8 * u;
+    live[u] = i < rows;
+    const int64_t ic = live[u] ? i : (rows - 1);  // clamp: reads stay in bounds
+    qrow[u] = ic;
+    int64_t qs = 0, qe = 0;
+    for (int r = 0; r < num_reqs; ++r) {
+      if (ic >= cu[r] && ic < cu[r + 1]) {
+        qs = cu[r];
+        qe = cu[r + 1];
+        break;
+      }
+    }
+    const int64_t ii = ic - qs;
+    rhi[u] = qs + (causal ? ii : (qe - qs - 1));
+    rlo[u] = qs;
+    if (causal && window > 0) rlo[u] = qs + (ii - (window - 1) > 0 ? ii - (window - 1) : 0);
+  }
+
+  // --- Q A-fragments, read ONCE straight from global into registers ---------
+  unsigned qfrag[kDT][4];
+#pragma unroll
+  for (int kd = 0; kd < kDT; ++kd) {
+    const int64_t c0 = static_cast<int64_t>(kd) * 16 + tig * 2;
+    const int64_t o0 = (qrow[0] * hq + h) * kD;
+    const int64_t o1 = (qrow[1] * hq + h) * kD;
+    qfrag[kd][0] = *reinterpret_cast<const unsigned*>(query + o0 + c0);
+    qfrag[kd][1] = *reinterpret_cast<const unsigned*>(query + o1 + c0);
+    qfrag[kd][2] = *reinterpret_cast<const unsigned*>(query + o0 + c0 + 8);
+    qfrag[kd][3] = *reinterpret_cast<const unsigned*>(query + o1 + c0 + 8);
+  }
+
+  float acc[kNT][4];
+#pragma unroll
+  for (int nt = 0; nt < kNT; ++nt) {
+#pragma unroll
+    for (int c = 0; c < 4; ++c) acc[nt][c] = 0.0f;
+  }
+  float mrow[2] = {-CUDART_INF_F, -CUDART_INF_F};
+  float lrow[2] = {0.0f, 0.0f};
+
+  for (int64_t base = klo; base <= khi; base += kMmaKeys) {
+    // (1) stage the K and V tiles: 8 bf16 (16 B) per thread per step, coalesced.
+    __syncthreads();
+    for (int idx = tid * 8; idx < kMmaKeys * kD; idx += static_cast<int>(blockDim.x) * 8) {
+      const int kk = idx / kD, col = idx % kD;
+      const int64_t j = base + kk;
+      const int64_t jc = j < rows ? j : (rows - 1);  // clamp; masked keys score -inf
+      const int64_t off = (jc * hk + g) * kD + col;
+      const int sh = kk * kStride + col;
+      *reinterpret_cast<uint4*>(ksh + sh) = *reinterpret_cast<const uint4*>(key + off);
+      *reinterpret_cast<uint4*>(vsh + sh) = *reinterpret_cast<const uint4*>(value + off);
+    }
+    __syncthreads();
+
+    // (2) S = Q·Kᵀ on the tensor cores. 4 independent n-tiles => 4-way ILP over
+    //     the kDT-long serial accumulate chain.
+    float s[4][4];
+#pragma unroll
+    for (int nt = 0; nt < 4; ++nt) {
+#pragma unroll
+      for (int c = 0; c < 4; ++c) s[nt][c] = 0.0f;
+#pragma unroll
+      for (int kd = 0; kd < kDT; ++kd) {
+        const int krow = nt * 8 + gid;
+        unsigned b[2];
+        b[0] = *reinterpret_cast<const unsigned*>(ksh + krow * kStride + kd * 16 + tig * 2);
+        b[1] = *reinterpret_cast<const unsigned*>(ksh + krow * kStride + kd * 16 + tig * 2 + 8);
+        MmaBf16M16N8K16(s[nt], qfrag[kd], b);
+      }
+    }
+
+    // (3) scale + MASK, then the per-row max over this lane's 8 columns.
+    float rmax[2] = {-CUDART_INF_F, -CUDART_INF_F};
+#pragma unroll
+    for (int nt = 0; nt < 4; ++nt) {
+#pragma unroll
+      for (int c = 0; c < 4; ++c) {
+        const int u = c >> 1;
+        const int64_t j = base + nt * 8 + tig * 2 + (c & 1);
+        float v = s[nt][c] * scale;
+        if (j < rlo[u] || j > rhi[u]) v = -CUDART_INF_F;
+        s[nt][c] = v;
+        rmax[u] = fmaxf(rmax[u], v);
+      }
+    }
+    // The 8 columns of a row live in the 4 lanes of a QUAD: reduce with xor 1,2.
+#pragma unroll
+    for (int u = 0; u < 2; ++u) {
+      rmax[u] = fmaxf(rmax[u], __shfl_xor_sync(0xFFFFFFFFu, rmax[u], 1));
+      rmax[u] = fmaxf(rmax[u], __shfl_xor_sync(0xFFFFFFFFu, rmax[u], 2));
+    }
+
+    // (4) online softmax. A row can see NOTHING in this tile (the block walks the
+    //     union of 64 rows' ranges), so guard the -inf minus -inf that would NaN.
+    float corr[2];
+#pragma unroll
+    for (int u = 0; u < 2; ++u) {
+      const bool any = rmax[u] > -CUDART_INF_F;
+      const float mn = any ? fmaxf(mrow[u], rmax[u]) : mrow[u];
+      corr[u] = any ? __expf(mrow[u] - mn) : 1.0f;  // 0 on the first live tile
+      mrow[u] = mn;
+    }
+    float rsum[2] = {0.0f, 0.0f};
+#pragma unroll
+    for (int nt = 0; nt < 4; ++nt) {
+#pragma unroll
+      for (int c = 0; c < 4; ++c) {
+        const int u = c >> 1;
+        const float p = s[nt][c] > -CUDART_INF_F ? __expf(s[nt][c] - mrow[u]) : 0.0f;
+        s[nt][c] = p;
+        rsum[u] += p;
+      }
+    }
+#pragma unroll
+    for (int u = 0; u < 2; ++u) {
+      rsum[u] += __shfl_xor_sync(0xFFFFFFFFu, rsum[u], 1);
+      rsum[u] += __shfl_xor_sync(0xFFFFFFFFu, rsum[u], 2);
+      lrow[u] = lrow[u] * corr[u] + rsum[u];
+    }
+#pragma unroll
+    for (int nt = 0; nt < kNT; ++nt) {
+      acc[nt][0] *= corr[0];
+      acc[nt][1] *= corr[0];
+      acc[nt][2] *= corr[1];
+      acc[nt][3] *= corr[1];
+    }
+
+    // (5) P -> bf16 A-fragments. The C layout of step (2) IS the A layout, so this
+    //     is a pure pack: n-tiles {2kk, 2kk+1} become the 16-key k-step kk.
+    unsigned pf[2][4];
+#pragma unroll
+    for (int kk = 0; kk < 2; ++kk) {
+      const __nv_bfloat162 r0 = __floats2bfloat162_rn(s[2 * kk][0], s[2 * kk][1]);
+      const __nv_bfloat162 r1 = __floats2bfloat162_rn(s[2 * kk][2], s[2 * kk][3]);
+      const __nv_bfloat162 r2 = __floats2bfloat162_rn(s[2 * kk + 1][0], s[2 * kk + 1][1]);
+      const __nv_bfloat162 r3 = __floats2bfloat162_rn(s[2 * kk + 1][2], s[2 * kk + 1][3]);
+      pf[kk][0] = *reinterpret_cast<const unsigned*>(&r0);
+      pf[kk][1] = *reinterpret_cast<const unsigned*>(&r1);
+      pf[kk][2] = *reinterpret_cast<const unsigned*>(&r2);
+      pf[kk][3] = *reinterpret_cast<const unsigned*>(&r3);
+    }
+
+    // (6) O += P·V on the tensor cores. B wants consecutive KEYS in one register,
+    //     which V's row-major tile does not give: four 16-bit shared reads.
+#pragma unroll
+    for (int nt = 0; nt < kNT; ++nt) {
+      const int dcol = nt * 8 + gid;
+#pragma unroll
+      for (int kk = 0; kk < 2; ++kk) {
+        const int r0 = kk * 16 + tig * 2;
+        unsigned b[2];
+        b[0] = static_cast<unsigned>(vsh_u[r0 * kStride + dcol]) |
+               (static_cast<unsigned>(vsh_u[(r0 + 1) * kStride + dcol]) << 16);
+        b[1] = static_cast<unsigned>(vsh_u[(r0 + 8) * kStride + dcol]) |
+               (static_cast<unsigned>(vsh_u[(r0 + 9) * kStride + dcol]) << 16);
+        MmaBf16M16N8K16(acc[nt], pf[kk], b);
+      }
+    }
+  }
+
+#pragma unroll
+  for (int u = 0; u < 2; ++u) {
+    if (!live[u]) continue;
+    const float inv = lrow[u] > 0.0f ? 1.0f / lrow[u] : 0.0f;
+    const int64_t ooff = (qrow[u] * hq + h) * kD;
+#pragma unroll
+    for (int nt = 0; nt < kNT; ++nt) {
+      const int64_t col = nt * 8 + tig * 2;
+      Store(out, ooff + col, acc[nt][2 * u] * inv);
+      Store(out, ooff + col + 1, acc[nt][2 * u + 1] * inv);
+    }
+  }
+#else
+  (void)out; (void)query; (void)key; (void)value; (void)cu; (void)num_reqs; (void)hq;
+  (void)hk; (void)scale; (void)causal; (void)window;
+  __trap();  // never launched below sm_80 (host gate: DFlashMmaSupported)
+#endif
+}
+
+// The bf16 tensor-core path needs BOTH a compile-time and a runtime guarantee:
+// mma.sync's bf16 form is Ampere-and-later, so it must be in the compiled arch set
+// AND on the device we are actually running. VT_DFLASH_ATTN_MMA=0 disables it for
+// the same-binary A/B this project's benchmark protocol requires.
+#if defined(__CUDA_ARCH_LIST__)
+constexpr int kBuiltArchList[] = {__CUDA_ARCH_LIST__};
+constexpr bool BuiltArchesAllHaveBf16Mma() {
+  for (int a : kBuiltArchList) {
+    if (a < 800) return false;
+  }
+  return true;
+}
+#else
+constexpr bool BuiltArchesAllHaveBf16Mma() { return false; }
+#endif
+
+inline bool DFlashMmaSupported() {
+  static const bool on = [] {
+    if (!BuiltArchesAllHaveBf16Mma()) return false;
+    const char* e = std::getenv("VT_DFLASH_ATTN_MMA");
+    if (e != nullptr && e[0] == '0') return false;
+    int dev = 0;
+    if (cudaGetDevice(&dev) != cudaSuccess) return false;
+    int major = 0;
+    if (cudaDeviceGetAttribute(&major, cudaDevAttrComputeCapabilityMajor, dev) != cudaSuccess)
+      return false;
+    return major >= 8;
+  }();
+  return on;
+}
+
 template <typename Tin>
 void LaunchDFlashBlockAttention(cudaStream_t s, Tensor& out, const Tensor& query,
                                 const Tensor& key, const Tensor& value,
@@ -1597,6 +2632,138 @@ void LaunchDFlashBlockAttention(cudaStream_t s, Tensor& out, const Tensor& query
   Check(cudaMemcpyAsync(d_cu, args.cu_seqlens, cub, cudaMemcpyHostToDevice, s),
         "dflash-block-attn cu upload");
   const dim3 grid(static_cast<unsigned>(t), static_cast<unsigned>(hq));
+  // TENSOR-CORE fast path: bf16 in, head_dim a multiple of the MMA's k (16), up to
+  // 128 (the largest head this port uses). f32 streams stay on the CUDA-core kernel
+  // below -- rounding them to bf16 to reach the tensor cores would trade the f32
+  // path's 2e-5 tolerance for a bf16 one, which is not a trade this op may make.
+  if (std::is_same<Tin, __nv_bfloat16>::value && d % 16 == 0 && d >= 16 && d <= 128 &&
+      DFlashMmaSupported()) {
+    const dim3 mgrid(static_cast<unsigned>((t + kMmaWarps * kMmaQ - 1) / (kMmaWarps * kMmaQ)),
+                     static_cast<unsigned>(hq));
+    const unsigned mblock = kMmaWarps * 32;
+    const size_t mshmem =
+        2u * kMmaKeys * static_cast<size_t>(d + kMmaPad) * sizeof(__nv_bfloat16);
+#define VT_DFLASH_MMA(DT)                                                                     \
+  do {                                                                                        \
+    if (out.dtype == DType::kF32) {                                                           \
+      DFlashAttnMmaKernel<float, DT><<<mgrid, mblock, mshmem, s>>>(                           \
+          out.Ptr<float>(), reinterpret_cast<const __nv_bfloat16*>(query.data),               \
+          reinterpret_cast<const __nv_bfloat16*>(key.data),                                   \
+          reinterpret_cast<const __nv_bfloat16*>(value.data), d_cu, args.num_reqs, hq, hk,    \
+          args.scale, args.causal, args.sliding_window);                                      \
+    } else {                                                                                  \
+      DFlashAttnMmaKernel<__nv_bfloat16, DT><<<mgrid, mblock, mshmem, s>>>(                   \
+          out.Ptr<__nv_bfloat16>(), reinterpret_cast<const __nv_bfloat16*>(query.data),       \
+          reinterpret_cast<const __nv_bfloat16*>(key.data),                                   \
+          reinterpret_cast<const __nv_bfloat16*>(value.data), d_cu, args.num_reqs, hq, hk,    \
+          args.scale, args.causal, args.sliding_window);                                      \
+    }                                                                                         \
+  } while (0)
+    switch (d / 16) {
+      case 1: VT_DFLASH_MMA(1); break;
+      case 2: VT_DFLASH_MMA(2); break;
+      case 3: VT_DFLASH_MMA(3); break;
+      case 4: VT_DFLASH_MMA(4); break;
+      case 5: VT_DFLASH_MMA(5); break;
+      case 6: VT_DFLASH_MMA(6); break;
+      case 7: VT_DFLASH_MMA(7); break;
+      default: VT_DFLASH_MMA(8); break;
+    }
+#undef VT_DFLASH_MMA
+    Check(cudaGetLastError(), "dflash-block-attn mma launch");
+    Check(cudaFreeAsync(d_cu, s), "dflash-block-attn cu free");
+    return;
+  }
+  // Warp-per-query fast path when head_dim is a whole number of warp widths (64 and
+  // 128 cover every head this port uses). Three forms live here so the verdict can
+  // be reproduced on ONE binary (same-binary A/B is this project's benchmark rule):
+  // the CHUNKED reduce-scatter kernel is the default, VT_DFLASH_ATTN_KEYLANE=1
+  // selects the measured-negative one-key-per-lane form, and VT_DFLASH_ATTN_WARP=1
+  // selects the original per-key warp-reduction form.
+  if (d % 32 == 0 && d / 32 <= 4 && !UseDflashAttnWarpKernel()) {
+    constexpr int kWarpsPerBlock = 8;
+    const dim3 kgrid(static_cast<unsigned>((t + kWarpsPerBlock - 1) / kWarpsPerBlock),
+                     static_cast<unsigned>(hq));
+    const unsigned kblock = kWarpsPerBlock * 32;
+    const bool keylane = UseDflashAttnKeyLaneKernel();
+    const size_t kshmem =
+        static_cast<size_t>(kWarpsPerBlock) * (keylane ? (d + 32) : 32) * sizeof(float);
+#define VT_DFLASH_CHUNK(PER_LANE)                                                               \
+  do {                                                                                          \
+    if (out.dtype == DType::kF32) {                                                             \
+      DFlashAttnChunkKernel<Tin, float, PER_LANE><<<kgrid, kblock, kshmem, s>>>(                \
+          out.Ptr<float>(), query.Ptr<Tin>(), key.Ptr<Tin>(), value.Ptr<Tin>(), d_cu,           \
+          args.num_reqs, hq, hk, args.scale, args.causal, args.sliding_window);                 \
+    } else {                                                                                    \
+      DFlashAttnChunkKernel<Tin, __nv_bfloat16, PER_LANE><<<kgrid, kblock, kshmem, s>>>(        \
+          out.Ptr<__nv_bfloat16>(), query.Ptr<Tin>(), key.Ptr<Tin>(), value.Ptr<Tin>(), d_cu,   \
+          args.num_reqs, hq, hk, args.scale, args.causal, args.sliding_window);                 \
+    }                                                                                           \
+  } while (0)
+    if (!keylane) {
+      switch (d / 32) {
+        case 1: VT_DFLASH_CHUNK(1); break;
+        case 2: VT_DFLASH_CHUNK(2); break;
+        case 3: VT_DFLASH_CHUNK(3); break;
+        default: VT_DFLASH_CHUNK(4); break;
+      }
+#undef VT_DFLASH_CHUNK
+      Check(cudaGetLastError(), "dflash-block-attn chunk launch");
+      Check(cudaFreeAsync(d_cu, s), "dflash-block-attn cu free");
+      return;
+    }
+#define VT_DFLASH_KEYLANE(PER_LANE)                                                             \
+  do {                                                                                          \
+    if (out.dtype == DType::kF32) {                                                             \
+      DFlashAttnKeyLaneKernel<Tin, float, PER_LANE><<<kgrid, kblock, kshmem, s>>>(              \
+          out.Ptr<float>(), query.Ptr<Tin>(), key.Ptr<Tin>(), value.Ptr<Tin>(), d_cu,           \
+          args.num_reqs, hq, hk, args.scale, args.causal, args.sliding_window);                 \
+    } else {                                                                                    \
+      DFlashAttnKeyLaneKernel<Tin, __nv_bfloat16, PER_LANE><<<kgrid, kblock, kshmem, s>>>(      \
+          out.Ptr<__nv_bfloat16>(), query.Ptr<Tin>(), key.Ptr<Tin>(), value.Ptr<Tin>(), d_cu,   \
+          args.num_reqs, hq, hk, args.scale, args.causal, args.sliding_window);                 \
+    }                                                                                           \
+  } while (0)
+    switch (d / 32) {
+      case 1: VT_DFLASH_KEYLANE(1); break;
+      case 2: VT_DFLASH_KEYLANE(2); break;
+      case 3: VT_DFLASH_KEYLANE(3); break;
+      default: VT_DFLASH_KEYLANE(4); break;
+    }
+#undef VT_DFLASH_KEYLANE
+    Check(cudaGetLastError(), "dflash-block-attn key-lane launch");
+    Check(cudaFreeAsync(d_cu, s), "dflash-block-attn cu free");
+    return;
+  }
+  if (d % 32 == 0 && d / 32 <= 4) {
+    constexpr int kWarpsPerBlock = 4;
+    const dim3 wgrid(static_cast<unsigned>((t + kWarpsPerBlock - 1) / kWarpsPerBlock),
+                     static_cast<unsigned>(hq));
+    const unsigned wblock = kWarpsPerBlock * 32;
+#define VT_DFLASH_WARP(PER_LANE)                                                              \
+  do {                                                                                        \
+    if (out.dtype == DType::kF32) {                                                           \
+      DFlashBlockAttentionWarpKernel<Tin, float, PER_LANE><<<wgrid, wblock, 0, s>>>(          \
+          out.Ptr<float>(), query.Ptr<Tin>(), key.Ptr<Tin>(), value.Ptr<Tin>(), d_cu,         \
+          args.num_reqs, hq, hk, d, args.scale, args.causal, args.sliding_window);            \
+    } else {                                                                                  \
+      DFlashBlockAttentionWarpKernel<Tin, __nv_bfloat16, PER_LANE><<<wgrid, wblock, 0, s>>>(  \
+          out.Ptr<__nv_bfloat16>(), query.Ptr<Tin>(), key.Ptr<Tin>(), value.Ptr<Tin>(), d_cu, \
+          args.num_reqs, hq, hk, d, args.scale, args.causal, args.sliding_window);            \
+    }                                                                                         \
+  } while (0)
+    switch (d / 32) {
+      case 1: VT_DFLASH_WARP(1); break;
+      case 2: VT_DFLASH_WARP(2); break;
+      case 3: VT_DFLASH_WARP(3); break;
+      default: VT_DFLASH_WARP(4); break;
+    }
+#undef VT_DFLASH_WARP
+    Check(cudaGetLastError(), "dflash-block-attn warp launch");
+    Check(cudaFreeAsync(d_cu, s), "dflash-block-attn cu free");
+    return;
+  }
+
   const size_t shmem = (static_cast<size_t>(d) + kBlock) * sizeof(float);
   switch (out.dtype) {
     case DType::kF32:
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 16aa6b3f0..288c3ac04 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -45,6 +45,8 @@ vllm_cpp_add_test(test_gguf_qwen36_loader vllm/test_gguf_qwen36_loader.cpp)
 vllm_cpp_add_test(test_gguf_keep_quant vllm/test_gguf_keep_quant.cpp)
 vllm_cpp_add_test(test_model_loader_gguf vllm/test_model_loader_gguf.cpp)
 vllm_cpp_add_test(test_model_registry vllm/models/test_model_registry.cpp)
+vllm_cpp_add_test(test_minimax_h3 vllm/models/test_minimax_h3.cpp)
+vllm_cpp_add_test(test_video_api vllm/entrypoints/openai/test_video_api.cpp)
 target_include_directories(test_model_registry PRIVATE ${CMAKE_SOURCE_DIR}/src)
 vllm_cpp_add_test(test_platform vllm/platforms/test_platform.cpp)
 vllm_cpp_add_test(test_linear_method vllm/model_executor/layers/test_linear_method.cpp)
diff --git a/tests/vllm/entrypoints/openai/test_api_server.cpp b/tests/vllm/entrypoints/openai/test_api_server.cpp
index c90eaf18b..38e98f369 100644
--- a/tests/vllm/entrypoints/openai/test_api_server.cpp
+++ b/tests/vllm/entrypoints/openai/test_api_server.cpp
@@ -11,6 +11,7 @@
 // The synthetic model mirrors tests/vllm/entrypoints/openai/test_serving.cpp
 // (tiny hybrid-MoE Qwen3.6 + the BPE fixture, vocab ids 0..21).
 #include "vllm/entrypoints/openai/api_server.h"
+#include "vllm/entrypoints/openai/video_api.h"
 
 #include <doctest/doctest.h>
 
@@ -1642,3 +1643,106 @@ TEST_CASE(
   server_thread.join();
 #endif  // defined(__linux__)
 }
+
+// ---------------------------------------------------------------------------
+// MiniMax-H3 /v1/videos routes. These are ADDITIVE and OPT-IN: without a runner
+// attached the handlers refuse, and the routes are never registered at all.
+// ---------------------------------------------------------------------------
+
+namespace {
+std::string VideoBody() {
+  return R"({"prompt":"a cat","num_inference_steps":4})";
+}
+}  // namespace
+
+TEST_CASE("api_server: /v1/videos without a runner is a 500, not a crash") {
+  const HfConfig c = MakeConfig();
+  const Qwen3_5MoeWeights w = MakeWeights(c);
+  ServerHarness h(c, w, Fixture());
+  ApiServer::DispatchResult async_result = h.server.handle_videos(VideoBody());
+  CHECK(async_result.status == 500);
+  ApiServer::DispatchResult sync_result =
+      h.server.handle_videos_sync(VideoBody());
+  CHECK(sync_result.status == 500);
+  // And an unknown job id is a 404 rather than an empty 200.
+  CHECK(h.server.handle_video_status("video-0").status == 404);
+}
+
+TEST_CASE("api_server: /v1/videos/sync runs the runner and returns its path") {
+  const HfConfig c = MakeConfig();
+  const Qwen3_5MoeWeights w = MakeWeights(c);
+  ServerHarness h(c, w, Fixture());
+  std::string seen_prompt;
+  int64_t seen_steps = 0;
+  h.server.set_video_runner(
+      [&](const vllm::openai::VideoRequest& req) -> std::string {
+        seen_prompt = req.prompt;
+        seen_steps = req.num_inference_steps;
+        return "/tmp/out.mp4";
+      });
+
+  ApiServer::DispatchResult r = h.server.handle_videos_sync(VideoBody());
+  REQUIRE(r.status == 200);
+  CHECK(r.content_type == "application/json");
+  nlohmann::json body = nlohmann::json::parse(r.body);
+  CHECK(body.at("status") == "succeeded");
+  CHECK(body.at("output_path") == "/tmp/out.mp4");
+  // The parsed request actually reached the runner.
+  CHECK(seen_prompt == "a cat");
+  CHECK(seen_steps == 4);
+
+  // The job is retrievable afterwards by id.
+  ApiServer::DispatchResult status =
+      h.server.handle_video_status(body.at("id").get<std::string>());
+  REQUIRE(status.status == 200);
+  CHECK(nlohmann::json::parse(status.body).at("status") == "succeeded");
+}
+
+TEST_CASE("api_server: a throwing runner fails the job, sync and async alike") {
+  const HfConfig c = MakeConfig();
+  const Qwen3_5MoeWeights w = MakeWeights(c);
+  ServerHarness h(c, w, Fixture());
+  h.server.set_video_runner(
+      [](const vllm::openai::VideoRequest&) -> std::string {
+        throw std::runtime_error("ffmpeg missing");
+      });
+
+  ApiServer::DispatchResult sync_result =
+      h.server.handle_videos_sync(VideoBody());
+  CHECK(sync_result.status == 500);
+  CHECK(nlohmann::json::parse(sync_result.body)
+            .at("error")
+            .at("message")
+            .get<std::string>() == "ffmpeg missing");
+
+  // The async endpoint still accepts the job; the FAILURE surfaces on polling,
+  // and crucially the worker thread does not terminate the process.
+  ApiServer::DispatchResult async_result = h.server.handle_videos(VideoBody());
+  REQUIRE(async_result.status == 200);
+  const std::string id =
+      nlohmann::json::parse(async_result.body).at("id").get<std::string>();
+  std::string status;
+  for (int i = 0; i < 400; ++i) {
+    status = nlohmann::json::parse(h.server.handle_video_status(id).body)
+                 .at("status")
+                 .get<std::string>();
+    if (status == "failed" || status == "succeeded") break;
+    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+  }
+  CHECK(status == "failed");
+}
+
+TEST_CASE("api_server: /v1/videos rejects a malformed body with 400") {
+  const HfConfig c = MakeConfig();
+  const Qwen3_5MoeWeights w = MakeWeights(c);
+  ServerHarness h(c, w, Fixture());
+  h.server.set_video_runner(
+      [](const vllm::openai::VideoRequest&) -> std::string {
+        FAIL("the runner must not be reached for an invalid request");
+        return {};
+      });
+  CHECK(h.server.handle_videos("{not json").status == 400);
+  CHECK(h.server.handle_videos_sync("{not json").status == 400);
+  // A body that parses but carries no prompt is equally a client error.
+  CHECK(h.server.handle_videos_sync(R"({"num_inference_steps":4})").status == 400);
+}
diff --git a/tests/vllm/entrypoints/openai/test_video_api.cpp b/tests/vllm/entrypoints/openai/test_video_api.cpp
new file mode 100644
index 000000000..0884aace5
--- /dev/null
+++ b/tests/vllm/entrypoints/openai/test_video_api.cpp
@@ -0,0 +1,161 @@
+// `/v1/videos` serving surface: request contract + job lifecycle.
+//
+// The library never spawns a process (developer-ratified: the ffmpeg invocation
+// lives in examples/), so these two pieces ARE the endpoint's logic and both are
+// pure, which is what makes them testable here.
+#include "vllm/entrypoints/openai/video_api.h"
+
+#include <doctest/doctest.h>
+
+#include <nlohmann/json.hpp>
+
+#include <string>
+#include <thread>
+#include <vector>
+
+using vllm::openai::ParseVideoRequest;
+using vllm::openai::VideoJob;
+using vllm::openai::VideoJobStatus;
+using vllm::openai::VideoJobStatusJson;
+using vllm::openai::VideoJobStore;
+using vllm::openai::VideoRequest;
+
+TEST_CASE("video api: request parsing applies H3 defaults and rejects bad input") {
+  const VideoRequest minimal = ParseVideoRequest(R"({"prompt": "a cat"})");
+  CHECK(minimal.prompt == "a cat");
+  CHECK(minimal.task.empty());              // resolved later from partition + inputs
+  CHECK(minimal.num_inference_steps == 50);  // H3's documented step count
+  CHECK(minimal.flow_shift == doctest::Approx(12.0));       // video
+  CHECK(minimal.audio_flow_shift == doctest::Approx(3.0));  // audio
+  CHECK(minimal.duration_seconds == doctest::Approx(0.0));  // => per-task default
+  CHECK_FALSE(minimal.has_seed);
+
+  // vLLM-Omni nests the knobs under extra_params; both spellings must work.
+  const VideoRequest nested = ParseVideoRequest(R"({
+    "prompt": "a dog", "height": 768, "width": 1344,
+    "extra_params": {"duration": 6.0, "num_inference_steps": 30,
+                     "flow_shift": 9.5, "audio_flow_shift": 2.5, "seed": 1234}
+  })");
+  CHECK(nested.height == 768);
+  CHECK(nested.width == 1344);
+  CHECK(nested.duration_seconds == doctest::Approx(6.0));
+  CHECK(nested.num_inference_steps == 30);
+  CHECK(nested.flow_shift == doctest::Approx(9.5));
+  CHECK(nested.audio_flow_shift == doctest::Approx(2.5));
+  CHECK(nested.has_seed);
+  CHECK(nested.seed == 1234);
+
+  const VideoRequest flat =
+      ParseVideoRequest(R"({"prompt": "x", "duration": 4.0, "num_inference_steps": 10})");
+  CHECK(flat.duration_seconds == doctest::Approx(4.0));
+  CHECK(flat.num_inference_steps == 10);
+
+  // Malformed input must be a specific error, never a silent default.
+  CHECK_THROWS(ParseVideoRequest("not json"));
+  CHECK_THROWS(ParseVideoRequest("[]"));
+  CHECK_THROWS(ParseVideoRequest(R"({})"));                        // no prompt
+  CHECK_THROWS(ParseVideoRequest(R"({"prompt": 5})"));             // wrong type
+  CHECK_THROWS(ParseVideoRequest(R"({"prompt":"x","num_inference_steps":0})"));
+  CHECK_THROWS(ParseVideoRequest(R"({"prompt":"x","flow_shift":0})"));
+  CHECK_THROWS(ParseVideoRequest(R"({"prompt":"x","duration":-1})"));
+  CHECK_THROWS(ParseVideoRequest(R"({"prompt":"x","height":-8})"));
+}
+
+TEST_CASE("video api: the job store enforces its lifecycle") {
+  VideoJobStore store;
+  CHECK(store.Size() == 0);
+
+  const std::string id = store.Create();
+  CHECK(!id.empty());
+  CHECK(store.Size() == 1);
+
+  VideoJob job;
+  REQUIRE(store.Get(id, &job));
+  CHECK(job.id == id);
+  CHECK(job.status == VideoJobStatus::kQueued);
+
+  // An unknown id is reported, not invented -- so the route can 404.
+  CHECK_FALSE(store.Get("vid_does_not_exist", &job));
+
+  store.MarkRunning(id);
+  REQUIRE(store.Get(id, &job));
+  CHECK(job.status == VideoJobStatus::kRunning);
+
+  store.MarkSucceeded(id, "/tmp/out.mp4");
+  REQUIRE(store.Get(id, &job));
+  CHECK(job.status == VideoJobStatus::kSucceeded);
+  CHECK(job.output_path == "/tmp/out.mp4");
+
+  // Illegal transitions throw rather than corrupting a finished record.
+  CHECK_THROWS(store.MarkRunning(id));
+  CHECK_THROWS(store.MarkSucceeded(id, "/tmp/other.mp4"));
+  CHECK_THROWS(store.MarkFailed(id, "late"));
+  CHECK_THROWS(store.MarkRunning("vid_nope"));
+
+  // A succeeded job must carry a path; an empty one is a caller bug.
+  const std::string second = store.Create();
+  store.MarkRunning(second);
+  CHECK_THROWS(store.MarkSucceeded(second, ""));
+  store.MarkFailed(second, "ffmpeg exited 1");
+  REQUIRE(store.Get(second, &job));
+  CHECK(job.status == VideoJobStatus::kFailed);
+  CHECK(job.error == "ffmpeg exited 1");
+
+  // A queued job may fail directly (rejected before it ever ran).
+  const std::string third = store.Create();
+  store.MarkFailed(third, "");
+  REQUIRE(store.Get(third, &job));
+  CHECK(job.status == VideoJobStatus::kFailed);
+  CHECK(job.error == "unspecified error");  // never an empty reason
+}
+
+TEST_CASE("video api: status JSON reports exactly what the client needs") {
+  VideoJobStore store;
+  const std::string id = store.Create();
+  VideoJob job;
+  REQUIRE(store.Get(id, &job));
+
+  nlohmann::json queued = nlohmann::json::parse(VideoJobStatusJson(job));
+  CHECK(queued.at("id") == id);
+  CHECK(queued.at("status") == "queued");
+  CHECK_FALSE(queued.contains("output_path"));  // nothing to hand back yet
+  CHECK_FALSE(queued.contains("error"));
+
+  store.MarkRunning(id);
+  store.MarkSucceeded(id, "/tmp/a.mp4");
+  REQUIRE(store.Get(id, &job));
+  nlohmann::json done = nlohmann::json::parse(VideoJobStatusJson(job));
+  CHECK(done.at("status") == "succeeded");
+  CHECK(done.at("output_path") == "/tmp/a.mp4");
+  CHECK_FALSE(done.contains("error"));
+
+  const std::string bad = store.Create();
+  store.MarkRunning(bad);
+  store.MarkFailed(bad, "boom");
+  REQUIRE(store.Get(bad, &job));
+  nlohmann::json failed = nlohmann::json::parse(VideoJobStatusJson(job));
+  CHECK(failed.at("status") == "failed");
+  CHECK(failed.at("error") == "boom");
+  CHECK_FALSE(failed.contains("output_path"));
+}
+
+TEST_CASE("video api: the job store is safe under concurrent creation") {
+  // The HTTP worker pool touches this from several threads, so ids must stay
+  // unique and no record may be lost.
+  VideoJobStore store;
+  constexpr int kThreads = 8, kPerThread = 32;
+  std::vector<std::thread> threads;
+  std::vector<std::vector<std::string>> ids(kThreads);
+  for (int t = 0; t < kThreads; ++t) {
+    threads.emplace_back([&store, &ids, t]() {
+      for (int i = 0; i < kPerThread; ++i) ids[t].push_back(store.Create());
+    });
+  }
+  for (std::thread& thread : threads) thread.join();
+
+  CHECK(store.Size() == kThreads * kPerThread);
+  std::vector<std::string> flat;
+  for (const auto& per_thread : ids) flat.insert(flat.end(), per_thread.begin(), per_thread.end());
+  std::sort(flat.begin(), flat.end());
+  CHECK(std::adjacent_find(flat.begin(), flat.end()) == flat.end());  // all unique
+}
diff --git a/tests/vllm/models/minimax_h3_audio_vae_encoder_goldens.inc b/tests/vllm/models/minimax_h3_audio_vae_encoder_goldens.inc
new file mode 100644
index 000000000..c598b5353
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_audio_vae_encoder_goldens.inc
@@ -0,0 +1,69 @@
+// GENERATED by scripts/gen-minimax-h3-audio-vae-encoder-goldens.py — DO NOT EDIT BY HAND.
+//
+// MiniMax-H3 AUDIO VAE **encoder** goldens, produced by executing the CHECKPOINT'S OWN
+// remote-code modules (FL2VA/audio_vae/dac_audio_vae.py + dac_attn_proj.py) at reduced
+// dimensions, in the exact sequence vLLM-Omni's reference-audio path runs
+// (vae.py:317-325): preprocess -> Encoder -> pre_block -> mean_proj. The remote code is
+// not vendored here; see the generator's docstring. Weights come from the shared H3Rand
+// stream, so no weight byte is checked in.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3AudioEncDim = 8;
+inline constexpr int64_t kH3AudioEncLatentDim = 16;
+inline constexpr int64_t kH3AudioEncVaeChannels = 4;
+inline constexpr int64_t kH3AudioEncHeads = 2;
+inline constexpr int64_t kH3AudioEncSamples = 25;
+inline constexpr int64_t kH3AudioEncFrames = 7;
+inline constexpr int64_t kH3AudioEncRates[] = {2, 2};
+
+inline constexpr float kH3AudioEncInputGolden[] = {
+    -0.996517241f, -0.928762972f, -0.0854872763f, 0.565218449f, 0.353265047f, -0.859112382f,
+    -0.568568826f, 0.616092801f, 0.956712544f, 0.125359058f, 0.617079437f, 0.555017412f,
+    -0.492701381f, -0.713567853f, -0.495044649f, -0.616983473f, -0.764478743f, -0.522185266f,
+    0.482539684f, -0.626400113f, 0.475179613f, 0.602462053f, 0.956581891f, -0.124502763f,
+    0.87525934f,
+};
+
+inline constexpr float kH3AudioEncBlockGolden[] = {
+    0.00744111789f, 0.00945140049f, 0.0090844119f, 0.00911143608f, 0.00947892573f, 0.00915240403f,
+    0.0121479165f, -0.0406957492f, -0.0456981659f, -0.0470272191f, -0.0469177589f, -0.0465101637f,
+    -0.0472135991f, -0.0453818701f, -0.0404146202f, -0.0428102501f, -0.042226281f, -0.0420760065f,
+    -0.0425957926f, -0.0427792892f, -0.0434204042f, -0.049407538f, -0.0505231582f, -0.0498396046f,
+    -0.0508168042f, -0.0503279679f, -0.0506520383f, -0.0476027951f, 0.0298064444f, 0.0298818182f,
+    0.0286593679f, 0.0303253513f, 0.0297649857f, 0.0290962607f, 0.0312649682f, 0.0204932094f,
+    0.0195147898f, 0.0192108136f, 0.0193540044f, 0.0188648086f, 0.0178254116f, 0.0204383414f,
+    -0.00684522279f, -0.00804489851f, -0.00761325378f, -0.00810076948f, -0.00810084771f, -0.00640848838f,
+    -0.00677413074f, 0.0450298861f, 0.0411362685f, 0.0408697017f, 0.0397591367f, 0.0402197838f,
+    0.0406537391f, 0.0378447995f, 0.0298743118f, 0.0323865376f, 0.0324012563f, 0.0330815092f,
+    0.0329335146f, 0.0322220176f, 0.030722307f, 0.0465482026f, 0.044800438f, 0.0450100936f,
+    0.0452062525f, 0.0448908024f, 0.0454649813f, 0.0436415784f, -0.0390654728f, -0.038579829f,
+    -0.0378300846f, -0.0373443812f, -0.0377354845f, -0.0383077599f, -0.034314163f, 0.0324162655f,
+    0.0347327515f, 0.0351068899f, 0.0350909866f, 0.0346708558f, 0.0344813094f, 0.0315887779f,
+    0.029812241f, 0.0265280362f, 0.0264153164f, 0.0271478891f, 0.0262003597f, 0.0261751395f,
+    0.0253360216f, 0.0486792549f, 0.0505047552f, 0.0498945825f, 0.0504469573f, 0.0503460616f,
+    0.0505397469f, 0.0496150479f, -0.0384124666f, -0.0364880674f, -0.0365874916f, -0.0368787237f,
+    -0.0368895978f, -0.0365522057f, -0.034855511f, -0.00935205724f, -0.0104675787f, -0.0107695907f,
+    -0.0101618674f, -0.00998985581f, -0.0101575553f, -0.00877371803f,
+};
+
+inline constexpr float kH3AudioEncAttnProjGolden[] = {
+    -0.0459364764f, -0.0157652833f, -0.0137237348f, -0.00701446086f, -0.0108876899f, -0.0151353404f,
+    -0.0209955573f, -0.110648558f, -0.114096545f, -0.112632915f, -0.118582614f, -0.115707427f,
+    -0.114288658f, -0.106874205f, 0.327704668f, 0.31373018f, 0.318265378f, 0.31578511f,
+    0.313651025f, 0.315576702f, 0.287185133f, -0.117315166f, -0.102521457f, -0.0984839723f,
+    -0.101726383f, -0.101504542f, -0.103327394f, -0.118676007f,
+};
+
+inline constexpr float kH3AudioEncMeanGolden[] = {
+    -0.0373153053f, -0.0383006595f, -0.0391526073f, -0.0387527645f, -0.0385237373f, -0.0384519808f,
+    -0.0350583829f, -0.000351943541f, -0.0024503381f, -0.00298886513f, -0.00321778469f, -0.00283447327f,
+    -0.00253127795f, 0.000217293855f, -0.0139565961f, -0.0148590412f, -0.0149568785f, -0.0153686963f,
+    -0.0150939049f, -0.0149497315f, -0.0142772216f, -0.041000843f, -0.0415197611f, -0.0415256731f,
+    -0.042607978f, -0.0419391841f, -0.041783791f, -0.0404332131f,
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_audio_vae_goldens.inc b/tests/vllm/models/minimax_h3_audio_vae_goldens.inc
new file mode 100644
index 000000000..971b4bbcf
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_audio_vae_goldens.inc
@@ -0,0 +1,32 @@
+// GENERATED by scripts/gen-minimax-h3-audio-vae-goldens.py — DO NOT EDIT BY HAND.
+//
+// MiniMax-H3 AUDIO VAE decoder goldens, produced by executing the CHECKPOINT'S OWN
+// remote-code modules (FL2VA/audio_vae/*.py) at reduced dimensions. The remote code
+// is not vendored here; see the generator's docstring. Weights come from the shared
+// H3Rand stream, so no weight byte is checked in.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3AudioVaeNumMels = 16;
+inline constexpr int64_t kH3AudioVaeFrames = 8;
+inline constexpr int64_t kH3AudioVaeInitialChannel = 16;
+inline constexpr int64_t kH3AudioVaeOutSamples = 32;
+
+inline constexpr float kH3AudioVaeUpFilterGolden[] = {
+    0.00202896469f, 0.00938946567f, -0.0255434588f, -0.0576573834f, 0.128572583f, 0.443209797f,
+    0.443209797f, 0.128572583f, -0.0576573834f, -0.0255434588f, 0.00938946567f, 0.00202896469f,
+};
+
+inline constexpr float kH3AudioVaeWaveformGolden[] = {
+    -0.000981161371f, -0.000977792079f, 0.00320230541f, 0.00634984206f, 0.00706541445f, 0.00629444607f,
+    0.00785835553f, 0.0068855565f, 0.00711112889f, 0.00659469049f, 0.00810943544f, 0.00727024721f,
+    0.00724928128f, 0.00671261642f, 0.00803683139f, 0.00723272655f, 0.00693816831f, 0.00673233438f,
+    0.00811647717f, 0.0066558565f, 0.00719360868f, 0.00686675915f, 0.00795679726f, 0.00663859304f,
+    0.00713692885f, 0.00677527767f, 0.00782371312f, 0.00639861356f, 0.00792965107f, 0.00712114293f,
+    0.0052891681f, 0.0034062583f,
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_audio_vae_manifest.inc b/tests/vllm/models/minimax_h3_audio_vae_manifest.inc
new file mode 100644
index 000000000..885692ba4
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_audio_vae_manifest.inc
@@ -0,0 +1,1111 @@
+// GENERATED by scripts/gen-minimax-h3-safetensors-manifest.py — DO NOT EDIT BY HAND.
+//
+// Tensor manifest of a REAL safetensors checkpoint (MiniMaxAI/MiniMax-H3 FL2VA/audio_vae/model.safetensors): 1087 tensors,
+// names/dtypes/shapes only — no weight bytes. Captured from the file's own header via
+// an HTTP range request. See .agents/specs/minimax-h3.md.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3AudioVaeTensorCount = 1087;
+
+struct H3AudioVaeTensor {
+  const char* name;
+  const char* dtype;
+  int64_t shape[5];  // 0-padded (Conv3d weights are rank 5)
+  int32_t rank;
+};
+
+inline constexpr H3AudioVaeTensor kH3AudioVaeTensors[] = {
+    {"dec_in_proj.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"dec_in_proj.weight", "F32", {2048, 32, 1, 0, 0}, 3},
+    {"decoder.activation_post.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.activation_post.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.activation_post.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.activation_post.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.conv_post.weight_g", "F32", {1, 1, 1, 0, 0}, 3},
+    {"decoder.conv_post.weight_v", "F32", {1, 8, 7, 0, 0}, 3},
+    {"decoder.conv_pre.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"decoder.conv_pre.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"decoder.conv_pre.weight_v", "F32", {1024, 2048, 7, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.0.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.0.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.1.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.1.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.2.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.2.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.3.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.3.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.4.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.4.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.5.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.5.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.0.convs1.0.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.convs1.0.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.0.convs1.0.weight_v", "F32", {512, 512, 3, 0, 0}, 3},
+    {"decoder.resblocks.0.convs1.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.convs1.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.0.convs1.1.weight_v", "F32", {512, 512, 3, 0, 0}, 3},
+    {"decoder.resblocks.0.convs1.2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.convs1.2.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.0.convs1.2.weight_v", "F32", {512, 512, 3, 0, 0}, 3},
+    {"decoder.resblocks.0.convs2.0.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.convs2.0.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.0.convs2.0.weight_v", "F32", {512, 512, 3, 0, 0}, 3},
+    {"decoder.resblocks.0.convs2.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.convs2.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.0.convs2.1.weight_v", "F32", {512, 512, 3, 0, 0}, 3},
+    {"decoder.resblocks.0.convs2.2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.0.convs2.2.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.0.convs2.2.weight_v", "F32", {512, 512, 3, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.0.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.0.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.1.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.1.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.2.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.2.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.3.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.3.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.4.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.4.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.5.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.5.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.1.convs1.0.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.convs1.0.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.1.convs1.0.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"decoder.resblocks.1.convs1.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.convs1.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.1.convs1.1.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"decoder.resblocks.1.convs1.2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.convs1.2.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.1.convs1.2.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"decoder.resblocks.1.convs2.0.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.convs2.0.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.1.convs2.0.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"decoder.resblocks.1.convs2.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.convs2.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.1.convs2.1.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"decoder.resblocks.1.convs2.2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.1.convs2.2.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.1.convs2.2.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.0.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.0.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.1.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.1.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.2.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.2.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.3.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.3.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.4.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.4.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.5.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.5.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.10.convs1.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.convs1.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.10.convs1.0.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"decoder.resblocks.10.convs1.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.convs1.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.10.convs1.1.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"decoder.resblocks.10.convs1.2.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.convs1.2.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.10.convs1.2.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"decoder.resblocks.10.convs2.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.convs2.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.10.convs2.0.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"decoder.resblocks.10.convs2.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.convs2.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.10.convs2.1.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"decoder.resblocks.10.convs2.2.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.10.convs2.2.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.10.convs2.2.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.0.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.0.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.1.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.1.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.2.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.2.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.3.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.3.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.4.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.4.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.5.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.5.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.11.convs1.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.convs1.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.11.convs1.0.weight_v", "F32", {64, 64, 11, 0, 0}, 3},
+    {"decoder.resblocks.11.convs1.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.convs1.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.11.convs1.1.weight_v", "F32", {64, 64, 11, 0, 0}, 3},
+    {"decoder.resblocks.11.convs1.2.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.convs1.2.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.11.convs1.2.weight_v", "F32", {64, 64, 11, 0, 0}, 3},
+    {"decoder.resblocks.11.convs2.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.convs2.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.11.convs2.0.weight_v", "F32", {64, 64, 11, 0, 0}, 3},
+    {"decoder.resblocks.11.convs2.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.convs2.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.11.convs2.1.weight_v", "F32", {64, 64, 11, 0, 0}, 3},
+    {"decoder.resblocks.11.convs2.2.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.11.convs2.2.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.11.convs2.2.weight_v", "F32", {64, 64, 11, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.0.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.0.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.1.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.1.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.2.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.2.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.3.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.3.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.4.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.4.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.5.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.5.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.12.convs1.0.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.convs1.0.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.12.convs1.0.weight_v", "F32", {32, 32, 3, 0, 0}, 3},
+    {"decoder.resblocks.12.convs1.1.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.convs1.1.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.12.convs1.1.weight_v", "F32", {32, 32, 3, 0, 0}, 3},
+    {"decoder.resblocks.12.convs1.2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.convs1.2.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.12.convs1.2.weight_v", "F32", {32, 32, 3, 0, 0}, 3},
+    {"decoder.resblocks.12.convs2.0.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.convs2.0.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.12.convs2.0.weight_v", "F32", {32, 32, 3, 0, 0}, 3},
+    {"decoder.resblocks.12.convs2.1.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.convs2.1.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.12.convs2.1.weight_v", "F32", {32, 32, 3, 0, 0}, 3},
+    {"decoder.resblocks.12.convs2.2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.12.convs2.2.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.12.convs2.2.weight_v", "F32", {32, 32, 3, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.0.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.0.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.1.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.1.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.2.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.2.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.3.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.3.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.4.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.4.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.5.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.5.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.13.convs1.0.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.convs1.0.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.13.convs1.0.weight_v", "F32", {32, 32, 7, 0, 0}, 3},
+    {"decoder.resblocks.13.convs1.1.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.convs1.1.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.13.convs1.1.weight_v", "F32", {32, 32, 7, 0, 0}, 3},
+    {"decoder.resblocks.13.convs1.2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.convs1.2.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.13.convs1.2.weight_v", "F32", {32, 32, 7, 0, 0}, 3},
+    {"decoder.resblocks.13.convs2.0.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.convs2.0.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.13.convs2.0.weight_v", "F32", {32, 32, 7, 0, 0}, 3},
+    {"decoder.resblocks.13.convs2.1.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.convs2.1.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.13.convs2.1.weight_v", "F32", {32, 32, 7, 0, 0}, 3},
+    {"decoder.resblocks.13.convs2.2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.13.convs2.2.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.13.convs2.2.weight_v", "F32", {32, 32, 7, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.0.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.0.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.1.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.1.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.2.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.2.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.3.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.3.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.4.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.4.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.5.act.alpha", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.5.act.beta", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.14.convs1.0.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.convs1.0.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.14.convs1.0.weight_v", "F32", {32, 32, 11, 0, 0}, 3},
+    {"decoder.resblocks.14.convs1.1.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.convs1.1.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.14.convs1.1.weight_v", "F32", {32, 32, 11, 0, 0}, 3},
+    {"decoder.resblocks.14.convs1.2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.convs1.2.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.14.convs1.2.weight_v", "F32", {32, 32, 11, 0, 0}, 3},
+    {"decoder.resblocks.14.convs2.0.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.convs2.0.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.14.convs2.0.weight_v", "F32", {32, 32, 11, 0, 0}, 3},
+    {"decoder.resblocks.14.convs2.1.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.convs2.1.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.14.convs2.1.weight_v", "F32", {32, 32, 11, 0, 0}, 3},
+    {"decoder.resblocks.14.convs2.2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.14.convs2.2.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.14.convs2.2.weight_v", "F32", {32, 32, 11, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.0.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.0.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.1.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.1.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.2.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.2.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.3.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.3.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.4.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.4.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.5.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.5.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.15.convs1.0.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.convs1.0.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.15.convs1.0.weight_v", "F32", {16, 16, 3, 0, 0}, 3},
+    {"decoder.resblocks.15.convs1.1.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.convs1.1.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.15.convs1.1.weight_v", "F32", {16, 16, 3, 0, 0}, 3},
+    {"decoder.resblocks.15.convs1.2.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.convs1.2.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.15.convs1.2.weight_v", "F32", {16, 16, 3, 0, 0}, 3},
+    {"decoder.resblocks.15.convs2.0.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.convs2.0.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.15.convs2.0.weight_v", "F32", {16, 16, 3, 0, 0}, 3},
+    {"decoder.resblocks.15.convs2.1.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.convs2.1.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.15.convs2.1.weight_v", "F32", {16, 16, 3, 0, 0}, 3},
+    {"decoder.resblocks.15.convs2.2.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.15.convs2.2.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.15.convs2.2.weight_v", "F32", {16, 16, 3, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.0.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.0.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.1.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.1.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.2.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.2.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.3.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.3.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.4.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.4.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.5.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.5.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.16.convs1.0.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.convs1.0.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.16.convs1.0.weight_v", "F32", {16, 16, 7, 0, 0}, 3},
+    {"decoder.resblocks.16.convs1.1.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.convs1.1.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.16.convs1.1.weight_v", "F32", {16, 16, 7, 0, 0}, 3},
+    {"decoder.resblocks.16.convs1.2.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.convs1.2.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.16.convs1.2.weight_v", "F32", {16, 16, 7, 0, 0}, 3},
+    {"decoder.resblocks.16.convs2.0.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.convs2.0.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.16.convs2.0.weight_v", "F32", {16, 16, 7, 0, 0}, 3},
+    {"decoder.resblocks.16.convs2.1.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.convs2.1.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.16.convs2.1.weight_v", "F32", {16, 16, 7, 0, 0}, 3},
+    {"decoder.resblocks.16.convs2.2.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.16.convs2.2.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.16.convs2.2.weight_v", "F32", {16, 16, 7, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.0.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.0.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.1.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.1.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.2.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.2.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.3.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.3.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.4.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.4.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.5.act.alpha", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.5.act.beta", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.17.convs1.0.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.convs1.0.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.17.convs1.0.weight_v", "F32", {16, 16, 11, 0, 0}, 3},
+    {"decoder.resblocks.17.convs1.1.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.convs1.1.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.17.convs1.1.weight_v", "F32", {16, 16, 11, 0, 0}, 3},
+    {"decoder.resblocks.17.convs1.2.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.convs1.2.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.17.convs1.2.weight_v", "F32", {16, 16, 11, 0, 0}, 3},
+    {"decoder.resblocks.17.convs2.0.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.convs2.0.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.17.convs2.0.weight_v", "F32", {16, 16, 11, 0, 0}, 3},
+    {"decoder.resblocks.17.convs2.1.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.convs2.1.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.17.convs2.1.weight_v", "F32", {16, 16, 11, 0, 0}, 3},
+    {"decoder.resblocks.17.convs2.2.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.17.convs2.2.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.17.convs2.2.weight_v", "F32", {16, 16, 11, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.0.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.0.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.1.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.1.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.2.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.2.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.3.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.3.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.4.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.4.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.5.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.5.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.18.convs1.0.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.convs1.0.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.18.convs1.0.weight_v", "F32", {8, 8, 3, 0, 0}, 3},
+    {"decoder.resblocks.18.convs1.1.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.convs1.1.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.18.convs1.1.weight_v", "F32", {8, 8, 3, 0, 0}, 3},
+    {"decoder.resblocks.18.convs1.2.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.convs1.2.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.18.convs1.2.weight_v", "F32", {8, 8, 3, 0, 0}, 3},
+    {"decoder.resblocks.18.convs2.0.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.convs2.0.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.18.convs2.0.weight_v", "F32", {8, 8, 3, 0, 0}, 3},
+    {"decoder.resblocks.18.convs2.1.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.convs2.1.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.18.convs2.1.weight_v", "F32", {8, 8, 3, 0, 0}, 3},
+    {"decoder.resblocks.18.convs2.2.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.18.convs2.2.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.18.convs2.2.weight_v", "F32", {8, 8, 3, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.0.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.0.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.1.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.1.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.2.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.2.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.3.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.3.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.4.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.4.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.5.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.5.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.19.convs1.0.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.convs1.0.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.19.convs1.0.weight_v", "F32", {8, 8, 7, 0, 0}, 3},
+    {"decoder.resblocks.19.convs1.1.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.convs1.1.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.19.convs1.1.weight_v", "F32", {8, 8, 7, 0, 0}, 3},
+    {"decoder.resblocks.19.convs1.2.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.convs1.2.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.19.convs1.2.weight_v", "F32", {8, 8, 7, 0, 0}, 3},
+    {"decoder.resblocks.19.convs2.0.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.convs2.0.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.19.convs2.0.weight_v", "F32", {8, 8, 7, 0, 0}, 3},
+    {"decoder.resblocks.19.convs2.1.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.convs2.1.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.19.convs2.1.weight_v", "F32", {8, 8, 7, 0, 0}, 3},
+    {"decoder.resblocks.19.convs2.2.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.19.convs2.2.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.19.convs2.2.weight_v", "F32", {8, 8, 7, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.0.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.0.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.1.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.1.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.2.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.2.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.3.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.3.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.4.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.4.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.5.act.alpha", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.5.act.beta", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.2.convs1.0.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.convs1.0.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.2.convs1.0.weight_v", "F32", {512, 512, 11, 0, 0}, 3},
+    {"decoder.resblocks.2.convs1.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.convs1.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.2.convs1.1.weight_v", "F32", {512, 512, 11, 0, 0}, 3},
+    {"decoder.resblocks.2.convs1.2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.convs1.2.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.2.convs1.2.weight_v", "F32", {512, 512, 11, 0, 0}, 3},
+    {"decoder.resblocks.2.convs2.0.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.convs2.0.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.2.convs2.0.weight_v", "F32", {512, 512, 11, 0, 0}, 3},
+    {"decoder.resblocks.2.convs2.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.convs2.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.2.convs2.1.weight_v", "F32", {512, 512, 11, 0, 0}, 3},
+    {"decoder.resblocks.2.convs2.2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.2.convs2.2.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.2.convs2.2.weight_v", "F32", {512, 512, 11, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.0.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.0.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.1.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.1.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.2.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.2.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.3.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.3.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.4.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.4.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.5.act.alpha", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.5.act.beta", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.20.convs1.0.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.convs1.0.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.20.convs1.0.weight_v", "F32", {8, 8, 11, 0, 0}, 3},
+    {"decoder.resblocks.20.convs1.1.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.convs1.1.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.20.convs1.1.weight_v", "F32", {8, 8, 11, 0, 0}, 3},
+    {"decoder.resblocks.20.convs1.2.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.convs1.2.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.20.convs1.2.weight_v", "F32", {8, 8, 11, 0, 0}, 3},
+    {"decoder.resblocks.20.convs2.0.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.convs2.0.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.20.convs2.0.weight_v", "F32", {8, 8, 11, 0, 0}, 3},
+    {"decoder.resblocks.20.convs2.1.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.convs2.1.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.20.convs2.1.weight_v", "F32", {8, 8, 11, 0, 0}, 3},
+    {"decoder.resblocks.20.convs2.2.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.20.convs2.2.weight_g", "F32", {8, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.20.convs2.2.weight_v", "F32", {8, 8, 11, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.0.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.0.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.1.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.1.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.2.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.2.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.3.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.3.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.4.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.4.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.5.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.5.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.3.convs1.0.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.convs1.0.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.3.convs1.0.weight_v", "F32", {256, 256, 3, 0, 0}, 3},
+    {"decoder.resblocks.3.convs1.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.convs1.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.3.convs1.1.weight_v", "F32", {256, 256, 3, 0, 0}, 3},
+    {"decoder.resblocks.3.convs1.2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.convs1.2.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.3.convs1.2.weight_v", "F32", {256, 256, 3, 0, 0}, 3},
+    {"decoder.resblocks.3.convs2.0.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.convs2.0.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.3.convs2.0.weight_v", "F32", {256, 256, 3, 0, 0}, 3},
+    {"decoder.resblocks.3.convs2.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.convs2.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.3.convs2.1.weight_v", "F32", {256, 256, 3, 0, 0}, 3},
+    {"decoder.resblocks.3.convs2.2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.3.convs2.2.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.3.convs2.2.weight_v", "F32", {256, 256, 3, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.0.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.0.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.1.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.1.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.2.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.2.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.3.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.3.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.4.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.4.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.5.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.5.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.4.convs1.0.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.convs1.0.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.4.convs1.0.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"decoder.resblocks.4.convs1.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.convs1.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.4.convs1.1.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"decoder.resblocks.4.convs1.2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.convs1.2.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.4.convs1.2.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"decoder.resblocks.4.convs2.0.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.convs2.0.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.4.convs2.0.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"decoder.resblocks.4.convs2.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.convs2.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.4.convs2.1.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"decoder.resblocks.4.convs2.2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.4.convs2.2.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.4.convs2.2.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.0.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.0.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.1.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.1.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.2.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.2.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.3.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.3.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.4.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.4.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.5.act.alpha", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.5.act.beta", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.5.convs1.0.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.convs1.0.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.5.convs1.0.weight_v", "F32", {256, 256, 11, 0, 0}, 3},
+    {"decoder.resblocks.5.convs1.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.convs1.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.5.convs1.1.weight_v", "F32", {256, 256, 11, 0, 0}, 3},
+    {"decoder.resblocks.5.convs1.2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.convs1.2.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.5.convs1.2.weight_v", "F32", {256, 256, 11, 0, 0}, 3},
+    {"decoder.resblocks.5.convs2.0.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.convs2.0.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.5.convs2.0.weight_v", "F32", {256, 256, 11, 0, 0}, 3},
+    {"decoder.resblocks.5.convs2.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.convs2.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.5.convs2.1.weight_v", "F32", {256, 256, 11, 0, 0}, 3},
+    {"decoder.resblocks.5.convs2.2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.5.convs2.2.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.5.convs2.2.weight_v", "F32", {256, 256, 11, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.0.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.0.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.1.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.1.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.2.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.2.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.3.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.3.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.4.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.4.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.5.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.5.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.6.convs1.0.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.convs1.0.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.6.convs1.0.weight_v", "F32", {128, 128, 3, 0, 0}, 3},
+    {"decoder.resblocks.6.convs1.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.convs1.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.6.convs1.1.weight_v", "F32", {128, 128, 3, 0, 0}, 3},
+    {"decoder.resblocks.6.convs1.2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.convs1.2.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.6.convs1.2.weight_v", "F32", {128, 128, 3, 0, 0}, 3},
+    {"decoder.resblocks.6.convs2.0.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.convs2.0.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.6.convs2.0.weight_v", "F32", {128, 128, 3, 0, 0}, 3},
+    {"decoder.resblocks.6.convs2.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.convs2.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.6.convs2.1.weight_v", "F32", {128, 128, 3, 0, 0}, 3},
+    {"decoder.resblocks.6.convs2.2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.6.convs2.2.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.6.convs2.2.weight_v", "F32", {128, 128, 3, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.0.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.0.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.1.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.1.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.2.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.2.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.3.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.3.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.4.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.4.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.5.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.5.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.7.convs1.0.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.convs1.0.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.7.convs1.0.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"decoder.resblocks.7.convs1.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.convs1.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.7.convs1.1.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"decoder.resblocks.7.convs1.2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.convs1.2.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.7.convs1.2.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"decoder.resblocks.7.convs2.0.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.convs2.0.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.7.convs2.0.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"decoder.resblocks.7.convs2.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.convs2.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.7.convs2.1.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"decoder.resblocks.7.convs2.2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.7.convs2.2.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.7.convs2.2.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.0.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.0.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.1.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.1.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.2.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.2.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.3.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.3.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.4.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.4.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.5.act.alpha", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.5.act.beta", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.8.convs1.0.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.convs1.0.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.8.convs1.0.weight_v", "F32", {128, 128, 11, 0, 0}, 3},
+    {"decoder.resblocks.8.convs1.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.convs1.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.8.convs1.1.weight_v", "F32", {128, 128, 11, 0, 0}, 3},
+    {"decoder.resblocks.8.convs1.2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.convs1.2.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.8.convs1.2.weight_v", "F32", {128, 128, 11, 0, 0}, 3},
+    {"decoder.resblocks.8.convs2.0.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.convs2.0.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.8.convs2.0.weight_v", "F32", {128, 128, 11, 0, 0}, 3},
+    {"decoder.resblocks.8.convs2.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.convs2.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.8.convs2.1.weight_v", "F32", {128, 128, 11, 0, 0}, 3},
+    {"decoder.resblocks.8.convs2.2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.8.convs2.2.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.8.convs2.2.weight_v", "F32", {128, 128, 11, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.0.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.0.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.0.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.0.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.1.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.1.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.1.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.1.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.2.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.2.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.2.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.2.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.3.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.3.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.3.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.3.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.4.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.4.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.4.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.4.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.5.act.alpha", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.5.act.beta", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.activations.5.downsample.lowpass.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.activations.5.upsample.filter", "F32", {1, 1, 12, 0, 0}, 3},
+    {"decoder.resblocks.9.convs1.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.convs1.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.9.convs1.0.weight_v", "F32", {64, 64, 3, 0, 0}, 3},
+    {"decoder.resblocks.9.convs1.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.convs1.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.9.convs1.1.weight_v", "F32", {64, 64, 3, 0, 0}, 3},
+    {"decoder.resblocks.9.convs1.2.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.convs1.2.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.9.convs1.2.weight_v", "F32", {64, 64, 3, 0, 0}, 3},
+    {"decoder.resblocks.9.convs2.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.convs2.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.9.convs2.0.weight_v", "F32", {64, 64, 3, 0, 0}, 3},
+    {"decoder.resblocks.9.convs2.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.convs2.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.9.convs2.1.weight_v", "F32", {64, 64, 3, 0, 0}, 3},
+    {"decoder.resblocks.9.convs2.2.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.resblocks.9.convs2.2.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.resblocks.9.convs2.2.weight_v", "F32", {64, 64, 3, 0, 0}, 3},
+    {"decoder.ups.0.0.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"decoder.ups.0.0.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"decoder.ups.0.0.weight_v", "F32", {1024, 512, 9, 0, 0}, 3},
+    {"decoder.ups.1.0.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"decoder.ups.1.0.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"decoder.ups.1.0.weight_v", "F32", {512, 256, 9, 0, 0}, 3},
+    {"decoder.ups.2.0.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"decoder.ups.2.0.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"decoder.ups.2.0.weight_v", "F32", {256, 128, 4, 0, 0}, 3},
+    {"decoder.ups.3.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"decoder.ups.3.0.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"decoder.ups.3.0.weight_v", "F32", {128, 64, 4, 0, 0}, 3},
+    {"decoder.ups.4.0.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"decoder.ups.4.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"decoder.ups.4.0.weight_v", "F32", {64, 32, 4, 0, 0}, 3},
+    {"decoder.ups.5.0.bias", "F32", {16, 0, 0, 0, 0}, 1},
+    {"decoder.ups.5.0.weight_g", "F32", {32, 1, 1, 0, 0}, 3},
+    {"decoder.ups.5.0.weight_v", "F32", {32, 16, 4, 0, 0}, 3},
+    {"decoder.ups.6.0.bias", "F32", {8, 0, 0, 0, 0}, 1},
+    {"decoder.ups.6.0.weight_g", "F32", {16, 1, 1, 0, 0}, 3},
+    {"decoder.ups.6.0.weight_v", "F32", {16, 8, 4, 0, 0}, 3},
+    {"encoder.block.0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"encoder.block.0.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"encoder.block.0.weight_v", "F32", {64, 1, 7, 0, 0}, 3},
+    {"encoder.block.1.block.0.block.0.alpha", "F32", {1, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.0.block.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"encoder.block.1.block.0.block.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"encoder.block.1.block.0.block.1.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"encoder.block.1.block.0.block.2.alpha", "F32", {1, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.0.block.3.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"encoder.block.1.block.0.block.3.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"encoder.block.1.block.0.block.3.weight_v", "F32", {64, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.1.block.0.alpha", "F32", {1, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.1.block.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"encoder.block.1.block.1.block.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"encoder.block.1.block.1.block.1.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"encoder.block.1.block.1.block.2.alpha", "F32", {1, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.1.block.3.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"encoder.block.1.block.1.block.3.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"encoder.block.1.block.1.block.3.weight_v", "F32", {64, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.2.block.0.alpha", "F32", {1, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.2.block.1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"encoder.block.1.block.2.block.1.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"encoder.block.1.block.2.block.1.weight_v", "F32", {64, 64, 7, 0, 0}, 3},
+    {"encoder.block.1.block.2.block.2.alpha", "F32", {1, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.2.block.3.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"encoder.block.1.block.2.block.3.weight_g", "F32", {64, 1, 1, 0, 0}, 3},
+    {"encoder.block.1.block.2.block.3.weight_v", "F32", {64, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.3.alpha", "F32", {1, 64, 1, 0, 0}, 3},
+    {"encoder.block.1.block.4.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.block.1.block.4.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"encoder.block.1.block.4.weight_v", "F32", {128, 64, 4, 0, 0}, 3},
+    {"encoder.block.2.block.0.block.0.alpha", "F32", {1, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.0.block.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.block.2.block.0.block.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"encoder.block.2.block.0.block.1.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"encoder.block.2.block.0.block.2.alpha", "F32", {1, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.0.block.3.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.block.2.block.0.block.3.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"encoder.block.2.block.0.block.3.weight_v", "F32", {128, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.1.block.0.alpha", "F32", {1, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.1.block.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.block.2.block.1.block.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"encoder.block.2.block.1.block.1.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"encoder.block.2.block.1.block.2.alpha", "F32", {1, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.1.block.3.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.block.2.block.1.block.3.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"encoder.block.2.block.1.block.3.weight_v", "F32", {128, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.2.block.0.alpha", "F32", {1, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.2.block.1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.block.2.block.2.block.1.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"encoder.block.2.block.2.block.1.weight_v", "F32", {128, 128, 7, 0, 0}, 3},
+    {"encoder.block.2.block.2.block.2.alpha", "F32", {1, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.2.block.3.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.block.2.block.2.block.3.weight_g", "F32", {128, 1, 1, 0, 0}, 3},
+    {"encoder.block.2.block.2.block.3.weight_v", "F32", {128, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.3.alpha", "F32", {1, 128, 1, 0, 0}, 3},
+    {"encoder.block.2.block.4.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.block.2.block.4.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"encoder.block.2.block.4.weight_v", "F32", {256, 128, 8, 0, 0}, 3},
+    {"encoder.block.3.block.0.block.0.alpha", "F32", {1, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.0.block.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.block.3.block.0.block.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"encoder.block.3.block.0.block.1.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"encoder.block.3.block.0.block.2.alpha", "F32", {1, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.0.block.3.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.block.3.block.0.block.3.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"encoder.block.3.block.0.block.3.weight_v", "F32", {256, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.1.block.0.alpha", "F32", {1, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.1.block.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.block.3.block.1.block.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"encoder.block.3.block.1.block.1.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"encoder.block.3.block.1.block.2.alpha", "F32", {1, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.1.block.3.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.block.3.block.1.block.3.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"encoder.block.3.block.1.block.3.weight_v", "F32", {256, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.2.block.0.alpha", "F32", {1, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.2.block.1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.block.3.block.2.block.1.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"encoder.block.3.block.2.block.1.weight_v", "F32", {256, 256, 7, 0, 0}, 3},
+    {"encoder.block.3.block.2.block.2.alpha", "F32", {1, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.2.block.3.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.block.3.block.2.block.3.weight_g", "F32", {256, 1, 1, 0, 0}, 3},
+    {"encoder.block.3.block.2.block.3.weight_v", "F32", {256, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.3.alpha", "F32", {1, 256, 1, 0, 0}, 3},
+    {"encoder.block.3.block.4.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.block.3.block.4.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"encoder.block.3.block.4.weight_v", "F32", {512, 256, 8, 0, 0}, 3},
+    {"encoder.block.4.block.0.block.0.alpha", "F32", {1, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.0.block.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.block.4.block.0.block.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"encoder.block.4.block.0.block.1.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"encoder.block.4.block.0.block.2.alpha", "F32", {1, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.0.block.3.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.block.4.block.0.block.3.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"encoder.block.4.block.0.block.3.weight_v", "F32", {512, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.1.block.0.alpha", "F32", {1, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.1.block.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.block.4.block.1.block.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"encoder.block.4.block.1.block.1.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"encoder.block.4.block.1.block.2.alpha", "F32", {1, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.1.block.3.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.block.4.block.1.block.3.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"encoder.block.4.block.1.block.3.weight_v", "F32", {512, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.2.block.0.alpha", "F32", {1, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.2.block.1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.block.4.block.2.block.1.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"encoder.block.4.block.2.block.1.weight_v", "F32", {512, 512, 7, 0, 0}, 3},
+    {"encoder.block.4.block.2.block.2.alpha", "F32", {1, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.2.block.3.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.block.4.block.2.block.3.weight_g", "F32", {512, 1, 1, 0, 0}, 3},
+    {"encoder.block.4.block.2.block.3.weight_v", "F32", {512, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.3.alpha", "F32", {1, 512, 1, 0, 0}, 3},
+    {"encoder.block.4.block.4.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.block.4.block.4.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"encoder.block.4.block.4.weight_v", "F32", {1024, 512, 10, 0, 0}, 3},
+    {"encoder.block.5.block.0.block.0.alpha", "F32", {1, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.0.block.1.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.block.5.block.0.block.1.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"encoder.block.5.block.0.block.1.weight_v", "F32", {1024, 1024, 7, 0, 0}, 3},
+    {"encoder.block.5.block.0.block.2.alpha", "F32", {1, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.0.block.3.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.block.5.block.0.block.3.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"encoder.block.5.block.0.block.3.weight_v", "F32", {1024, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.1.block.0.alpha", "F32", {1, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.1.block.1.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.block.5.block.1.block.1.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"encoder.block.5.block.1.block.1.weight_v", "F32", {1024, 1024, 7, 0, 0}, 3},
+    {"encoder.block.5.block.1.block.2.alpha", "F32", {1, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.1.block.3.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.block.5.block.1.block.3.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"encoder.block.5.block.1.block.3.weight_v", "F32", {1024, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.2.block.0.alpha", "F32", {1, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.2.block.1.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.block.5.block.2.block.1.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"encoder.block.5.block.2.block.1.weight_v", "F32", {1024, 1024, 7, 0, 0}, 3},
+    {"encoder.block.5.block.2.block.2.alpha", "F32", {1, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.2.block.3.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.block.5.block.2.block.3.weight_g", "F32", {1024, 1, 1, 0, 0}, 3},
+    {"encoder.block.5.block.2.block.3.weight_v", "F32", {1024, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.3.alpha", "F32", {1, 1024, 1, 0, 0}, 3},
+    {"encoder.block.5.block.4.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"encoder.block.5.block.4.weight_g", "F32", {2048, 1, 1, 0, 0}, 3},
+    {"encoder.block.5.block.4.weight_v", "F32", {2048, 1024, 10, 0, 0}, 3},
+    {"encoder.block.6.alpha", "F32", {1, 2048, 1, 0, 0}, 3},
+    {"encoder.block.7.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"encoder.block.7.weight_g", "F32", {2048, 1, 1, 0, 0}, 3},
+    {"encoder.block.7.weight_v", "F32", {2048, 2048, 3, 0, 0}, 3},
+    {"logs_proj.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"logs_proj.weight", "F32", {32, 32, 1, 0, 0}, 3},
+    {"mean_proj.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"mean_proj.weight", "F32", {32, 32, 1, 0, 0}, 3},
+    {"pre_block.attn.proj.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"pre_block.attn.proj.weight", "F32", {32, 32, 0, 0, 0}, 2},
+    {"pre_block.attn.q_bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"pre_block.attn.qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"pre_block.attn.v_bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"pre_block.attn.zero_k_bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"pre_block.mlp.norm.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"pre_block.mlp.norm.weight", "F32", {32, 0, 0, 0, 0}, 1},
+    {"pre_block.mlp.w0.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"pre_block.mlp.w0.weight", "F32", {64, 32, 0, 0, 0}, 2},
+    {"pre_block.mlp.w1.bias", "F32", {64, 0, 0, 0, 0}, 1},
+    {"pre_block.mlp.w1.weight", "F32", {64, 32, 0, 0, 0}, 2},
+    {"pre_block.mlp.w2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"pre_block.mlp.w2.weight", "F32", {32, 64, 0, 0, 0}, 2},
+    {"pre_block.norm1.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"pre_block.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"pre_block.norm2.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"pre_block.norm2.weight", "F32", {32, 0, 0, 0, 0}, 1},
+    {"pre_block.norm3.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"pre_block.norm3.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"pre_block.proj.bias", "F32", {32, 0, 0, 0, 0}, 1},
+    {"pre_block.proj.weight", "F32", {32, 2048, 0, 0, 0}, 2},
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_encoder_goldens.inc b/tests/vllm/models/minimax_h3_encoder_goldens.inc
new file mode 100644
index 000000000..5f61ccfe7
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_encoder_goldens.inc
@@ -0,0 +1,171 @@
+// GENERATED by scripts/gen-minimax-h3-encoder-goldens.py — DO NOT EDIT BY HAND.
+//
+// MiniMax-H3 ENCODER text-tower goldens from the UPSTREAM vLLM-Omni
+// MiniMaxH3Qwen3VLTextModel at reduced dimensions. Weights come from the shared
+// H3Rand stream, so no weight byte is checked in. The three H3 deltas vs a stock
+// Qwen3-VL text model — layer truncation, the UNNORMALIZED output, and DeepStack
+// injection into the first N layers — are all exercised here.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3EncVocab = 32;
+inline constexpr int64_t kH3EncHidden = 16;
+inline constexpr int64_t kH3EncConfigLayers = 4;
+inline constexpr int64_t kH3EncSelectedLayer = 3;
+inline constexpr int64_t kH3EncHeads = 2;
+inline constexpr int64_t kH3EncKvHeads = 1;
+inline constexpr int64_t kH3EncHeadDim = 8;
+inline constexpr int64_t kH3EncIntermediate = 32;
+inline constexpr int64_t kH3EncSeq = 5;
+inline constexpr int64_t kH3EncDeepstackLayers = 2;
+inline constexpr int64_t kH3EncNumVisual = 2;
+
+inline constexpr int64_t kH3EncMropeSection[] = {
+    2, 1, 1,
+};
+
+inline constexpr int64_t kH3EncVisualMask[] = {
+    0, 1, 0, 1, 0,
+};
+
+inline constexpr float kH3EncGolden[] = {
+    0.759512186f, -0.496689558f, 0.575350404f, -0.138985157f, -0.502833664f, 0.72849226f,
+    -0.67851907f, -0.952144086f, 0.0457006395f, -0.198997617f, -0.817631721f, -0.270105451f,
+    -0.497347713f, -0.785627007f, 0.417794794f, -0.190108821f, -0.875258744f, 0.539779723f,
+    0.0392484888f, -0.0508909225f, -0.127615809f, 0.289791524f, 0.13331081f, -0.980086267f,
+    -0.943603218f, 0.257566631f, -0.287599623f, 0.596245646f, 0.370117754f, -0.347353935f,
+    0.387310594f, -0.791569054f, -0.659221888f, 0.38751772f, 0.826508403f, 0.453633398f,
+    0.124531031f, -0.550619304f, -0.441919774f, -1.03951919f, -0.986524761f, -0.641365051f,
+    -0.100644484f, -0.16712141f, -0.298040837f, 0.732460618f, -0.763768971f, -0.666643977f,
+    -0.199069262f, 0.253491342f, -0.146885276f, 0.56197536f, -0.644165277f, 0.283776164f,
+    0.397704691f, -0.578888357f, -0.0972060561f, 1.03570926f, -0.267905474f, -0.413426131f,
+    0.227487221f, -0.603166997f, 0.358375698f, 0.693947911f, -0.868382454f, -0.805462658f,
+    -0.127138093f, 0.0738371015f, 0.210017145f, 0.197653428f, 0.0539482161f, 0.259400904f,
+    0.295184135f, -0.862840056f, 0.442789912f, -0.74041748f, 1.004776f, 0.381628364f,
+    0.938659549f, 0.019439429f,
+};
+
+inline constexpr float kH3EncDeepstackGolden[] = {
+    0.759512186f, -0.496689558f, 0.575350404f, -0.138985157f, -0.502833664f, 0.72849226f,
+    -0.67851907f, -0.952144086f, 0.0457006395f, -0.198997617f, -0.817631721f, -0.270105451f,
+    -0.497347713f, -0.785627007f, 0.417794794f, -0.190108821f, -0.899219334f, 0.531076908f,
+    0.128559053f, -0.0382265076f, -0.105097301f, 0.316806912f, 0.114943229f, -0.843082428f,
+    -0.893536389f, 0.393119067f, -0.217759907f, 0.762600243f, 0.287814796f, -0.433343232f,
+    0.538769007f, -0.70133549f, -0.659915626f, 0.38711682f, 0.833389401f, 0.457399935f,
+    0.128361821f, -0.541667759f, -0.441208273f, -1.04083812f, -0.98752296f, -0.641955495f,
+    -0.0971057937f, -0.172647446f, -0.3033759f, 0.732551455f, -0.770117819f, -0.661370099f,
+    -0.16913195f, 0.235662729f, -0.0797856376f, 0.514339983f, -0.538012743f, 0.27559334f,
+    0.432524621f, -0.578369379f, 0.0249750149f, 1.08171213f, -0.230422348f, -0.53919214f,
+    0.127380282f, -0.76925683f, 0.256615281f, 0.600108385f, -0.875863373f, -0.808767617f,
+    -0.129511222f, 0.077516973f, 0.222321644f, 0.195762068f, 0.0478144065f, 0.266893536f,
+    0.304818541f, -0.867132246f, 0.450773448f, -0.739033639f, 1.00516057f, 0.377712041f,
+    0.941497624f, 0.0236697085f,
+};
+
+inline constexpr int64_t kH3EncVisDim = 16;
+inline constexpr int64_t kH3EncVisHeads = 2;
+inline constexpr int64_t kH3EncVisIntermediate = 32;
+inline constexpr int64_t kH3EncVisSeq = 6;
+
+inline constexpr int64_t kH3EncVisCuSeqlens[] = {
+    0, 4, 6,
+};
+
+inline constexpr float kH3EncVisCos[] = {
+    0.931782424f, 0.950272679f, 0.823288381f, 0.995327711f, 0.972027063f, 0.903232992f,
+    0.908354938f, 0.913416505f, 0.938608468f, 0.964472175f, 0.830044389f, 0.999119759f,
+    0.570598423f, 0.997091055f, 0.776158392f, 0.765999496f, 0.558819354f, 0.999826133f,
+    0.634648383f, 0.872251093f, 0.855444252f, 0.994714737f, 0.99504149f, 0.960590065f,
+    0.785211086f, 0.972135007f, 0.542473018f, 0.586352527f, 0.663729668f, 0.987614632f,
+    0.683065653f, 0.998012125f, 0.957524717f, 0.548226953f, 0.744504213f, 0.980726957f,
+    0.997349143f, 0.998512566f, 0.567449152f, 0.649225056f, 0.677686691f, 0.620428801f,
+    0.871058941f, 0.924919069f, 0.988862634f, 0.551037729f, 0.990496576f, 0.972672462f,
+};
+
+inline constexpr float kH3EncVisSin[] = {
+    0.435661554f, 0.682460785f, -0.358310938f, 0.616901278f, -0.0885099769f, -0.308968574f,
+    -0.700154424f, -0.627880931f, 0.338933051f, 0.113764323f, -0.549741447f, 0.221605122f,
+    0.798399329f, -0.591639876f, 0.144033104f, 0.202846169f, 0.35833022f, -0.828618884f,
+    0.306378007f, -0.669165075f, 0.631836772f, -0.100742221f, -0.77620101f, 0.201684892f,
+    0.352234483f, -0.0720588416f, 0.748064935f, -0.277667612f, -0.709519446f, -0.0560839958f,
+    0.436549723f, 0.316705078f, -0.636719108f, -0.455395848f, -0.734584033f, 0.109721042f,
+    -0.810053647f, -0.420919299f, -0.115061685f, 0.529824972f, -0.771215975f, -0.217031509f,
+    -0.825304508f, 0.499420077f, 0.114810564f, -0.546791792f, 0.454901636f, -0.44971177f,
+};
+
+inline constexpr float kH3EncVisBlockGolden[] = {
+    -0.132416293f, -0.868744135f, -0.785114586f, -0.491155654f, 0.776331186f, 0.128175363f,
+    0.321017623f, 0.800629258f, 0.609754026f, 0.111145318f, 0.578666568f, -0.407251179f,
+    0.452991933f, -0.767088771f, 0.0919189826f, 0.246388644f, 0.292690694f, -0.118139729f,
+    -0.250950128f, 1.01031911f, -0.782920659f, 0.617864072f, 0.432187915f, -0.0123146307f,
+    0.579737008f, -0.738230288f, -0.878363311f, 0.875148892f, 0.210565656f, -0.98234272f,
+    0.224150687f, 0.400407642f, 0.347939849f, 0.91909039f, 0.606235147f, 0.78076005f,
+    -0.757147253f, 0.619246066f, -0.0414515063f, 0.674002111f, 0.0799828917f, -0.417796701f,
+    0.76274085f, 0.271409959f, 1.08772123f, -1.00227427f, -0.728636503f, 0.540698171f,
+    1.05969262f, 0.787458479f, -0.30856505f, 0.170044824f, -0.467257679f, -0.644100547f,
+    -0.329583645f, -0.478515863f, 0.823340833f, -0.711173594f, 0.585540175f, -0.583814561f,
+    -0.790987551f, -0.105440438f, -0.716952622f, -0.222425923f, 0.225168571f, -0.55318737f,
+    0.567298412f, -1.02649021f, 0.85226661f, -0.257025599f, -0.9227947f, -0.394220859f,
+    0.295500755f, 0.450971097f, 0.346727937f, 1.02281499f, -0.865128517f, -0.906113684f,
+    0.514386296f, 0.0401468165f, 0.562354743f, -0.437545061f, 0.363177598f, -0.57490778f,
+    -0.35507381f, -0.48226136f, 0.640452743f, 0.295252532f, -0.716683149f, 0.886249602f,
+    0.634117842f, -0.767577708f, -0.0237874836f, 0.924207866f, -0.112672955f, 0.0592343248f,
+};
+
+inline constexpr int64_t kH3EncTowerDepth = 2;
+inline constexpr int64_t kH3EncTowerPatch = 2;
+inline constexpr int64_t kH3EncTowerTemporalPatch = 2;
+inline constexpr int64_t kH3EncTowerInCh = 3;
+inline constexpr int64_t kH3EncTowerMerge = 2;
+inline constexpr int64_t kH3EncTowerOutHidden = 16;
+inline constexpr int64_t kH3EncTowerNumPos = 16;
+inline constexpr int64_t kH3EncTowerPatches = 20;
+inline constexpr int64_t kH3EncTowerMergedRows = 5;
+inline constexpr int64_t kH3EncTowerDeepstackCount = 1;
+
+inline constexpr int64_t kH3EncTowerGridThw[] = {
+    1, 4, 4, 1, 2, 2,
+};
+
+inline constexpr int64_t kH3EncTowerDeepstackIdx[] = {
+    0,
+};
+
+inline constexpr float kH3EncTowerMergedGolden[] = {
+    0.0734016299f, 0.484152764f, 0.231409967f, 0.0259073731f, -0.160809577f, -0.00215015467f,
+    0.243104622f, -0.114144877f, 0.00860065781f, 0.342887372f, 0.308641523f, 0.134190291f,
+    -0.130593568f, -0.221678153f, -0.211331829f, -0.0852992684f, -0.0288632233f, 0.138906345f,
+    0.0793285444f, -0.0420917608f, -0.107959993f, 0.0817306191f, 0.024214698f, 0.103693008f,
+    -0.183817461f, 0.13904117f, 0.0878035128f, -0.0310007259f, -0.0564524084f, -0.0612307563f,
+    -0.176377699f, -0.0793815851f, 0.0679543614f, 0.22185488f, -0.00822003931f, 0.0967893898f,
+    0.00909533538f, -0.0843603164f, 0.155902296f, 0.156827629f, -0.0537412688f, -0.0161741823f,
+    0.246058434f, 0.121254593f, -0.216048598f, -0.11855796f, -0.192702726f, -0.0246881209f,
+    0.110518441f, 0.284806758f, -0.0219339877f, 0.0320352763f, -0.131076083f, -0.13778612f,
+    -0.0782208219f, -0.140480518f, 0.184194833f, 0.0879209787f, 0.175409123f, -0.0354161561f,
+    -0.21358484f, 0.0435613096f, -0.218591079f, -0.0997961462f, -0.106288284f, 0.00417526253f,
+    -0.0419357717f, 0.22269991f, 0.229173243f, 0.0320467614f, 0.105687f, 0.141913772f,
+    0.220896482f, -0.0530066192f, 0.0651995987f, -0.217160836f, -0.0502597094f, -0.143725321f,
+    -0.206476122f, -0.129159451f,
+};
+
+inline constexpr float kH3EncTowerDeepstackGolden[] = {
+    0.0366771482f, 0.0500522554f, 0.0632700622f, -0.0132507635f, 0.127984777f, -0.0683151931f,
+    0.234008223f, -0.0398214199f, -0.0480353832f, -0.0552254915f, 0.128674209f, -0.00246609375f,
+    -0.117313504f, 0.176323161f, 0.00313843694f, 0.0215740874f, -0.0432741418f, -0.00549815502f,
+    -0.0789804831f, -0.0727825314f, 0.0688653812f, -0.00675807521f, -0.0690801665f, 0.0604482442f,
+    -0.00786312856f, -0.134185225f, 0.000295617618f, 0.0439516231f, -0.00988566596f, 0.147329822f,
+    0.095253095f, -0.0569473952f, 0.0270558037f, 0.274674058f, -0.169808462f, -0.0902684852f,
+    0.194673106f, -0.0702420995f, 0.0378384516f, 0.0423659831f, -0.0291087963f, -0.13819316f,
+    0.193568766f, 0.194629043f, -0.0911763608f, 0.0370840169f, 0.0754005983f, -0.116867974f,
+    -0.164699331f, -0.00456197048f, 0.0124569898f, -0.0331945717f, -0.0984169245f, -0.0173999816f,
+    -0.0624839962f, -0.115639068f, 0.125765294f, -0.168902218f, -0.041303806f, 0.00988831371f,
+    0.0418260917f, 0.0228001345f, 0.0781365335f, -0.00156387966f, 0.0623706654f, -0.137694344f,
+    0.0264124777f, -0.0455154106f, -0.0880609006f, -0.0884368196f, 0.0300565958f, 0.00677479804f,
+    -0.0854713023f, 0.0879662856f, -0.0824910626f, 0.0583208427f, -0.0481380671f, -0.112981915f,
+    -0.17082642f, 0.117758311f,
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_gguf_manifest.inc b/tests/vllm/models/minimax_h3_gguf_manifest.inc
new file mode 100644
index 000000000..6cb363589
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_gguf_manifest.inc
@@ -0,0 +1,564 @@
+// GENERATED by scripts/gen-minimax-h3-gguf-manifest.py — DO NOT EDIT BY HAND.
+//
+// The tensor manifest of a REAL ComfyUI-format MiniMax-H3 GGUF
+// (GGUF v3, 535 tensors, architecture 'wan', file_type 12). Names, dims and ggml type ids only —
+// no weight bytes. This is what gates the loader's name map and shape
+// resolution against a real checkpoint. See .agents/specs/minimax-h3.md.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3GgufTensorCount = 535;
+inline constexpr int64_t kH3GgufVersion = 3;
+inline constexpr const char* kH3GgufArchitecture = "wan";
+
+struct H3GgufTensor {
+  const char* name;
+  int64_t dims[4];   // GGUF ne order (reversed vs torch), 0-padded
+  int32_t n_dims;
+  uint32_t ggml_type;
+  int64_t orig_shape[4];  // comfy.gguf.orig_shape.<name>, 0 if absent
+  int32_t orig_n_dims;    // 0 when the key is absent
+};
+
+inline constexpr H3GgufTensor kH3GgufTensors[] = {
+    {"audio_patch_proj.bias", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"audio_patch_proj.weight", {32, 5376, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"blocks.0.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.0.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.0.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.0.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.0.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.0.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.0.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.0.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.0.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.0.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.1.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.1.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.1.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.1.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.1.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.1.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.1.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.1.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.1.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.1.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.10.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.10.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.10.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.10.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.10.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.10.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.10.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.10.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.10.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.10.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.11.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.11.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.11.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.11.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.11.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.11.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.11.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.11.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.11.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.11.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.12.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.12.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.12.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.12.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.12.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.12.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.12.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.12.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.12.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.12.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.13.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.13.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.13.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.13.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.13.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.13.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.13.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.13.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.13.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.13.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.14.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.14.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.14.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.14.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.14.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.14.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.14.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.14.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.14.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.14.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.15.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.15.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.15.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.15.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.15.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.15.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.15.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.15.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.15.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.15.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.16.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.16.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.16.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.16.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.16.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.16.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.16.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.16.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.16.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.16.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.17.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.17.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.17.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.17.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.17.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.17.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.17.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.17.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.17.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.17.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.18.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.18.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.18.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.18.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.18.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.18.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.18.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.18.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.18.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.18.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.19.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.19.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.19.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.19.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.19.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.19.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.19.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.19.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.19.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.19.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.2.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.2.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.2.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.2.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.2.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.2.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.2.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.2.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.2.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.2.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.20.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.20.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.20.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.20.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.20.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.20.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.20.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.20.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.20.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.20.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.21.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.21.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.21.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.21.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.21.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.21.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.21.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.21.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.21.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.21.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.22.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.22.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.22.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.22.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.22.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.22.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.22.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.22.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.22.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.22.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.23.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.23.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.23.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.23.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.23.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.23.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.23.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.23.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.23.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.23.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.24.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.24.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.24.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.24.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.24.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.24.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.24.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.24.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.24.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.24.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.25.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.25.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.25.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.25.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.25.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.25.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.25.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.25.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.25.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.25.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.26.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.26.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.26.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.26.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.26.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.26.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.26.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.26.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.26.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.26.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.27.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.27.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.27.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.27.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.27.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.27.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.27.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.27.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.27.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.27.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.28.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.28.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.28.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.28.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.28.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.28.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.28.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.28.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.28.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.28.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.29.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.29.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.29.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.29.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.29.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.29.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.29.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.29.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.29.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.29.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.3.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.3.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.3.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.3.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.3.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.3.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.3.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.3.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.3.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.3.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.30.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.30.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.30.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.30.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.30.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.30.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.30.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.30.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.30.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.30.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.31.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.31.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.31.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.31.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.31.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.31.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.31.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.31.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.31.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.31.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.32.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.32.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.32.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.32.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.32.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.32.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.32.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.32.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.32.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.32.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.33.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.33.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.33.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.33.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.33.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.33.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.33.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.33.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.33.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.33.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.34.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.34.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.34.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.34.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.34.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.34.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.34.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.34.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.34.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.34.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.35.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.35.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.35.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.35.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.35.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.35.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.35.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.35.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.35.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.35.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.36.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.36.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.36.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.36.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.36.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.36.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.36.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.36.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.36.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.36.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.37.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.37.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.37.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.37.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.37.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.37.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.37.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.37.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.37.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.37.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.38.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.38.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.38.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.38.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.38.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.38.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.38.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.38.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.38.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.38.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.39.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.39.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.39.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.39.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.39.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.39.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.39.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.39.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.39.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.39.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.4.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.4.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.4.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.4.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.4.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.4.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.4.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.4.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.4.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.4.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.40.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.40.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.40.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.40.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.40.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.40.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.40.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.40.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.40.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.40.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.41.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.41.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.41.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.41.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.41.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.41.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.41.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.41.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.41.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.41.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.42.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.42.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.42.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.42.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.42.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.42.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.42.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.42.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.42.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.42.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.43.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.43.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.43.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.43.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.43.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.43.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.43.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.43.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.43.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.43.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.44.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.44.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.44.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.44.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.44.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.44.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.44.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.44.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.44.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.44.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.45.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.45.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.45.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.45.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.45.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.45.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.45.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.45.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.45.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.45.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.46.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.46.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.46.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.46.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.46.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.46.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.46.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.46.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.46.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.46.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.47.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.47.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.47.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.47.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.47.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.47.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.47.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.47.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.47.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.47.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.48.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.48.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.48.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.48.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.48.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.48.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.48.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.48.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.48.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.48.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.49.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.49.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.49.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.49.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.49.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.49.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.49.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.49.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.49.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.49.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.5.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.5.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.5.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.5.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.5.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.5.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.5.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.5.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.5.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.5.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.6.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.6.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.6.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.6.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.6.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.6.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.6.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.6.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.6.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.6.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.7.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.7.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.7.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.7.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.7.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.7.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.7.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.7.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.7.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.7.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.8.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.8.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.8.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.8.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.8.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.8.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.8.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.8.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.8.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.8.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.9.adaln_proj.linear.bias", {96768, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.9.adaln_proj.linear.weight", {256, 1016064, 0, 0}, 2, 11u, {96768, 2688, 0, 0}, 2},  // Q3_K
+    {"blocks.9.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.9.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.9.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.9.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.9.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.9.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 11u, {0, 0, 0, 0}, 0},  // Q3_K
+    {"blocks.9.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"blocks.9.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"condition_proj.bias", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"condition_proj.weight", {5120, 5376, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"final_layer.adaln_proj.linear.bias", {10752, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"final_layer.adaln_proj.linear.weight", {2688, 10752, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"final_layer.audio_out.bias", {32, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"final_layer.audio_out.weight", {5376, 32, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"final_layer.norm.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"final_layer.video_out.bias", {96, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"final_layer.video_out.weight", {5376, 96, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"rope.inv_freq", {16, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"time_embedder.proj_in.bias", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"time_embedder.proj_in.weight", {256, 5376, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"time_embedder.proj_out.bias", {2688, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"time_embedder.proj_out.weight", {5376, 2688, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.0.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.blocks.0.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.0.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.blocks.0.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.0.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.0.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.0.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.blocks.0.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.blocks.1.attn.k_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.blocks.1.attn.out_proj.weight", {7168, 5376, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.1.attn.q_norm.weight", {128, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.blocks.1.attn.qkv_proj.weight", {5376, 21504, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.1.mlp.fc1.weight", {5376, 28672, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.1.mlp.fc2.weight", {14336, 5376, 0, 0}, 2, 1u, {0, 0, 0, 0}, 0},  // F16
+    {"token_refiner.blocks.1.norm1.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.blocks.1.norm2.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"token_refiner.final_norm.weight", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"video_patch_proj.bias", {5376, 0, 0, 0}, 1, 0u, {0, 0, 0, 0}, 0},  // F32
+    {"video_patch_proj.weight", {256, 2016, 0, 0}, 2, 1u, {5376, 96, 0, 0}, 2},  // F16
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_goldens.inc b/tests/vllm/models/minimax_h3_goldens.inc
new file mode 100644
index 000000000..d7b307e80
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_goldens.inc
@@ -0,0 +1,1502 @@
+// GENERATED by scripts/gen-minimax-h3-goldens.py — DO NOT EDIT BY HAND.
+//
+// MiniMax-H3 parity goldens produced by executing the upstream vLLM-Omni
+// modules (vllm-project/vllm-omni, vllm_omni/diffusion/models/minimax_h3/)
+// at reduced dimensions with the deterministic H3Rand stream. Regenerate with:
+//   python3 scripts/gen-minimax-h3-goldens.py --vllm-omni /home/mudler/_git/vllm-omni --out tests/vllm/models/minimax_h3_goldens.inc
+//
+// See .agents/specs/minimax-h3.md section 4 for why this is the gate: the real
+// checkpoint is ~354 GB over 4x B300 and cannot run on this project's hardware,
+// so the MATH is gated exactly here and the WEIGHTS are gated structurally.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+// --- section 1: minimax_h3_packed_sequence (fl2va, one leading keyframe) ---
+inline constexpr int64_t kH3Fl2va_text_len = 7;
+inline constexpr int64_t kH3Fl2va_latent_t = 3;
+inline constexpr int64_t kH3Fl2va_latent_h = 4;
+inline constexpr int64_t kH3Fl2va_latent_w = 6;
+inline constexpr int64_t kH3Fl2va_audio_t = 5;
+inline constexpr int64_t kH3Fl2va_audio_channel = 2;
+inline constexpr int64_t kH3Fl2va_frame_count = 9;
+inline constexpr int64_t kH3Fl2va_seq_len = 64;
+
+inline constexpr int64_t kH3Fl2vaInputIds[] = {
+    -5, -5, -5, -5, -5, -5, -5, -11, -11, -11, -11, -11,
+    -11, -15, -14, -14, -14, -14, -14, -14, -14, -14, -14, -3,
+    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+    -2, -2, -2, -2, -4, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1,
+};
+
+inline constexpr int64_t kH3Fl2vaTokenTags[] = {
+    1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+    0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1,
+};
+
+inline constexpr int64_t kH3Fl2vaImgPos[] = {
+    7, 8, 9, 10, 11, 12, 23, 24, 25, 26, 27, 28,
+    29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+};
+
+inline constexpr int64_t kH3Fl2vaAudioPos[] = {
+    13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+};
+
+inline constexpr int64_t kH3Fl2vaTextPos[] = {
+    0, 1, 2, 3, 4, 5, 6,
+};
+
+inline constexpr int64_t kH3Fl2vaUpdateMask[] = {
+    0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+};
+
+inline constexpr int64_t kH3Fl2vaCuSeqlens[] = {
+    0, 41, 64,
+};
+
+inline constexpr int64_t kH3Fl2vaDocumentId[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1,
+};
+
+inline constexpr double kH3Fl2vaImgPositionIds[] = {
+    0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
+    2.0, 0.0, 0.0, 3.0, 0.0, 0.0,
+    4.0, 0.0, 0.0, 5.0, 0.0, 0.0,
+    6.0, 0.0, 0.0, 7.0, 2.9360547051563817, -3.5959179422654266,
+    7.0, 2.9360547051563817, 9.4680273525781935, 7.0, 2.9360547051563817, 22.531972647421814,
+    7.0, 16.0, -3.5959179422654266, 7.0, 16.0, 9.4680273525781935,
+    7.0, 16.0, 22.531972647421814, 7.0, 0.0, -3.5959179422654266,
+    8.0, 0.0, -3.5959179422654266, 9.0, 0.0, -3.5959179422654266,
+    10.0, 0.0, -3.5959179422654266, 11.0, 0.0, -3.5959179422654266,
+    7.0, 0.0, 22.531972647421814, 8.0, 0.0, 22.531972647421814,
+    9.0, 0.0, 22.531972647421814, 10.0, 0.0, 22.531972647421814,
+    11.0, 0.0, 22.531972647421814, 7.0, 2.9360547051563817, -3.5959179422654266,
+    7.0, 2.9360547051563817, 9.4680273525781935, 7.0, 2.9360547051563817, 22.531972647421814,
+    7.0, 16.0, -3.5959179422654266, 7.0, 16.0, 9.4680273525781935,
+    7.0, 16.0, 22.531972647421814, 8.6666666666666661, 2.9360547051563817, -3.5959179422654266,
+    8.6666666666666661, 2.9360547051563817, 9.4680273525781935, 8.6666666666666661, 2.9360547051563817, 22.531972647421814,
+    8.6666666666666661, 16.0, -3.5959179422654266, 8.6666666666666661, 16.0, 9.4680273525781935,
+    8.6666666666666661, 16.0, 22.531972647421814, 15.333333333333334, 2.9360547051563817, -3.5959179422654266,
+    15.333333333333334, 2.9360547051563817, 9.4680273525781935, 15.333333333333334, 2.9360547051563817, 22.531972647421814,
+    15.333333333333334, 16.0, -3.5959179422654266, 15.333333333333334, 16.0, 9.4680273525781935,
+    15.333333333333334, 16.0, 22.531972647421814, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+};
+
+// --- section 2: minimax_h3_packed_sequence_ref2va_blocks ---
+inline constexpr int64_t kH3Ref2va_text_len = 5;
+inline constexpr int64_t kH3Ref2va_latent_t = 2;
+inline constexpr int64_t kH3Ref2va_latent_h = 4;
+inline constexpr int64_t kH3Ref2va_latent_w = 4;
+inline constexpr int64_t kH3Ref2va_audio_t = 3;
+inline constexpr int64_t kH3Ref2va_audio_channel = 2;
+inline constexpr int64_t kH3Ref2va_seq_len = 64;
+
+inline constexpr int64_t kH3Ref2vaInputIds[] = {
+    -5, -5, -5, -5, -5, -11, -11, -11, -11, -17, -17, -17,
+    -17, -11, -11, -11, -11, -11, -11, -11, -11, -15, -14, -14,
+    -14, -14, -14, -3, -2, -2, -2, -2, -2, -2, -4, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1,
+};
+
+inline constexpr int64_t kH3Ref2vaTokenTags[] = {
+    1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2,
+    2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2,
+    2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1,
+};
+
+inline constexpr int64_t kH3Ref2vaImgPos[] = {
+    5, 6, 7, 8, 13, 14, 15, 16, 17, 18, 19, 20,
+    27, 28, 29, 30, 31, 32, 33, 34,
+};
+
+inline constexpr int64_t kH3Ref2vaAudioPos[] = {
+    9, 10, 11, 12, 21, 22, 23, 24, 25, 26,
+};
+
+inline constexpr int64_t kH3Ref2vaUpdateMask[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 1, 1, 1, 1, 1,
+};
+
+inline constexpr int64_t kH3Ref2vaAudioUpdateMask[] = {
+    0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+};
+
+inline constexpr int64_t kH3Ref2vaCuSeqlens[] = {
+    0, 35, 64,
+};
+
+inline constexpr double kH3Ref2vaImgPositionIds[] = {
+    0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
+    2.0, 0.0, 0.0, 3.0, 0.0, 0.0,
+    4.0, 0.0, 0.0, 5.0, 0.0, 0.0,
+    5.0, 0.0, 16.0, 5.0, 16.0, 0.0,
+    5.0, 16.0, 16.0, 6.0, 0.0, 0.0,
+    7.0, 0.0, 0.0, 6.0, 0.0, 16.0,
+    7.0, 0.0, 16.0, 6.0, 0.0, 0.0,
+    6.0, 0.0, 16.0, 6.0, 16.0, 0.0,
+    6.0, 16.0, 16.0, 7.666666666666667, 0.0, 0.0,
+    7.666666666666667, 0.0, 16.0, 7.666666666666667, 16.0, 0.0,
+    7.666666666666667, 16.0, 16.0, 14.333333333333334, 0.0, 0.0,
+    15.333333333333334, 0.0, 0.0, 16.333333333333336, 0.0, 0.0,
+    14.333333333333334, 0.0, 16.0, 15.333333333333334, 0.0, 16.0,
+    16.333333333333336, 0.0, 16.0, 14.333333333333334, 0.0, 0.0,
+    14.333333333333334, 0.0, 16.0, 14.333333333333334, 16.0, 0.0,
+    14.333333333333334, 16.0, 16.0, 16.0, 0.0, 0.0,
+    16.0, 0.0, 16.0, 16.0, 16.0, 0.0,
+    16.0, 16.0, 16.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+    0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+};
+
+// --- section 3: packed_tokens patchify / unpatchify / audio pack ---
+inline constexpr int64_t kH3PatchifyC = 5;
+inline constexpr int64_t kH3PatchifyT = 2;
+inline constexpr int64_t kH3PatchifyH = 4;
+inline constexpr int64_t kH3PatchifyW = 6;
+inline constexpr int64_t kH3PatchifyRows = 12;
+inline constexpr int64_t kH3PatchifyRowWidth = 20;
+
+inline constexpr float kH3PatchifyRowsGolden[] = {
+    -0.839917839f, -0.489967585f, 0.742104113f, 0.745100558f, -0.0817067102f, 0.71555239f,
+    -0.221731037f, 0.311325699f, 0.786754727f, 0.98405993f, -0.575585902f, 0.586485863f,
+    0.747402906f, 0.104257621f, 0.336960316f, -0.11067529f, 0.202912316f, 0.671667874f,
+    -0.853774905f, -0.190517679f, 0.858729601f, 0.334511846f, -0.0173227414f, 0.734548748f,
+    0.323877931f, -0.0401596501f, -0.461054534f, 0.0690004528f, 0.0277255122f, 0.510376751f,
+    -0.275820017f, 0.135007024f, -0.0774729475f, 0.424949199f, 0.498941272f, 0.321867228f,
+    -0.914279342f, 0.816078305f, -0.337762177f, 0.0746692345f, -0.87728703f, 0.348186553f,
+    0.187559068f, 0.409695417f, 0.68926245f, 0.152191401f, 0.149237052f, -0.702905715f,
+    -0.307298362f, -0.763987958f, 0.921571374f, 0.296821862f, -0.179218903f, 0.866584003f,
+    -0.122583419f, -0.561160147f, 0.240982547f, 0.885412514f, 0.690483987f, -0.307872802f,
+    0.912102222f, 0.352783829f, -0.822215676f, 0.244669616f, 0.316481769f, -0.354604602f,
+    0.286513418f, -0.498852998f, 0.446563333f, 0.957051814f, 0.420559198f, 0.497806042f,
+    0.58205384f, 0.0659745038f, 0.273808956f, 0.982380867f, -0.646479905f, -0.0653409585f,
+    0.879083097f, -0.91289562f, 0.725754023f, -0.713435352f, -0.82963419f, -0.83455348f,
+    -0.0407303572f, 0.253281742f, -0.459853142f, 0.784634292f, -0.780694008f, 0.0769072846f,
+    0.159877151f, 0.0762477964f, -0.904113948f, 0.0654344857f, 0.883877873f, 0.0326075628f,
+    -0.74944967f, -0.213846281f, -0.433849245f, -0.868052363f, -0.226174518f, 0.149744242f,
+    -0.995066524f, 0.292156398f, -0.815634191f, 0.369121104f, 0.400914878f, -0.347624481f,
+    -0.294430822f, 0.603223026f, 0.0233175289f, -0.40278244f, -0.210205585f, -0.473807991f,
+    -0.367566317f, 0.685179174f, 0.566254616f, 0.654445112f, -0.276737094f, 0.702582061f,
+    -0.220050231f, -0.398701459f, -0.025171062f, -0.0228734612f, 0.000122784069f, 0.0309518222f,
+    0.220800489f, -0.19987987f, -0.278871357f, 0.475921124f, 0.979618073f, -0.733187973f,
+    -0.329306185f, 0.0211987812f, -0.44826901f, 0.457541198f, -0.913266897f, 0.22574991f,
+    -0.196778432f, -0.901181996f, 0.444904774f, -0.296465307f, -0.60695374f, -0.128983885f,
+    0.120764151f, -0.278448343f, 0.828368008f, 0.848218501f, 0.171552315f, -0.00375299924f,
+    0.058165662f, -0.436255664f, -0.64706862f, -0.461985767f, 0.363254458f, -0.633509994f,
+    0.843931377f, -0.110477977f, -0.689509451f, -0.720721006f, 0.580843091f, -0.547906995f,
+    -0.919538081f, -0.166112721f, 0.872462869f, 0.11381866f, -0.69894278f, -0.210378006f,
+    -0.0965927541f, -0.156420708f, -0.814463913f, 0.17284064f, 0.762460947f, 0.960039079f,
+    -0.183188245f, 0.0420542471f, 0.0727361366f, -0.869633973f, 0.649338186f, -0.647336423f,
+    0.04421198f, 0.708330393f, -0.521672308f, 0.546271086f, 0.231929451f, 0.376287609f,
+    -0.850101054f, 0.986531258f, 0.828350127f, 0.990656018f, -0.573477685f, 0.247171462f,
+    0.564660251f, 0.824146152f, 0.517412007f, 0.816393435f, -0.523563147f, 0.41394487f,
+    -0.942305207f, -0.125932679f, 0.957295597f, 0.306902558f, -0.71940136f, -0.178135172f,
+    -0.01300517f, -0.903398156f, 0.342460066f, -0.804866612f, 0.540836692f, -0.211158425f,
+    0.509571314f, -0.273858458f, -0.955568671f, -0.217508242f, -0.2690745f, -0.996983886f,
+    -0.888864875f, 0.24665828f, 0.267315209f, 0.0196375921f, 0.0107150106f, 0.790605843f,
+    -0.390652537f, 0.618961632f, -0.011906527f, -0.866301239f, -0.0206541158f, -0.573352337f,
+    0.191599488f, -0.243127048f, -0.75800842f, -0.122320406f, 0.391907066f, 0.0709807873f,
+    0.134755373f, -0.850077152f, -0.844890237f, -0.135095388f, 0.15690206f, 0.325141072f,
+};
+
+inline constexpr int64_t kH3AudioPackChannels = 2;
+inline constexpr int64_t kH3AudioPackDim = 6;
+inline constexpr int64_t kH3AudioPackT = 4;
+
+inline constexpr float kH3AudioPackRowsGolden[] = {
+    -0.937777996f, 0.117997162f, -0.000760909519f, -0.313123524f, 0.0988090858f, -0.325097948f,
+    -0.139718935f, 0.399080575f, -0.434750855f, 0.881571054f, -0.380355984f, -0.802718997f,
+    0.255313188f, -0.503308296f, 0.581382275f, 0.332404822f, -0.239544004f, 0.523868084f,
+    0.421442717f, 0.104417145f, 0.282395959f, -0.338716507f, -0.626064599f, 0.103453673f,
+    0.674916804f, 0.428806812f, -0.923021078f, -0.284120828f, 0.65365833f, 0.411805838f,
+    -0.639654458f, 0.211954847f, 0.352740437f, 0.259889752f, -0.978834867f, -0.229998708f,
+    0.269998044f, 0.400429785f, -0.902480483f, -0.646393538f, -0.132407069f, -0.00302331266f,
+    -0.158384487f, -0.066260241f, -0.700976074f, 0.00362426159f, -0.30368346f, 0.911531568f,
+};
+
+// --- section 4: euler-ancestral eta0 scheduler ---
+inline constexpr int64_t kH3SchedN = 24;
+inline constexpr int64_t kH3SchedSteps = 3;
+
+inline constexpr float kH3SchedTimesteps[] = {
+    0.0199999996f, 0.5f, 0.970000029f,
+};
+
+inline constexpr float kH3SchedX0Golden[] = {
+    0.125843167f, -0.592506409f, -1.47550702f, -0.0571773052f, -0.85201478f, 0.805873454f,
+    0.524332702f, -0.189024419f, 0.612122178f, 1.26505566f, 1.04565239f, 1.7693001f,
+    0.206652164f, 1.19190037f, -0.253141463f, 0.676851869f, 0.276425779f, -0.966520429f,
+    -0.169769838f, 0.327976197f, 1.54269147f, 0.371155769f, -0.423705876f, -1.20575988f,
+    0.512419879f, -0.237793967f, -1.08453417f, 0.278256416f, -0.902089953f, 0.422500342f,
+    0.310146183f, 0.112664461f, 0.600563347f, 0.948113024f, 0.85057044f, 1.39190614f,
+    -0.264596879f, 0.837253451f, -0.36586076f, 0.741331756f, 0.569762945f, -0.772453308f,
+    -0.15564467f, 0.00060325861f, 1.25487959f, 0.429609954f, -0.0660855472f, -0.880707502f,
+    0.890942872f, 0.109528668f, -0.701706529f, 0.60670197f, -0.951121867f, 0.0471141264f,
+    0.100421876f, 0.40806818f, 0.589245319f, 0.637773335f, 0.659552753f, 1.02237451f,
+    -0.726028264f, 0.489995092f, -0.476231784f, 0.804468393f, 0.856988907f, -0.58242929f,
+    -0.141813785f, -0.319949418f, 0.973063886f, 0.486846358f, 0.28408435f, -0.562426984f,
+};
+
+inline constexpr float kH3SchedStepGolden[] = {
+    0.52047354f, -0.230404109f, -1.07638884f, 0.285244614f, -0.903133154f, 0.414513379f,
+    0.30568397f, 0.118949652f, 0.600322545f, 0.941510081f, 0.846506238f, 1.38404369f,
+    -0.274414569f, 0.829865038f, -0.368209094f, 0.742675126f, 0.57587409f, -0.768410265f,
+    -0.155350402f, -0.00621700287f, 1.24888361f, 0.430827737f, -0.0586351454f, -0.87393558f,
+    0.713761926f, -0.0530478954f, -0.880902469f, 0.452961475f, -0.9281708f, 0.222826838f,
+    0.198590711f, 0.269794106f, 0.594543099f, 0.783038735f, 0.748965263f, 1.19534683f,
+    -0.510039091f, 0.652541578f, -0.424568743f, 0.774915099f, 0.722542703f, -0.671376705f,
+    -0.148287818f, -0.169903472f, 1.10497761f, 0.460054845f, 0.120175019f, -0.71140933f,
+    0.903023362f, 0.120613426f, -0.689488649f, 0.617184281f, -0.952686727f, 0.0351337269f,
+    0.0937285572f, 0.417495966f, 0.588884115f, 0.627868891f, 0.65345645f, 1.01058102f,
+    -0.740754783f, 0.478912383f, -0.479754269f, 0.806483388f, 0.866155684f, -0.576364696f,
+    -0.141372383f, -0.330179811f, 0.964069784f, 0.488673031f, 0.295259953f, -0.552269101f,
+};
+
+// --- section 5: MiniMaxH3DiTModel forward (reduced dims, fp32) ---
+inline constexpr int64_t kH3Dit_num_layers = 2;
+inline constexpr int64_t kH3Dit_token_refiner_num_layers = 1;
+inline constexpr int64_t kH3Dit_hidden_size = 64;
+inline constexpr int64_t kH3Dit_num_attention_heads = 4;
+inline constexpr int64_t kH3Dit_attention_head_dim = 16;
+inline constexpr int64_t kH3Dit_ffn_hidden_size = 128;
+inline constexpr int64_t kH3Dit_latents_dim = 8;
+inline constexpr int64_t kH3Dit_audio_latents_dim = 6;
+inline constexpr int64_t kH3Dit_text_dim = 24;
+inline constexpr int64_t kH3Dit_timestep_input_dim = 16;
+inline constexpr int64_t kH3Dit_time_embed_hidden_size = 64;
+inline constexpr int64_t kH3Dit_time_embed_dim = 32;
+inline constexpr int64_t kH3Dit_rope_inv_freq_len = 2;
+inline constexpr int64_t kH3Dit_video_row_width = 32;
+inline constexpr int64_t kH3Dit_unique_timesteps = 3;
+
+inline constexpr float kH3DitUniqueTimesteps[] = {
+    0.349999994f, 0.400000006f, 0.999000013f,
+};
+
+inline constexpr int64_t kH3DitInverseIndices[] = {
+    1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
+    2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1,
+};
+
+inline constexpr float kH3DitVideoLogitsGolden[] = {
+    0.0f, 0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    0.0f, -0.0f, 0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, 0.0f, -0.0f, 0.0f,
+    -0.0f, -0.0f, -0.0f, -0.0f, 0.0f, 0.0f,
+    -0.0f, -0.0f, -0.0f, 0.0f, -0.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, -0.0f, 0.0f, 0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, -0.0f, -0.0f,
+    0.0f, -0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    0.0f, -0.0f, -0.0f, 0.0f, -0.0f, 0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, -0.0f, 0.0f, 0.0f,
+    0.0f, -0.0f, 0.0f, -0.0f, 0.0f, 0.0f,
+    0.0f, -0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    0.0f, -0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    -0.0f, 0.0f, 0.0f, -0.0f, -0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    0.0f, 0.0f, -0.0f, 0.0f, -0.0f, 0.0f,
+    0.0f, 0.0f, -0.0f, 0.0f, 0.0f, 0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.137917712f, -0.234130248f, -0.497244954f, 0.29884395f, -0.100384533f, 0.0507150181f,
+    -0.078446351f, 0.147597894f, 0.203603476f, 0.351661026f, 0.0532780141f, 0.075976193f,
+    -0.0310322419f, -0.105577871f, -0.0220998768f, 0.216189966f, 0.287534922f, -0.325358599f,
+    -0.0975827202f, -0.103820816f, 0.105645433f, -0.105067715f, -0.302565932f, -0.400916755f,
+    -0.376587361f, 0.111636892f, 0.00369578134f, 0.157276526f, 0.114818856f, 0.0731319711f,
+    -0.0637023225f, 0.279834539f, 0.0479765087f, 0.191572428f, 0.527270377f, -0.207765862f,
+    0.00657897349f, -0.103906021f, 0.199235633f, -0.141059011f, -0.0266793836f, 0.146355927f,
+    0.0756472424f, -0.0992141664f, 0.283411592f, 0.127458766f, -0.0556056499f, -0.180261374f,
+    -0.140924767f, -0.208811402f, -0.0562489629f, -0.0858644843f, -0.153377742f, -0.385590762f,
+    0.48407656f, -0.152284697f, 0.138309106f, -0.120958596f, -0.296137393f, 0.0826946348f,
+    0.056363672f, 0.0252563599f, 0.193158522f, -0.266139239f, -0.148333803f, -0.174436405f,
+    0.351718009f, 0.191028222f, -0.294205546f, 0.122301809f, -0.299951553f, -0.23838824f,
+    -0.0590861328f, 0.102336042f, -0.0998185202f, 0.0399515852f, 0.308630973f, -0.0166417863f,
+    0.261973917f, 0.14112021f, -0.0588652492f, -0.176329046f, 0.0687235817f, -0.0207418948f,
+    0.0565133579f, 0.161415234f, -0.00876711216f, 0.0647368431f, 0.422589153f, -0.278148293f,
+    -0.295228153f, -0.128020689f, -0.333485484f, 0.216228798f, 0.238450527f, -0.224959195f,
+    -0.12941429f, -0.262824297f, -0.313085675f, 0.242235914f, -0.120008655f, -0.0231411569f,
+    0.0917436257f, 0.207432255f, -0.357536107f, -0.152313009f, -0.177627593f, 0.166597754f,
+    -0.0725270212f, -0.369791865f, -0.0778539255f, 0.0235888157f, 0.21395579f, 0.0215139948f,
+    0.0755939037f, 0.00867325068f, -0.107797839f, 0.270425767f, -0.187939718f, 0.0293346159f,
+    0.0854485929f, 0.17118296f, 0.212172911f, -0.114338018f, -0.0484237522f, 0.0235489309f,
+    0.0120537542f, -0.0365255326f, -0.546821237f, -0.254705042f, -0.0373510979f, 0.065348424f,
+    0.140357375f, 0.0182946566f, 0.129532263f, 0.496270031f, 0.31430614f, 0.0640072003f,
+    0.152023077f, 0.230139047f, 0.156480104f, 0.3280586f, -0.440055847f, -0.333236158f,
+    0.208524689f, 0.16249086f, 0.221484885f, -0.381121308f, 0.283482373f, 0.232321352f,
+    0.0738618299f, 0.0942924917f, -0.146849483f, 0.0548943542f, 0.353564054f, 0.22044836f,
+    -0.223027185f, 0.425955683f, 0.134433374f, 0.0888856351f, -0.102705888f, 0.0145264491f,
+    -0.253498107f, 0.166404754f, -0.169322938f, 0.246535718f, -0.234368607f, -0.0946957543f,
+    -0.0108180279f, 0.140491784f, 0.0208436865f, -0.0561063327f, 0.278117955f, -0.115264013f,
+    0.377871603f, -0.000531528145f, 0.0145136015f, -0.318840981f, -0.0468817204f, -0.0976120159f,
+    -0.180551514f, -0.151713789f, -0.219367087f, 0.122870147f, 0.330833137f, 0.0394966193f,
+    0.0932471752f, -0.127318367f, 0.132722363f, 0.419292241f, 0.157633811f, -0.00701334327f,
+    0.140902251f, 0.301653624f, 0.578049541f, 0.395984977f, 0.171463162f, 0.288078219f,
+    -0.146114916f, -0.0169803798f, -0.235721797f, 0.469968915f, -0.361989498f, -0.0829809904f,
+    0.0398389772f, 0.374364465f, -0.220800653f, -0.104956627f, -0.285232693f, 0.177889168f,
+    0.126446322f, -0.35764733f, -0.314421058f, 0.0294257496f, 0.0481283478f, 0.0262174718f,
+    -0.0106340861f, -0.37869367f, -0.212541685f, -0.013813315f, -0.369710952f, 0.28020367f,
+    0.0886020288f, -0.297491461f, -0.161369637f, -0.315443218f, -0.18037951f, -0.353339881f,
+    0.0784807503f, -0.236862034f, -0.198175579f, -0.0188808031f, 0.24071449f, -0.256883979f,
+    -0.076119259f, 0.159684032f, 0.413095236f, -0.17781879f, 0.39788565f, -0.11207547f,
+    -0.0834925249f, 0.216066629f, -0.22851415f, 0.26929915f, -0.251957148f, 0.648098588f,
+    0.00516217668f, 0.668136597f, 0.149421707f, 0.0190474093f, 0.0740992203f, -0.0870066434f,
+    -0.397019893f, 0.0425445661f, 0.149455354f, -0.0533867255f, -0.125679001f, -0.215786383f,
+    -0.106101371f, 0.223812267f, -0.0292598773f, -0.185423583f, 0.172922149f, 0.536044836f,
+    -0.142735973f, 0.161118746f, 0.156909481f, 0.113550112f, -0.324024737f, -0.415487915f,
+    0.134620041f, -0.000645949505f, 0.0785956904f, 0.0257078484f, -0.0645641685f, 0.0128037669f,
+    0.287564367f, -0.0813543275f, 0.247901902f, 0.0781279355f, 0.0895855799f, -0.402484477f,
+    0.391308576f, -0.0120616285f, 0.282355934f, -0.0981066823f, 0.284028172f, -0.045425754f,
+    -0.134251699f, -0.0207120609f, 0.076062791f, -0.265427053f, 0.372654527f, -0.0951322988f,
+    -0.118806005f, 0.214519918f, 0.320846796f, -0.218251452f, -0.0181529596f, 0.0368573964f,
+    -0.145337835f, 0.235944882f, -0.455845416f, -0.190570295f, 0.168150112f, -0.179460332f,
+    -0.0995030552f, 0.0806585029f, -0.350192636f, 0.0856266916f, -0.016134426f, -0.138066009f,
+    -0.297586113f, 0.0704971477f, -0.090229772f, 0.0374311395f, -0.42684409f, -0.221063599f,
+    0.0555477217f, 0.156982005f, 0.041837737f, 0.106605425f, -0.0193047859f, -0.123422459f,
+    0.0106622651f, 0.0694115683f, 0.0624173507f, 0.335160464f, -0.207287133f, -0.0558966547f,
+    0.122629993f, -0.0661645383f, -0.0313782021f, 0.496287107f, -0.305637836f, 0.142952561f,
+    -0.014927092f, 0.150773704f, -0.180765301f, -0.286339551f, 0.0905470997f, -0.357502252f,
+    0.296494514f, 0.0215666294f, -0.357654184f, -0.303475589f, 0.0719839111f, -0.0432310514f,
+    0.189912647f, 0.027751131f, 0.105708107f, 0.203639954f, 0.117069095f, -0.167192176f,
+    -0.540551424f, 0.203401297f, -0.0320246443f, 0.17899105f, -0.182860866f, -0.198112339f,
+    0.16647622f, -0.168178543f, 0.0875095353f, 0.436830282f, -0.39922002f, -0.134048492f,
+    0.160097018f, 0.107004888f, 0.0435033292f, -0.221214116f, -0.244498774f, 0.0750382841f,
+    0.126767933f, 0.138686508f, -0.195116445f, 0.0348396376f, 0.544579983f, -0.191479743f,
+    0.263289958f, -0.178975984f, -0.121854007f, -0.34646666f, -0.172957212f, 0.0112465201f,
+    0.199847922f, 0.178019583f, 0.193739146f, 0.321072102f, -0.269770384f, 0.152001858f,
+    -0.127057835f, -0.234727815f, -0.134694874f, 0.169748917f, -0.270585746f, -0.132765099f,
+    0.0719814152f, 0.166348204f, 0.139155731f, 0.00620697159f, -0.0011297632f, -0.185429335f,
+    -0.191852897f, -0.20383139f, -0.0145756742f, -0.00925456546f, -0.0709034503f, -0.238932297f,
+    0.0679515004f, -0.203662634f, -0.403235823f, -0.156452715f, -0.215715379f, 0.527084768f,
+    0.158490658f, -0.152007639f, 0.0529846698f, 0.141709268f, -0.135902613f, -0.00264955033f,
+    0.423841774f, 0.0568588674f, -0.297509193f, 0.0149343517f, 0.0961878747f, -0.112416796f,
+    0.254828125f, 0.123424351f, -0.259488553f, -0.28365624f, 0.125311911f, -0.018772712f,
+    0.0558334179f, -0.0206869431f, -0.107930288f, 0.130372614f, -0.324341595f, 0.337913543f,
+    -0.449433893f, 0.16282095f, 0.167192072f, 0.168130696f, -0.0343903527f, -0.432013988f,
+    -0.0505543612f, -0.161019742f, -0.140720963f, -0.31263411f, -0.0244776048f, 0.142976463f,
+    0.104897261f, -0.355151057f, -0.0369586274f, 0.217444241f, 0.0536726117f, 0.265686721f,
+    -0.0660648793f, -0.280620158f, 0.186856136f, -0.0581312366f, -0.213962093f, 0.291272998f,
+    -0.169984251f, 0.396532178f, 0.00917633995f, -0.221565872f, 0.020833971f, 0.1065984f,
+    -0.0239739567f, -0.207409531f, 0.317279369f, 0.0606120564f, -0.448763877f, 0.0370559096f,
+    0.0199844372f, 0.0661781281f, -0.0137134269f, -0.158125564f, 0.286557555f, 0.424430192f,
+    0.18344003f, -0.286832422f, -0.0644189417f, 0.140164658f, -0.344621629f, -0.0110930204f,
+    -0.304135472f, -0.117174447f, -0.238797769f, 0.231357276f, -0.0433897302f, 0.328396857f,
+    0.435187578f, -0.0956823528f, 0.442666262f, 0.0439702645f, -0.0840738192f, 0.138022408f,
+    -0.137559161f, -0.06764552f, -0.213870391f, 0.477426589f, 0.0556914024f, 0.256425768f,
+    0.209367871f, -0.244345546f, -0.1853811f, 0.0638268888f, -0.365151823f, -0.00216334499f,
+    -0.239818066f, -0.346759498f, 0.14677608f, 0.1445916f, -0.193816081f, -0.0294958688f,
+    -0.0284682233f, 0.0875872001f, 0.0475127622f, -0.293622136f, 0.154037848f, -0.0160625763f,
+    -0.339212537f, 0.114544511f, -0.0940286964f, 0.0892673433f, 0.129278198f, -0.22534734f,
+    0.10484343f, -0.207567245f, 0.122550696f, 0.361612499f, -0.0783864632f, 0.294975609f,
+    0.161807299f, -0.0189710446f, 0.195459023f, 0.216034025f, -0.286670893f, 0.0908539519f,
+    -0.27612862f, -0.151758224f, -0.132524252f, -0.474239826f, 0.164518192f, 0.272066385f,
+    0.246814832f, -0.252344042f, 0.326329052f, 0.234925002f, 0.133906975f, -0.0657187849f,
+    0.354167104f, -0.0246941261f, -0.47868818f, -0.285058349f, -0.630175054f, 0.187867284f,
+    -0.158393353f, 0.188492864f, -0.117237791f, -0.377449632f, -0.00226928387f, 0.382831424f,
+    0.00377185247f, 0.105743341f, 0.153224185f, -0.291160077f, -0.191782877f, -0.0774367824f,
+    -0.216274619f, 0.0786017776f, -0.407754719f, -0.0308668781f, 0.242262349f, 0.328808755f,
+};
+
+inline constexpr float kH3DitAudioLogitsGolden[] = {
+    -0.0073117041f, -0.152457446f, -0.00646608323f, 0.087039724f, -0.251817852f, 0.192099258f,
+    0.249603331f, -0.158621505f, -0.0147411823f, 0.151828289f, -0.214714468f, 0.12377122f,
+    0.169842899f, -0.254690289f, -0.0284043476f, -0.243239045f, 0.288735032f, -0.284347266f,
+    0.0284102093f, -0.192502484f, -0.138581365f, 0.160328209f, -0.578464985f, 0.209515899f,
+    -0.152072638f, 0.239422962f, 0.00502328575f, -0.093345359f, -0.29082647f, 0.211018592f,
+    -0.28469348f, 0.161104038f, 0.239082813f, -0.304003119f, -0.0169349294f, -0.195861161f,
+    0.140054509f, -0.353837073f, -0.0519648418f, 0.25434351f, -0.332177758f, 0.221894175f,
+    -0.231000781f, 0.155330166f, 0.348661274f, -0.0567575432f, -0.29300952f, 0.00987201184f,
+    -0.090026103f, -0.025943771f, 0.194971442f, -0.195087686f, 0.115229912f, -0.164066896f,
+    -0.201563925f, 0.0580958687f, 0.0865281224f, 0.0429093428f, -0.397339374f, 0.196255535f,
+};
+
+inline constexpr float kH3DitVideoLogitsBf16Golden[] = {
+    0.0f, 0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    0.0f, -0.0f, 0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, 0.0f, -0.0f, 0.0f,
+    -0.0f, -0.0f, -0.0f, -0.0f, 0.0f, 0.0f,
+    -0.0f, -0.0f, -0.0f, 0.0f, -0.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, -0.0f, 0.0f, 0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, -0.0f, -0.0f,
+    0.0f, -0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    0.0f, -0.0f, -0.0f, 0.0f, -0.0f, 0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, -0.0f, -0.0f, -0.0f, 0.0f, 0.0f,
+    0.0f, -0.0f, 0.0f, -0.0f, 0.0f, 0.0f,
+    0.0f, -0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    0.0f, -0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    -0.0f, 0.0f, 0.0f, -0.0f, -0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    -0.0f, -0.0f, 0.0f, -0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, -0.0f, -0.0f,
+    0.0f, 0.0f, -0.0f, 0.0f, -0.0f, 0.0f,
+    0.0f, 0.0f, -0.0f, 0.0f, 0.0f, 0.0f,
+    -0.0f, 0.0f, -0.0f, 0.0f, 0.0f, -0.0f,
+    -0.0f, 0.0f, -0.0f, -0.0f, 0.0f, -0.0f,
+    -0.138256505f, -0.23458828f, -0.497814745f, 0.298925281f, -0.101678811f, 0.0503181331f,
+    -0.0795369074f, 0.146260992f, 0.204146519f, 0.351321757f, 0.0537414923f, 0.076039806f,
+    -0.0317929201f, -0.105222732f, -0.0218971018f, 0.216654286f, 0.288043231f, -0.325642616f,
+    -0.0981825739f, -0.10250257f, 0.106488757f, -0.105425976f, -0.303396881f, -0.400899231f,
+    -0.37594825f, 0.112199306f, 0.00353481062f, 0.157970667f, 0.113961101f, 0.0721884742f,
+    -0.0628355667f, 0.280311584f, 0.047483813f, 0.193391412f, 0.525885105f, -0.207301542f,
+    0.00665141363f, -0.103295282f, 0.19994995f, -0.140824363f, -0.0264394879f, 0.145376742f,
+    0.0742794648f, -0.0982695371f, 0.28280431f, 0.128502771f, -0.0558281317f, -0.179734081f,
+    -0.141535327f, -0.209070012f, -0.0558521599f, -0.0854109451f, -0.153271958f, -0.384816498f,
+    0.484385461f, -0.152729645f, 0.13867566f, -0.122717917f, -0.296660244f, 0.0824152157f,
+    0.0559268668f, 0.0250642039f, 0.192562535f, -0.265753299f, -0.148382202f, -0.173505098f,
+    0.351158291f, 0.191131666f, -0.294305831f, 0.122034557f, -0.300326228f, -0.240008309f,
+    -0.05820705f, 0.102606758f, -0.0994291157f, 0.0393878669f, 0.308271825f, -0.0164675824f,
+    0.263769209f, 0.140803352f, -0.0587589368f, -0.177727878f, 0.067947261f, -0.0201640278f,
+    0.0557362549f, 0.161587432f, -0.0100511881f, 0.0637432039f, 0.422920048f, -0.278004885f,
+    -0.296739697f, -0.128181383f, -0.334200919f, 0.215762258f, 0.238408789f, -0.224566132f,
+    -0.128957734f, -0.26314801f, -0.311580926f, 0.242765889f, -0.120413132f, -0.0238109641f,
+    0.0907959193f, 0.207562715f, -0.357996732f, -0.15266414f, -0.177305609f, 0.166652679f,
+    -0.0729551166f, -0.370851487f, -0.0784622654f, 0.0246207584f, 0.213418022f, 0.0217307471f,
+    0.0760729611f, 0.0091864001f, -0.108814746f, 0.272141606f, -0.187280834f, 0.0313530117f,
+    0.085811317f, 0.171362028f, 0.211962283f, -0.115650445f, -0.0483743809f, 0.0237317905f,
+    0.012934179f, -0.0370607637f, -0.547911167f, -0.255892783f, -0.0375591964f, 0.0659708604f,
+    0.140810743f, 0.0183974728f, 0.129389271f, 0.497465432f, 0.314108789f, 0.0644200295f,
+    0.152678519f, 0.230407119f, 0.157159224f, 0.327792436f, -0.439592183f, -0.333977133f,
+    0.208621114f, 0.164005518f, 0.221885204f, -0.381507367f, 0.283603162f, 0.233215004f,
+    0.0728968531f, 0.0957310945f, -0.147507474f, 0.0540421493f, 0.353179902f, 0.219975784f,
+    -0.22302261f, 0.427176178f, 0.135108814f, 0.0884380117f, -0.102913536f, 0.0141673647f,
+    -0.253270805f, 0.165757433f, -0.168699503f, 0.246050477f, -0.232998863f, -0.0944449008f,
+    -0.00840883423f, 0.140234202f, 0.0206029769f, -0.0568193533f, 0.278605044f, -0.114787892f,
+    0.377714753f, -0.000857527368f, 0.0138504673f, -0.317780346f, -0.0473886728f, -0.097383365f,
+    -0.180221111f, -0.152176157f, -0.219989955f, 0.121438086f, 0.33034575f, 0.0389372744f,
+    0.0927967206f, -0.126984447f, 0.132393196f, 0.418536365f, 0.156007558f, -0.00745873339f,
+    0.139355734f, 0.301031113f, 0.57658875f, 0.39460066f, 0.171647713f, 0.289073259f,
+    -0.145725772f, -0.0165789407f, -0.235321969f, 0.468912244f, -0.362003684f, -0.0836392939f,
+    0.0401040763f, 0.373518646f, -0.219679624f, -0.104968369f, -0.284116447f, 0.177532762f,
+    0.127653062f, -0.357180148f, -0.314529032f, 0.0300407428f, 0.0478849076f, 0.0254882686f,
+    -0.0116570061f, -0.377820909f, -0.211166874f, -0.0133767705f, -0.369151354f, 0.280391544f,
+    0.0872094855f, -0.297933668f, -0.160658613f, -0.315232188f, -0.18042393f, -0.352055132f,
+    0.0779226273f, -0.237317264f, -0.197782695f, -0.0185989197f, 0.240700871f, -0.256582797f,
+    -0.0757606775f, 0.158118829f, 0.412981331f, -0.179121867f, 0.397197068f, -0.111988991f,
+    -0.0830689892f, 0.216317385f, -0.229162559f, 0.269514591f, -0.250926882f, 0.646987498f,
+    0.0064592436f, 0.668455064f, 0.149208784f, 0.0188452452f, 0.0743404701f, -0.0880649015f,
+    -0.397195101f, 0.0426736176f, 0.149639159f, -0.0546147488f, -0.123657957f, -0.215998024f,
+    -0.105295822f, 0.223184645f, -0.0292050596f, -0.185272485f, 0.173290536f, 0.535653412f,
+    -0.143397093f, 0.162160829f, 0.157478228f, 0.113972038f, -0.322955132f, -0.415560633f,
+    0.134761348f, -6.37853518e-05f, 0.0779706612f, 0.0255927965f, -0.0645807013f, 0.011173835f,
+    0.288385838f, -0.0820584372f, 0.246862516f, 0.0773829669f, 0.0913811997f, -0.403121293f,
+    0.39127022f, -0.012430992f, 0.282270074f, -0.0980172455f, 0.283886731f, -0.0463425554f,
+    -0.134493381f, -0.0199905001f, 0.0742847845f, -0.265542895f, 0.373364031f, -0.0936619714f,
+    -0.118229687f, 0.213667423f, 0.321010351f, -0.218806684f, -0.0189575851f, 0.037231572f,
+    -0.144592449f, 0.235920921f, -0.455843568f, -0.188878745f, 0.16873692f, -0.180358082f,
+    -0.0981601402f, 0.0819019601f, -0.349367887f, 0.0857523531f, -0.0151286563f, -0.137887254f,
+    -0.297520816f, 0.0710978359f, -0.0881417096f, 0.038799759f, -0.424799442f, -0.221375167f,
+    0.0550409108f, 0.15732944f, 0.040354263f, 0.107553355f, -0.019511845f, -0.1243755f,
+    0.0115350252f, 0.0694755688f, 0.0620089099f, 0.333028644f, -0.206939176f, -0.0564776435f,
+    0.123063035f, -0.0659029186f, -0.0300942995f, 0.496743381f, -0.304916292f, 0.141634107f,
+    -0.0163462237f, 0.150568202f, -0.181256697f, -0.284875602f, 0.089888826f, -0.357685179f,
+    0.296912789f, 0.0223177448f, -0.356307745f, -0.304448098f, 0.0719200596f, -0.0425055064f,
+    0.188578114f, 0.0272125322f, 0.104524419f, 0.204432964f, 0.117003389f, -0.16719678f,
+    -0.54112792f, 0.204461172f, -0.0325572044f, 0.179408193f, -0.183952034f, -0.198378921f,
+    0.165047869f, -0.166519985f, 0.0885817483f, 0.437198818f, -0.397475451f, -0.13459295f,
+    0.160903946f, 0.105980568f, 0.0424856581f, -0.220392361f, -0.245490745f, 0.0749035105f,
+    0.128274858f, 0.13879478f, -0.194476366f, 0.0339280181f, 0.546050072f, -0.192428932f,
+    0.262228847f, -0.178100005f, -0.1216176f, -0.347306728f, -0.17306526f, 0.0113133872f,
+    0.19984147f, 0.177920863f, 0.194787204f, 0.319820255f, -0.269843817f, 0.151129693f,
+    -0.126051143f, -0.234204739f, -0.132911503f, 0.168034598f, -0.270011187f, -0.13152951f,
+    0.0718885064f, 0.166369468f, 0.137555137f, 0.00698418543f, -0.00300935935f, -0.186055779f,
+    -0.191958994f, -0.203566119f, -0.0138155138f, -0.0106042754f, -0.0707103908f, -0.238243371f,
+    0.0685857311f, -0.203559771f, -0.401898801f, -0.155780956f, -0.214639097f, 0.525938153f,
+    0.159475669f, -0.15046674f, 0.0525391623f, 0.141121253f, -0.136403173f, -0.00375855342f,
+    0.423675328f, 0.0567622781f, -0.296065748f, 0.0157194808f, 0.09635517f, -0.113719307f,
+    0.255799562f, 0.12210606f, -0.258191049f, -0.283237845f, 0.125259534f, -0.020366827f,
+    0.0572975613f, -0.0182010196f, -0.10824798f, 0.130302072f, -0.324296504f, 0.338354766f,
+    -0.449202299f, 0.162163392f, 0.167170137f, 0.167784095f, -0.0344098881f, -0.432699502f,
+    -0.0491542779f, -0.159985468f, -0.140560642f, -0.313889682f, -0.0238378309f, 0.143747941f,
+    0.105318904f, -0.354875088f, -0.038851805f, 0.216659665f, 0.052159138f, 0.265223593f,
+    -0.0652889535f, -0.279901862f, 0.187249184f, -0.057358142f, -0.213794693f, 0.291994363f,
+    -0.169291437f, 0.397021681f, 0.00761741772f, -0.221580252f, 0.0199885592f, 0.106999099f,
+    -0.0235966034f, -0.208608836f, 0.316254318f, 0.0610527433f, -0.447893173f, 0.0362145118f,
+    0.0199406426f, 0.0662820861f, -0.0152349444f, -0.159390971f, 0.28742823f, 0.425796449f,
+    0.183060959f, -0.286734372f, -0.0652540028f, 0.140361726f, -0.344616801f, -0.0113377329f,
+    -0.303549051f, -0.117127672f, -0.237830609f, 0.231249258f, -0.0444727689f, 0.32893762f,
+    0.435821086f, -0.095778659f, 0.443354189f, 0.0448168516f, -0.0852835178f, 0.137662649f,
+    -0.138785213f, -0.0669274107f, -0.215316564f, 0.478962719f, 0.0554756746f, 0.256507576f,
+    0.209439307f, -0.245236844f, -0.184859768f, 0.0639577359f, -0.366193324f, -0.00206129067f,
+    -0.241729915f, -0.34659341f, 0.146605521f, 0.144636095f, -0.193629205f, -0.029645998f,
+    -0.0294187088f, 0.0897706822f, 0.0479245633f, -0.294821531f, 0.153313875f, -0.016775528f,
+    -0.338856161f, 0.112838939f, -0.0939538628f, 0.0901893824f, 0.130421132f, -0.225530177f,
+    0.105558902f, -0.207213923f, 0.122096337f, 0.361677349f, -0.0792306513f, 0.293397844f,
+    0.160395011f, -0.0203512069f, 0.196040869f, 0.216702476f, -0.288663298f, 0.0896119103f,
+    -0.275765151f, -0.152181402f, -0.133985445f, -0.47507605f, 0.165223211f, 0.272792965f,
+    0.24677138f, -0.252130061f, 0.325882047f, 0.235897392f, 0.13399221f, -0.0666050389f,
+    0.354478002f, -0.0241438821f, -0.478583544f, -0.286477655f, -0.631687999f, 0.189737976f,
+    -0.158241689f, 0.187653884f, -0.116552979f, -0.377241731f, -0.00248265266f, 0.38181904f,
+    0.00421817508f, 0.104801625f, 0.152628735f, -0.29196775f, -0.192756966f, -0.0751553029f,
+    -0.216786116f, 0.0796988383f, -0.407382101f, -0.0315435156f, 0.242085099f, 0.328970641f,
+};
+
+inline constexpr float kH3DitAudioLogitsBf16Golden[] = {
+    -0.00812470354f, -0.152351215f, -0.00597176701f, 0.0886283815f, -0.250703663f, 0.191906139f,
+    0.252056986f, -0.159256503f, -0.0153972507f, 0.151418313f, -0.215817913f, 0.122836336f,
+    0.16901201f, -0.254961461f, -0.0292966887f, -0.242927447f, 0.288995713f, -0.284299791f,
+    0.0291916486f, -0.193441495f, -0.138234407f, 0.159750417f, -0.577848017f, 0.208241284f,
+    -0.151085615f, 0.239182577f, 0.00525143743f, -0.0936781019f, -0.290324479f, 0.212291539f,
+    -0.284776956f, 0.161302283f, 0.237678051f, -0.304508328f, -0.0168674588f, -0.196649686f,
+    0.138735116f, -0.353194356f, -0.0514590666f, 0.254677296f, -0.332361221f, 0.22260502f,
+    -0.230079055f, 0.155499578f, 0.348416537f, -0.0579324104f, -0.293201238f, 0.0096321106f,
+    -0.0904588625f, -0.0283052288f, 0.195003152f, -0.195266277f, 0.115033887f, -0.162470683f,
+    -0.200901359f, 0.0571172051f, 0.0866019577f, 0.0433844291f, -0.396381587f, 0.194513857f,
+};
+
+inline constexpr double kH3RandProbe[] = {
+    -0.93872500038680107, -0.13405114396320883, -0.29464633629184278, -0.94858073360166162, 0.46066279294622103, -0.6676767516940918,
+    0.87804263095465118, -0.41525872937931285,
+};
+
+// --- section 6: request planning (time_request.py + shape resolution) ---
+inline constexpr int64_t kH3PlanFrameCases = 14;
+
+inline constexpr int64_t kH3PlanFrameInputs[] = {
+    1, 4, 5, 6, 17, 22, 23, 39, 40, 100, 124, 209,
+    210, 512,
+};
+
+inline constexpr int64_t kH3PlanFrameAligned[] = {
+    5, 5, 5, 22, 22, 22, 39, 39, 56, 107, 124, 209,
+    226, 515,
+};
+
+inline constexpr int64_t kH3PlanVideoLatentT[] = {
+    2, 2, 2, 7, 7, 7, 12, 12, 17, 32, 37, 62,
+    67, 152,
+};
+
+inline constexpr int64_t kH3PlanFrameFromLatentT[] = {
+    5, 5, 5, 22, 22, 22, 39, 39, 56, 107, 124, 209,
+    226, 515,
+};
+
+inline constexpr int64_t kH3PlanAudioLatentT[] = {
+    8, 8, 8, 37, 37, 37, 65, 65, 93, 178, 207, 348,
+    377, 858,
+};
+
+inline constexpr int64_t kH3PlanSigmaCases = 4;
+
+inline constexpr int64_t kH3PlanSigmaSteps[] = {
+    50, 50, 8, 1,
+};
+
+inline constexpr double kH3PlanSigmaShifts[] = {
+    12.0, 3.0, 6.0, 6.0,
+};
+
+inline constexpr int64_t kH3PlanSigmaLengths[] = {
+    50, 50, 8, 1,
+};
+
+inline constexpr float kH3PlanSigmasGolden[] = {
+    1.0f, 0.998266876f, 0.996466458f, 0.994594634f, 0.992647052f, 0.990619123f,
+    0.988505781f, 0.986301303f, 0.984000027f, 0.981595039f, 0.979079425f, 0.976445377f,
+    0.973684132f, 0.970786452f, 0.967741847f, 0.964538991f, 0.961165071f, 0.957605958f,
+    0.953846157f, 0.949868083f, 0.945652187f, 0.941176474f, 0.936416209f, 0.931343257f,
+    0.92592597f, 0.920127749f, 0.91390723f, 0.90721643f, 0.899999976f, 0.892193258f,
+    0.883720875f, 0.874493897f, 0.864406824f, 0.853333294f, 0.841121554f, 0.827586174f,
+    0.81249994f, 0.795580089f, 0.776470542f, 0.754716933f, 0.729729712f, 0.700729907f,
+    0.666666627f, 0.62608695f, 0.576923013f, 0.516129017f, 0.439024389f, 0.338028163f,
+    0.200000003f, 0.0f, 1.0f, 0.993103445f, 0.986014009f, 0.978723407f,
+    0.971222937f, 0.963503599f, 0.955555499f, 0.947368383f, 0.938931227f, 0.930232525f,
+    0.921259761f, 0.911999941f, 0.902438998f, 0.892561913f, 0.882352889f, 0.87179482f,
+    0.860869527f, 0.849557579f, 0.837837934f, 0.825688124f, 0.813084185f, 0.800000072f,
+    0.786407888f, 0.772277236f, 0.75757575f, 0.742268026f, 0.726315737f, 0.709677398f,
+    0.692307651f, 0.674157262f, 0.655172348f, 0.63529408f, 0.614457846f, 0.592592597f,
+    0.569620311f, 0.545454502f, 0.519999981f, 0.493150681f, 0.464788705f, 0.434782565f,
+    0.402985036f, 0.369230777f, 0.333333313f, 0.295081973f, 0.254237264f, 0.210526317f,
+    0.163636371f, 0.113207549f, 0.0588235296f, 0.0f, 1.0f, 0.972972989f,
+    0.93749994f, 0.888888896f, 0.818181813f, 0.70588237f, 0.50000006f, 0.0f,
+    1.0f,
+};
+
+inline constexpr int64_t kH3PlanRefImageCases = 5;
+
+inline constexpr int64_t kH3PlanRefImageInputs[] = {
+    1920, 1080, 1080, 1920, 1000, 1000, 800, 600, 2400, 1000,
+};
+
+inline constexpr int64_t kH3PlanRefImageGolden[] = {
+    3648, 2048, 2048, 3648, 2048, 2048, 2720, 2048, 4928, 2048,
+};
+
+inline constexpr int64_t kH3PlanShapeCases = 7;
+
+inline constexpr double kH3PlanShapeDurations[] = {
+    -1.0, -1.0, 6.0, -1.0, -1.0, -1.0,
+    15.0,
+};
+
+inline constexpr int64_t kH3PlanShapeNumFrames[] = {
+    0, 0, 0, 100, 0, 0, 0,
+};
+
+inline constexpr int64_t kH3PlanShapeHeights[] = {
+    0, 0, 0, 0, 0, 0, 1000,
+};
+
+inline constexpr int64_t kH3PlanShapeWidths[] = {
+    0, 0, 0, 0, 0, 0, 1700,
+};
+
+inline constexpr int64_t kH3PlanShapeImageW[] = {
+    0, 0, 0, 0, 1920, 1080, 0,
+};
+
+inline constexpr int64_t kH3PlanShapeImageH[] = {
+    0, 0, 0, 0, 1080, 1920, 0,
+};
+
+inline constexpr int64_t kH3PlanShapeGolden[] = {
+    768, 1344, 209, 62, 348, 768, 1344, 124, 37, 207, 768, 1344,
+    158, 47, 263, 768, 1344, 107, 32, 178, 768, 1376, 209, 62,
+    348, 1376, 768, 209, 62, 348, 992, 1696, 362, 107, 603,
+};
+
+// Task order for kH3PlanShape*: t2va, ref2va, t2va, t2va, fl2va, fl2va, t2va
+
+// --- section 7: condition-noise augmentation ---
+inline constexpr int64_t kH3CondTargetLatentT = 3;
+inline constexpr int64_t kH3CondImgvidFrames = 1;
+inline constexpr int64_t kH3CondShapeCount = 2;
+inline constexpr int64_t kH3CondRows = 18;
+inline constexpr int64_t kH3CondAudioCount = 2;
+inline constexpr int64_t kH3CondAudioRows = 10;
+
+inline constexpr double kH3CondNoiseAug[] = {
+    0.999,
+};
+
+inline constexpr int64_t kH3CondShapes[] = {
+    1, 4, 6, 2, 4, 6,
+};
+
+inline constexpr int64_t kH3CondAudioT[] = {
+    2, 3,
+};
+
+inline constexpr float kH3CondNoiseRows[] = {
+    -0.111718565f, -0.496590108f, -0.0596576072f, -0.467497945f, 0.738792598f, 1.59033453f,
+    -1.07924283f, -0.339609742f, -0.794542253f, 0.614386201f, 0.22087656f, -0.824515939f,
+    -1.41657794f, -0.986337662f, 1.06849718f, -0.183107883f, -0.534491062f, 2.20114017f,
+    1.30638945f, -2.18802333f, -0.0313676968f, 0.446462661f, 0.528711319f, 0.0930761695f,
+    0.279643595f, 1.21806324f, -0.511318505f, -0.512355089f, 1.06548393f, 0.518520594f,
+    0.966753483f, 0.297107667f, -0.31199649f, 2.45336914f, 0.0710412189f, 0.739978611f,
+    0.136045024f, 2.1895709f, 1.69853234f, -0.563737333f, -1.81309128f, -0.769362628f,
+    1.0852381f, 0.0627106279f, -0.943483233f, 1.19686699f, 0.0392943881f, -1.4806397f,
+    -0.494167924f, 0.786653697f, -0.88576293f, 0.465061128f, 1.67519653f, 0.96456486f,
+    -0.508196592f, -1.32917809f, -1.29686797f, -4.06878233f, 0.224511534f, -0.0390144177f,
+    -0.2251295f, -1.64134347f, -0.00245319167f, -0.192399323f, -1.16469073f, -0.30170086f,
+    -0.47013101f, -0.0511241443f, 0.687661469f, 1.0890286f, -1.20671833f, 0.888702691f,
+    0.0653422102f, 0.885972261f, 0.969910264f, -0.341667145f, -1.32872355f, -0.00720407162f,
+    -1.84988523f, -0.612135708f, -0.86480999f, 2.05306768f, 0.461101294f, 0.83801192f,
+    -0.427731335f, -0.26456216f, -0.677122593f, 1.75750577f, 0.0682955533f, -1.09384692f,
+    0.104658894f, 0.0299600381f, -0.769504547f, 0.561213434f, -1.26167667f, -1.29297054f,
+    0.163073704f, -0.88168776f, -0.215252936f, 0.883961618f, -0.194736242f, -0.241486594f,
+    -0.677968144f, -0.126062229f, -0.273025632f, 1.6560545f, 0.728879035f, -0.733625352f,
+    0.609118462f, 0.666754723f, 0.644461215f, -0.559220493f, -1.21468258f, -0.864175677f,
+    -2.0552175f, 0.738431871f, 1.47965586f, -1.04310751f, 1.28188324f, -0.62895596f,
+    0.172737867f, 0.206859037f, -0.831453025f, -1.91674638f, -0.821729958f, -1.63756454f,
+    0.200949982f, -0.613191545f, 0.792608142f, 0.238239661f, 0.728616953f, 1.35788608f,
+    -0.215887353f, -0.434204459f, -2.14291906f, -0.0135392742f, -0.777407229f, -0.492416292f,
+    0.80599159f, 0.178294659f, 1.6195122f, 0.820007682f, -0.348207355f, -0.0712817609f,
+    1.15860248f, -0.0976761505f, 2.35707664f, -1.4839325f, 0.644732893f, -0.779094994f,
+    -0.552035928f, 1.52057612f, 0.537062407f, -0.721368849f, -0.0784790963f, -0.152539134f,
+    -1.21639621f, -1.50105274f, 0.498123497f, -0.777507007f, 0.652263105f, -0.729873598f,
+    0.972962201f, 0.969319284f, 0.305310667f, -0.725764036f, 0.771874249f, -0.78806597f,
+    0.711368859f, 0.265851974f, 3.19180226f, -0.861759484f, 0.652739108f, 0.32461077f,
+    -1.3680979f, 0.611203849f, -1.05602443f, 1.25422454f, 0.284971565f, 1.10116088f,
+    -0.774965346f, 1.0044533f, -1.00242722f, -1.97354591f, -0.198467687f, -0.0801693052f,
+    0.196382999f, -0.882876694f, -0.876903594f, -0.233941972f, -0.735592663f, -2.50148249f,
+    0.0539001934f, 0.668373704f, -0.758416891f, -0.368867904f, 1.32044733f, 1.59969699f,
+    -1.67696702f, 1.20680046f, 1.39402997f, 0.605950713f, 1.56240535f, -1.02079904f,
+    -1.12062979f, -1.66799462f, -0.447985381f, -0.647583842f, -1.01317549f, -0.366758049f,
+    0.94542104f, -1.3522383f, 0.796614945f, 0.463342458f, 0.727170885f, -1.42993701f,
+    1.40070319f, -1.02155983f, -0.337787271f, -0.873210311f, -0.536230981f, -0.128767893f,
+    -1.27942598f, -0.403698683f, -0.524465263f, -0.213143304f, 1.35832107f, -0.581765354f,
+    -0.221579507f, -0.729424f, 0.917406738f, -1.84309554f, -0.719641328f, -0.106058903f,
+    -0.809216857f, 0.245494843f, 2.22544861f, 1.10015082f, -1.4655211f, 0.185869694f,
+    -2.2264607f, 1.14283562f, 0.529485762f, 0.651577353f, -0.0207676925f, 0.237874672f,
+    -0.523461878f, -2.4551487f, 0.307307541f, 0.335188001f, -0.14787285f, -0.538716614f,
+    -0.559957445f, 0.335635513f, -0.035689f, 2.38697124f, -0.470735669f, 0.357248694f,
+    2.88072014f, 0.615338981f, -0.470733643f, -2.10832763f, 1.1358453f, -0.100683309f,
+    1.37905157f, 0.0358249582f, -0.281386822f, -1.17626226f, -0.773986876f, -1.54708529f,
+    0.212544158f, 1.8253243f, -0.703444898f, -2.07509017f, 0.366381347f, 1.47161794f,
+    0.992718458f, -1.54516041f, 0.500031412f, 0.0796812177f, -0.747796237f, 1.0546931f,
+    -0.116507411f, 2.06491947f, -0.943422854f, 1.40239346f, 0.0557162166f, 0.300026f,
+    -0.342393607f, -1.40197182f, -0.704919696f, -1.60236216f, 0.572177291f, 0.0652887523f,
+    2.66167617f, 2.14791226f, -0.0175341405f, -0.919404328f, -1.24734235f, -0.748450875f,
+    0.208259806f, -0.73775506f, 1.37697709f, 0.398878217f, 0.662899375f, 0.543566525f,
+    -1.32078922f, 1.44865799f, -0.267996907f, 0.815666676f, 0.265920937f, -0.709127426f,
+    0.699125171f, -1.72334659f, -0.884155393f, -0.378046244f, 0.0097311046f, -0.473335743f,
+    -0.232488289f, 1.0328027f, -0.320419014f, -0.724195242f, 2.91535592f, -0.198520362f,
+    0.634416103f, 0.85569483f, 1.94327092f, -1.73108923f, -0.194445774f, -0.368559241f,
+    -0.331674933f, -0.418994784f, -1.05000854f, -0.294377238f, 0.124324113f, 1.11622071f,
+    0.185821161f, -2.25003862f, -0.0684034526f, -0.970386505f, 0.576729596f, 0.450140476f,
+    -0.0585367568f, 0.354647577f, 0.345282614f, -1.43136251f, 0.0872365087f, 0.661072493f,
+    -0.21163331f, 0.474932939f, 0.0736369565f, 1.11119437f, 0.453940123f, 0.162008673f,
+    -0.814218283f, -0.327357888f, -0.742517591f, 0.124151863f, 0.499846101f, 1.19887507f,
+    2.29800534f, 0.610523999f, 0.789191961f, 0.4604038f, 1.880602f, 0.71661371f,
+    2.61741161f, -1.71552002f, -0.707725704f, -1.27488923f, 1.1469574f, -0.165212065f,
+    -0.116829179f, 1.41453958f, -1.97085989f, 0.7432307f, -0.150498331f, 0.899837971f,
+    -1.36999238f, -1.54496181f, 0.114905812f, -0.569101512f, 0.00633249525f, 0.0193489734f,
+    0.320647985f, -1.0218575f, 0.28909719f, 0.489870846f, -0.023459021f, 0.887605667f,
+    -0.855492592f, -0.720805883f, -0.93890053f, -1.94208455f, -0.979238093f, 0.828512371f,
+    -0.321752667f, -0.949137747f, -1.21525753f, -0.031618312f, 0.532773316f, -0.729118347f,
+    -1.51547778f, -1.23637509f, 0.206128642f, -0.702998161f, 0.146176562f, -1.79705882f,
+    0.0584318712f, -0.268287152f, -1.63140845f, 0.155666456f, 1.21237302f, -0.173856542f,
+    -0.348020405f, 1.45940423f, -1.53092003f, 1.52081752f, 0.750685275f, -0.0390308313f,
+    -1.79293346f, -0.868515313f, -1.25516546f, 0.406398416f, -0.958898365f, -1.90516937f,
+    -1.41187263f, -2.51458359f, -0.589540899f, 0.239374787f, -1.6448741f, 1.07551301f,
+    0.399106354f, 0.506751835f, 1.56778908f, -0.65936327f, -0.878071666f, 0.339102119f,
+    0.643097639f, 0.589464366f, -0.959836602f, -0.125817075f, -0.518515468f, 0.75658977f,
+    0.883272648f, -1.95822489f, -0.209232435f, -1.27165318f, 2.36643457f, -0.286088139f,
+    -1.33581674f, -0.572270751f, 1.5235312f, -0.565980673f, -0.601523757f, -0.273638099f,
+    0.528206646f, 0.60210222f, -0.986849427f, 1.99064708f, 1.36409819f, 0.0865701213f,
+    -0.382639498f, 0.754344881f, 0.1112886f, 0.29878664f, -1.92160046f, -0.272310644f,
+    -0.858881712f, 0.37394467f, -0.579827249f, -0.971691906f, -1.19870555f, 0.415862978f,
+    -0.848874629f, -0.633103371f, -1.05293322f, -2.07254124f, -0.0594089366f, -1.05746043f,
+    0.798832595f, -0.092287533f, -0.385274619f, -0.712034583f, 0.956971049f, -0.550986826f,
+    1.37545443f, 0.998847306f, 0.232900739f, -1.10142016f, -0.250131965f, 0.160227641f,
+    1.07036197f, -1.04696834f, -0.868730485f, -0.351021111f, -1.3583293f, -0.18685855f,
+    -0.675816834f, -0.0800120905f, 0.576809168f, -1.19719088f, -0.357475519f, -1.456406f,
+    0.342928261f, -2.34045291f, 0.645746291f, -0.806575119f, -0.785905063f, -0.604111195f,
+    -0.055951491f, -1.28356946f, 0.240120694f, -0.545530915f, 0.863575101f, 0.204838425f,
+    0.030609576f, -2.32093048f, -0.0385488756f, 0.833428264f, -1.30595183f, -1.46689844f,
+    -0.787944436f, -0.522495568f, -2.66296148f, 0.0518725105f, 0.42521888f, -0.0518248342f,
+    0.2817339f, 1.47225571f, 1.22812593f, 0.140961766f, 0.811190426f, -1.06943536f,
+    1.06359208f, -0.116607226f, -0.814749002f, -1.58378565f, -2.07509041f, 1.90529788f,
+    -0.166269064f, 2.0628252f, 0.055552911f, -0.472379595f, 1.54062796f, 2.1775198f,
+    0.579726875f, -1.20756459f, 1.73388028f, 0.129710421f, 0.28031531f, 0.202012837f,
+    1.28994894f, -1.66655529f, -0.706625938f, -1.5533216f, -0.280840933f, 1.36638224f,
+    -1.09036422f, -0.362015784f, 0.133870095f, -1.17109561f, 0.814060569f, -1.92213535f,
+    0.971752226f, 1.21063709f, 1.41739225f, -1.70147431f, -1.6299808f, 0.373642147f,
+    1.01520336f, -1.60482943f, -0.694610298f, 0.0269353576f, 0.783904433f, -2.15741348f,
+    -0.111718565f, -0.496590108f, -0.0596576072f, -0.467497945f, 0.738792598f, 1.59033453f,
+    -1.07924283f, -0.339609742f, -0.794542253f, 0.614386201f, 0.22087656f, -0.824515939f,
+    -1.41657794f, -0.986337662f, 1.06849718f, -0.183107883f, -0.534491062f, 2.20114017f,
+    1.30638945f, -2.18802333f, -0.0313676968f, 0.446462661f, 0.528711319f, 0.0930761695f,
+    0.279643595f, 1.21806324f, -0.511318505f, -0.512355089f, 1.06548393f, 0.518520594f,
+    0.966753483f, 0.297107667f, -0.31199649f, 2.45336914f, 0.0710412189f, 0.739978611f,
+    0.136045024f, 2.1895709f, 1.69853234f, -0.563737333f, -1.81309128f, -0.769362628f,
+    1.0852381f, 0.0627106279f, -0.943483233f, 1.19686699f, 0.0392943881f, -1.4806397f,
+    -0.494167924f, 0.786653697f, -0.88576293f, 0.465061128f, 1.67519653f, 0.96456486f,
+    -0.508196592f, -1.32917809f, -1.29686797f, -4.06878233f, 0.224511534f, -0.0390144177f,
+    -0.2251295f, -1.64134347f, -0.00245319167f, -0.192399323f, -1.16469073f, -0.30170086f,
+    -0.47013101f, -0.0511241443f, 0.687661469f, 1.0890286f, -1.20671833f, 0.888702691f,
+    0.0653422102f, 0.885972261f, 0.969910264f, -0.341667145f, -1.32872355f, -0.00720407162f,
+    -1.84988523f, -0.612135708f, -0.86480999f, 2.05306768f, 0.461101294f, 0.83801192f,
+    -0.427731335f, -0.26456216f, -0.677122593f, 1.75750577f, 0.0682955533f, -1.09384692f,
+    0.104658894f, 0.0299600381f, -0.769504547f, 0.561213434f, -1.26167667f, -1.29297054f,
+    0.163073704f, -0.88168776f, -0.215252936f, 0.883961618f, -0.194736242f, -0.241486594f,
+    -0.677968144f, -0.126062229f, -0.273025632f, 1.6560545f, 0.728879035f, -0.733625352f,
+    0.609118462f, 0.666754723f, 0.644461215f, -0.559220493f, -1.21468258f, -0.864175677f,
+    -2.0552175f, 0.738431871f, 1.47965586f, -1.04310751f, 1.28188324f, -0.62895596f,
+    0.172737867f, 0.206859037f, -0.831453025f, -1.91674638f, -0.821729958f, -1.63756454f,
+    0.200949982f, -0.613191545f, 0.792608142f, 0.238239661f, 0.728616953f, 1.35788608f,
+    -0.215887353f, -0.434204459f, -2.14291906f, -0.0135392742f, -0.777407229f, -0.492416292f,
+    0.80599159f, 0.178294659f, 1.6195122f, 0.820007682f, -0.348207355f, -0.0712817609f,
+    1.15860248f, -0.0976761505f, 2.35707664f, -1.4839325f, 0.644732893f, -0.779094994f,
+    -0.552035928f, 1.52057612f, 0.537062407f, -0.721368849f, -0.0784790963f, -0.152539134f,
+    -1.21639621f, -1.50105274f, 0.498123497f, -0.777507007f, 0.652263105f, -0.729873598f,
+    0.972962201f, 0.969319284f, 0.305310667f, -0.725764036f, 0.771874249f, -0.78806597f,
+    0.711368859f, 0.265851974f, 3.19180226f, -0.861759484f, 0.652739108f, 0.32461077f,
+    -1.3680979f, 0.611203849f, -1.05602443f, 1.25422454f, 0.284971565f, 1.10116088f,
+    -0.774965346f, 1.0044533f, -1.00242722f, -1.97354591f, -0.198467687f, -0.0801693052f,
+    0.196382999f, -0.882876694f, -0.876903594f, -0.233941972f, -0.735592663f, -2.50148249f,
+    0.0539001934f, 0.668373704f, -0.758416891f, -0.368867904f, 1.32044733f, 1.59969699f,
+    -1.67696702f, 1.20680046f, 1.39402997f, 0.605950713f, 1.56240535f, -1.02079904f,
+    -1.12062979f, -1.66799462f, -0.447985381f, -0.647583842f, -1.01317549f, -0.366758049f,
+    0.94542104f, -1.3522383f, 0.796614945f, 0.463342458f, 0.727170885f, -1.42993701f,
+    1.40070319f, -1.02155983f, -0.337787271f, -0.873210311f, -0.536230981f, -0.128767893f,
+    -1.27942598f, -0.403698683f, -0.524465263f, -0.213143304f, 1.35832107f, -0.581765354f,
+    -0.221579507f, -0.729424f, 0.917406738f, -1.84309554f, -0.719641328f, -0.106058903f,
+    -0.809216857f, 0.245494843f, 2.22544861f, 1.10015082f, -1.4655211f, 0.185869694f,
+    -2.2264607f, 1.14283562f, 0.529485762f, 0.651577353f, -0.0207676925f, 0.237874672f,
+    -0.523461878f, -2.4551487f, 0.307307541f, 0.335188001f, -0.14787285f, -0.538716614f,
+    -0.559957445f, 0.335635513f, -0.035689f, 2.38697124f, -0.470735669f, 0.357248694f,
+    2.88072014f, 0.615338981f, -0.470733643f, -2.10832763f, 1.1358453f, -0.100683309f,
+    1.37905157f, 0.0358249582f, -0.281386822f, -1.17626226f, -0.773986876f, -1.54708529f,
+    0.212544158f, 1.8253243f, -0.703444898f, -2.07509017f, 0.366381347f, 1.47161794f,
+    0.992718458f, -1.54516041f, 0.500031412f, 0.0796812177f, -0.747796237f, 1.0546931f,
+    -0.116507411f, 2.06491947f, -0.943422854f, 1.40239346f, 0.0557162166f, 0.300026f,
+    -0.342393607f, -1.40197182f, -0.704919696f, -1.60236216f, 0.572177291f, 0.0652887523f,
+    2.66167617f, 2.14791226f, -0.0175341405f, -0.919404328f, -1.24734235f, -0.748450875f,
+    0.208259806f, -0.73775506f, 1.37697709f, 0.398878217f, 0.662899375f, 0.543566525f,
+    -1.32078922f, 1.44865799f, -0.267996907f, 0.815666676f, 0.265920937f, -0.709127426f,
+    0.699125171f, -1.72334659f, -0.884155393f, -0.378046244f, 0.0097311046f, -0.473335743f,
+    -0.232488289f, 1.0328027f, -0.320419014f, -0.724195242f, 2.91535592f, -0.198520362f,
+    0.634416103f, 0.85569483f, 1.94327092f, -1.73108923f, -0.194445774f, -0.368559241f,
+    -0.331674933f, -0.418994784f, -1.05000854f, -0.294377238f, 0.124324113f, 1.11622071f,
+    0.185821161f, -2.25003862f, -0.0684034526f, -0.970386505f, 0.576729596f, 0.450140476f,
+    -0.0585367568f, 0.354647577f, 0.345282614f, -1.43136251f, 0.0872365087f, 0.661072493f,
+    -0.21163331f, 0.474932939f, 0.0736369565f, 1.11119437f, 0.453940123f, 0.162008673f,
+    -0.814218283f, -0.327357888f, -0.742517591f, 0.124151863f, 0.499846101f, 1.19887507f,
+    2.29800534f, 0.610523999f, 0.789191961f, 0.4604038f, 1.880602f, 0.71661371f,
+    2.61741161f, -1.71552002f, -0.707725704f, -1.27488923f, 1.1469574f, -0.165212065f,
+    -0.116829179f, 1.41453958f, -1.97085989f, 0.7432307f, -0.150498331f, 0.899837971f,
+    -1.36999238f, -1.54496181f, 0.114905812f, -0.569101512f, 0.00633249525f, 0.0193489734f,
+    0.320647985f, -1.0218575f, 0.28909719f, 0.489870846f, -0.023459021f, 0.887605667f,
+    -0.855492592f, -0.720805883f, -0.93890053f, -1.94208455f, -0.979238093f, 0.828512371f,
+    -0.321752667f, -0.949137747f, -1.21525753f, -0.031618312f, 0.532773316f, -0.729118347f,
+    -1.51547778f, -1.23637509f, 0.206128642f, -0.702998161f, 0.146176562f, -1.79705882f,
+    0.0584318712f, -0.268287152f, -1.63140845f, 0.155666456f, 1.21237302f, -0.173856542f,
+    -0.348020405f, 1.45940423f, -1.53092003f, 1.52081752f, 0.750685275f, -0.0390308313f,
+    -1.79293346f, -0.868515313f, -1.25516546f, 0.406398416f, -0.958898365f, -1.90516937f,
+    -1.41187263f, -2.51458359f, -0.589540899f, 0.239374787f, -1.6448741f, 1.07551301f,
+    0.399106354f, 0.506751835f, 1.56778908f, -0.65936327f, -0.878071666f, 0.339102119f,
+    0.643097639f, 0.589464366f, -0.959836602f, -0.125817075f, -0.518515468f, 0.75658977f,
+    0.883272648f, -1.95822489f, -0.209232435f, -1.27165318f, 2.36643457f, -0.286088139f,
+    -1.33581674f, -0.572270751f, 1.5235312f, -0.565980673f, -0.601523757f, -0.273638099f,
+    0.528206646f, 0.60210222f, -0.986849427f, 1.99064708f, 1.36409819f, 0.0865701213f,
+    -0.382639498f, 0.754344881f, 0.1112886f, 0.29878664f, -1.92160046f, -0.272310644f,
+    -0.858881712f, 0.37394467f, -0.579827249f, -0.971691906f, -1.19870555f, 0.415862978f,
+    -0.848874629f, -0.633103371f, -1.05293322f, -2.07254124f, -0.0594089366f, -1.05746043f,
+    0.798832595f, -0.092287533f, -0.385274619f, -0.712034583f, 0.956971049f, -0.550986826f,
+    1.37545443f, 0.998847306f, 0.232900739f, -1.10142016f, -0.250131965f, 0.160227641f,
+    1.07036197f, -1.04696834f, -0.868730485f, -0.351021111f, -1.3583293f, -0.18685855f,
+    -0.675816834f, -0.0800120905f, 0.576809168f, -1.19719088f, -0.357475519f, -1.456406f,
+    0.342928261f, -2.34045291f, 0.645746291f, -0.806575119f, -0.785905063f, -0.604111195f,
+    -0.055951491f, -1.28356946f, 0.240120694f, -0.545530915f, 0.863575101f, 0.204838425f,
+    0.030609576f, -2.32093048f, -0.0385488756f, 0.833428264f, -1.30595183f, -1.46689844f,
+    -0.787944436f, -0.522495568f, -2.66296148f, 0.0518725105f, 0.42521888f, -0.0518248342f,
+    0.2817339f, 1.47225571f, 1.22812593f, 0.140961766f, 0.811190426f, -1.06943536f,
+    1.06359208f, -0.116607226f, -0.814749002f, -1.58378565f, -2.07509041f, 1.90529788f,
+    -0.166269064f, 2.0628252f, 0.055552911f, -0.472379595f, 1.54062796f, 2.1775198f,
+    0.579726875f, -1.20756459f, 1.73388028f, 0.129710421f, 0.28031531f, 0.202012837f,
+    1.28994894f, -1.66655529f, -0.706625938f, -1.5533216f, -0.280840933f, 1.36638224f,
+    -1.09036422f, -0.362015784f, 0.133870095f, -1.17109561f, 0.814060569f, -1.92213535f,
+    0.971752226f, 1.21063709f, 1.41739225f, -1.70147431f, -1.6299808f, 0.373642147f,
+    1.01520336f, -1.60482943f, -0.694610298f, 0.0269353576f, 0.783904433f, -2.15741348f,
+    -0.170613497f, -1.45943868f, -0.66305387f, 1.21575689f, 0.146918997f, -0.905294061f,
+    0.907783568f, 0.484822154f, 0.729535639f, -0.44405058f, -0.110835865f, -0.257299811f,
+    -0.199982241f, -1.44468224f, -0.0114688519f, -1.05454445f, -0.406018406f, 0.241545811f,
+    -0.0311669037f, 1.47250164f, 1.71731043f, -1.0184114f, -0.666139245f, -0.617986798f,
+    0.788171113f, -1.66254449f, 0.0162717849f, 0.0611960664f, 0.712596536f, 1.10811055f,
+    0.218141735f, 2.09063935f, 0.453148067f, -0.111205794f, -1.00015855f, -0.170854121f,
+    -0.366276085f, -1.24011099f, 0.916934073f, 0.304888844f, 0.492182344f, 1.76658905f,
+    0.0123760765f, 2.04670286f, -1.12375629f, -1.23165059f, 1.18777049f, 0.85133487f,
+    0.522665143f, 0.0628270283f, 0.13589631f, 0.922511697f, 1.98830843f, 0.705739141f,
+    -0.0689120665f, 1.57355905f, -0.192761093f, 0.820959747f, -1.17470312f, -1.51131296f,
+    0.56384486f, -0.208505481f, 1.31173027f, -0.260935336f, -0.0148426276f, -1.06432748f,
+    -0.736018181f, -1.09856224f, -0.326680839f, 0.13899897f, 0.921037853f, 0.506197929f,
+    -0.657777905f, 1.01317573f, 1.03071547f, 1.23746622f, -0.102453858f, 1.54949594f,
+    -0.14361985f, 0.151711568f, 0.0499724373f, 0.494941741f, -1.2881602f, 0.625454366f,
+    0.817615807f, -0.150380701f, -1.47919559f, -0.724608243f, -0.323036849f, -0.349228114f,
+    2.18529201f, -1.10582614f, 1.06134379f, -0.715110421f, -1.11812079f, -0.908706248f,
+    0.220659077f, 0.246252075f, -1.49487579f, 0.88096112f, -0.358746618f, 1.63738954f,
+    -0.26321584f, -0.543229878f, 0.821359754f, -0.601524055f, 0.563139737f, 0.0628963336f,
+    0.840209603f, -0.866842866f, -0.87479651f, 2.2993722f, 0.255928338f, -0.0605121627f,
+    -0.481494963f, -0.853339195f, -2.1018846f, -1.69814813f, 1.31070399f, 1.47359574f,
+    -0.7064116f, 0.447823972f, -2.69811153f, -0.508146167f, 0.00469527673f, 0.66728729f,
+    0.416027397f, -1.39303148f, 1.03071976f, -1.18621719f, -0.221757963f, 0.147707254f,
+    -0.256641626f, -0.0977100134f, -0.883027911f, -1.58405876f, 0.0404260494f, 0.446097404f,
+    -0.465207696f, 0.59823662f, -1.2211839f, -0.22103475f, 1.07439709f, -0.0301932432f,
+    -1.16783547f, -0.0426587462f, -0.462375462f, -0.689061522f, 0.275136173f, -0.845354378f,
+    0.00842034444f, 0.827321887f, 0.899319351f, -1.02279222f, -1.00794864f, 1.85045123f,
+    -2.78841853f, -0.959828377f, -1.52421784f, 2.09060359f, -0.586093307f, 0.226870924f,
+    0.929252684f, 0.956510305f, 0.514865935f, -0.0725017563f, 0.46202141f, -0.0802508891f,
+    -0.179672599f, -0.523514688f, -0.525947452f, 0.122704498f, 0.613741279f, 0.193300888f,
+    2.0628593f, 0.186365798f, -0.729822278f, -0.991251767f, 0.147026002f, 0.705181241f,
+    -1.08572888f, -1.73749602f, 1.47124076f, -0.801741838f, 0.983391285f, -1.2950201f,
+    -0.876452386f, 0.75497812f, 1.08835876f, 0.894808173f, 1.01531351f, -1.34011018f,
+    -1.32481194f, 0.696980536f, -1.17864752f, -0.933995008f, 0.68968612f, -0.584442437f,
+    -1.64057648f, 0.929452956f, 0.906919658f, 1.56910086f, -0.0639178604f, 3.02917433f,
+    -0.972759187f, -1.24517179f, -1.44531918f, -0.735035479f, -0.153940558f, 1.4019475f,
+    0.23098284f, 0.753509104f, -1.03736031f, 0.923020959f, -0.28513062f, -0.372597635f,
+    -0.429999948f, 1.14914298f, 0.874333739f, -0.23583445f, -0.558090448f, -0.954282284f,
+    -0.580925882f, 1.49668384f, -0.969601095f, 0.150802851f, -0.187460363f, 0.996331096f,
+    0.227312818f, -1.56659007f, -0.371138602f, -1.23384798f, -1.65696537f, -0.611091197f,
+    0.277811021f, 1.79605174f, -0.477179676f, 0.251603872f, -0.327753782f, 0.243813813f,
+    -0.953583479f, 1.38172579f, -0.205838367f, 1.14281714f, -0.56392324f, -0.362936527f,
+    -0.635571778f, 1.1765641f, 1.39861429f, -0.337661415f, 0.788504004f, -0.978667915f,
+    0.235897958f, -0.728427052f, -1.82879043f, 0.452488601f, -1.0685153f, 0.685732603f,
+    1.10587525f, -1.87339604f, -1.44109559f, -1.53605688f, 1.71513188f, -0.812178075f,
+    -1.10634303f, 0.885003448f, 1.50741708f, 0.985258579f, 3.02715421f, 0.578023195f,
+    -0.0464790948f, 1.91046476f, 0.452410191f, 0.110519134f, 1.25406563f, 0.806007326f,
+    -0.141411513f, -1.03523874f, -1.06331968f, -1.63681233f, -1.44438851f, -1.98175216f,
+    -1.09091258f, 1.04554069f, -2.80388474f, -0.334401131f, 0.877126455f, 0.349490076f,
+    -0.567545474f, -0.27722767f, -0.313860476f, -1.15670431f, 1.29069924f, 0.26122123f,
+    -0.667616904f, -0.842442572f, 0.185761243f, -0.170361951f, -1.39543378f, 0.867472291f,
+    -1.60727596f, -1.10385323f, -0.893197775f, -0.34646064f, -0.628690302f, -0.770201981f,
+    1.67101514f, -0.818153143f, -1.65634513f, -1.41510403f, -0.462672412f, -1.49790597f,
+    0.243520126f, 0.543088198f, -1.03151917f, -0.71857065f, 1.25382364f, 1.26669025f,
+    -1.9278965f, 1.58467305f, 0.361077875f, 0.0238246825f, 0.938484251f, 0.32447657f,
+    -0.614223182f, 0.280120522f, 0.336592674f, -0.453287482f, 0.722263575f, 0.592350543f,
+    -1.13218451f, -0.556657612f, -0.499049932f, 0.374597877f, -2.12161994f, -2.22775745f,
+    1.63639283f, -0.719573855f, 0.282115817f, 1.05439794f, -0.687608957f, -0.311264813f,
+    -1.45511448f, -0.601046979f, -0.258868963f, -1.66521919f, -0.539172769f, 0.409183174f,
+    -1.02566791f, 1.25679064f, 0.503800631f, 0.422449768f, -0.276676446f, -1.99994957f,
+    0.656811416f, 0.279683262f, 0.0907033905f, -1.17096376f, 1.23897862f, -0.383756965f,
+    -1.11202276f, -0.425700396f, 1.40168142f, -1.65013421f, 0.932453692f, 1.92565143f,
+    1.37936664f, 1.04109061f, 0.380097538f, 0.6872226f, 1.30031931f, -1.39804673f,
+    1.08557534f, 1.20062816f, -1.42779994f, 0.430175036f, 0.842383504f, 1.5335983f,
+    0.0589223206f, -0.392384857f, 1.6051054f, 0.860343277f, -0.65935564f, 0.589902401f,
+    -2.18339777f, 0.366826355f, 1.84085763f, -1.01743221f, -0.586164355f, -1.51052809f,
+    0.528945982f, -0.544657171f, 1.02704179f, 0.0704023093f, -0.225153029f, 0.119290188f,
+    -1.86797142f, 0.811876297f, -0.536503315f, -0.229270294f, 1.67127144f, 0.77652359f,
+    0.755146623f, 1.36625767f, -0.189667419f, 1.78604102f, -0.40239051f, -0.168760911f,
+    0.749847591f, 0.123783424f, -1.01727378f, 1.27406681f, -0.0936365128f, 0.106319815f,
+    0.766988158f, -0.986011982f, -0.0332376696f, 1.09441519f, -1.7054404f, 0.746680021f,
+    -0.547440171f, -0.369727165f, 0.0461238287f, -0.25976941f, -1.00440955f, -0.188052267f,
+    0.100316741f, 0.112108439f, -0.641563952f, -0.584432065f, -0.222241744f, 0.885426462f,
+    -0.0369239748f, 1.42081857f, 1.12102592f, -0.962533593f, 0.404954851f, -1.33901453f,
+    -0.155801505f, -0.34102428f, -1.02187991f, 0.223434716f, 0.215479672f, -0.593675435f,
+    1.01714563f, 0.735560834f, 0.793498814f, 0.390327841f, 0.453542471f, -0.900850654f,
+    -0.751298726f, -1.27445817f, -0.768416166f, -0.087576367f, -2.92294002f, 0.982525349f,
+    -0.295585215f, -0.0667909309f, 0.685729086f, 0.13340418f, 2.59979749f, 0.608043432f,
+    0.27119723f, -0.355898827f, 0.696010888f, 0.236275569f, 1.00513935f, 1.29886591f,
+    -0.788985133f, -0.0262500793f, 0.213088453f, -0.580121517f, -0.768142223f, 1.35887909f,
+    -1.53655756f, -0.997212529f, 0.0235550366f, -2.40607071f, -1.59611344f, -0.195336789f,
+    0.938027382f, 0.00781648513f, 1.21924055f, 0.160126761f, -2.01545501f, 0.696367979f,
+    0.809671164f, 1.12257171f, 0.358630359f, -2.35936308f, -1.07716358f, 0.251604348f,
+    1.1538074f, -0.553991556f, -0.2483816f, 0.354443789f, 0.489145547f, -0.501512766f,
+    -0.459819019f, 0.666813254f, 1.8001076f, 0.978921413f, -0.729459345f, -2.33393717f,
+    0.131673545f, 0.121144608f, 0.150348052f, 0.364033461f, -0.0316633545f, -0.0646187291f,
+    0.526023924f, 0.836075902f, -0.170906708f, 1.21200597f, -0.605898142f, 0.657240331f,
+    0.821433246f, -2.6705091f, -1.03533161f, 0.800495625f, 1.74352551f, -0.252878547f,
+    -0.997765481f, -0.381614774f, -0.284894705f, 0.415788084f, 0.146882981f, 0.415786266f,
+    0.362892807f, -0.740427554f, 0.0565381534f, -0.471357077f, 0.570356071f, 1.79702699f,
+    -0.805574477f, 1.75722432f, 1.3461237f, 0.743281007f, -0.22821711f, -0.565314889f,
+    1.93344045f, 2.3053329f, -0.890028894f, 0.634248435f, 1.59653902f, 0.636502743f,
+    0.511565149f, 1.81886137f, -1.36479545f, 1.03339374f, -0.258007497f, 0.455032587f,
+    1.05423295f, -0.338766515f, 0.540295482f, -0.0543335453f, 1.39361393f, -1.11507916f,
+    -0.389756411f, 0.560305476f, -0.349425316f, 0.632617891f, -0.43825534f, -0.640632331f,
+    1.02310252f, -1.77615273f, -1.1538775f, 1.02597272f, -0.0647603199f, 1.50940251f,
+    0.391858369f, -1.14763451f, 0.658556044f, 1.47881353f, -0.377006799f, 0.574636817f,
+};
+
+inline constexpr float kH3CondGolden[] = {
+    0.462093711f, 0.86216718f, -0.208971903f, 0.822244465f, 0.558785856f, -0.356530547f,
+    0.49248904f, -0.33328864f, 0.809041858f, -0.562776148f, 0.972126067f, -0.197489336f,
+    0.693079591f, -0.810632348f, -0.41702196f, 0.0639127493f, -0.988324046f, 0.87150389f,
+    -0.0646685213f, 0.978316367f, 0.117470928f, 0.312606841f, 0.718475044f, 0.429085046f,
+    0.997198701f, -0.216764227f, 0.795746624f, 0.307088375f, 0.669176221f, 0.789651275f,
+    0.494494557f, -0.649814188f, 0.0648123547f, 0.0429900326f, 0.815456331f, 0.140024796f,
+    -0.792457581f, -0.0973668844f, -0.786209822f, 0.766691864f, 0.611311615f, 0.78858161f,
+    0.690487385f, -0.634718835f, 0.28793931f, -0.446451128f, 0.820872366f, 0.166091248f,
+    -0.355444163f, 0.0702754632f, 0.914934218f, 0.0114544854f, -0.808124304f, -0.155509308f,
+    0.606385589f, -0.0460792147f, 0.626517117f, -0.984036684f, -0.540453315f, 0.077688925f,
+    0.744485378f, 0.51025337f, 0.209631771f, -0.635137379f, -0.0101351077f, -0.486889362f,
+    -0.416879594f, 0.946705997f, 0.785469115f, 0.856643438f, -0.28319037f, -0.214966878f,
+    0.767973125f, -0.810635865f, -0.0139739914f, 0.0125909271f, -0.212639779f, -0.183391914f,
+    -0.837488294f, 0.265271157f, 0.120175749f, 0.478797525f, -0.97138679f, -0.966044664f,
+    -0.495382071f, -0.858534634f, -0.479827911f, -0.448469609f, -0.262153625f, -0.394134104f,
+    -0.755238354f, -0.199743479f, 0.340920806f, -0.0249555558f, -0.315300554f, 0.711328208f,
+    0.443641037f, 0.311771095f, -0.647399902f, 0.747862518f, -0.720110357f, -0.588481784f,
+    -0.203536361f, 0.299655288f, 0.480858147f, 0.252609223f, -0.258503467f, -0.143495291f,
+    0.753881395f, -0.230647549f, -0.355059326f, 0.970636964f, 0.0293034837f, -0.557962894f,
+    -0.989796996f, -0.24828276f, 0.0712146983f, 0.759323001f, -0.958605528f, -0.409575194f,
+    -0.872677326f, 0.0583878048f, -0.00379929971f, -0.505545259f, -0.00692759873f, 0.337996185f,
+    0.902047038f, -0.94603461f, -0.21830985f, -0.599938452f, -0.888921797f, 0.688468397f,
+    -0.188705578f, 0.92974025f, -0.780637205f, -0.235715985f, 0.45660913f, -0.989865303f,
+    0.791882813f, -0.497142255f, -0.302497864f, 0.442630887f, 0.641848624f, -0.265787929f,
+    0.0989780053f, 0.942658007f, -0.155144274f, 0.329507917f, -0.159690931f, -0.930403709f,
+    0.580709279f, 0.43271634f, -0.689271092f, 0.805132747f, -0.876943827f, -0.0411783978f,
+    -0.410789937f, -0.636752725f, 0.783403754f, -0.401060015f, -0.791272521f, -0.915467978f,
+    -0.176829249f, -0.568068087f, 0.904920459f, 0.627230346f, -0.700590312f, -0.529507458f,
+    -0.124803089f, 0.870706677f, 0.42611745f, -0.297811657f, 0.822351515f, -0.153527156f,
+    -0.943811238f, -0.604560792f, 0.93455869f, -0.347095758f, 0.112625808f, 0.486994773f,
+    -0.298850149f, -0.823922157f, -0.810459971f, 0.703464806f, -0.0915978029f, 0.661120832f,
+    -0.484329045f, -0.691640615f, -0.0205265526f, -0.539712727f, -0.0116269821f, -0.797396719f,
+    0.241158903f, -0.825896442f, -0.918505669f, 0.0962141901f, 0.0585357323f, -0.357994884f,
+    -0.0324462354f, 0.206265211f, -0.844259083f, -0.709561467f, -0.59968406f, -0.501328707f,
+    -0.0734656826f, -0.492419034f, -0.0337110087f, 0.711719573f, -0.862565875f, 0.262971193f,
+    -0.00601764955f, 0.493334174f, 0.809990048f, 0.675127506f, -0.184053496f, 0.716238737f,
+    0.881085992f, 0.404967666f, -0.619382918f, -0.816323161f, 0.480891347f, 0.177390024f,
+    0.778069854f, 0.483811021f, 0.0546362884f, -0.909313858f, 0.197275847f, 0.902047634f,
+    -0.301558763f, -0.916257501f, -0.50358969f, -0.361879647f, 0.775484562f, -0.302968651f,
+    -0.281435639f, -0.667331696f, -0.0822955146f, -0.931411743f, -0.773647726f, -0.724018514f,
+    -0.527748525f, -0.883238912f, -0.527844846f, -0.735727847f, 0.731687009f, -0.558416843f,
+    0.873455703f, 0.164568558f, -0.934993327f, -0.821770906f, 0.960512877f, -0.90494138f,
+    -0.8700791f, 0.288450867f, -0.368837833f, 0.493435085f, -0.638589442f, -0.320239425f,
+    0.416816473f, -0.0219805911f, 0.986348331f, 0.123960517f, 0.422348201f, -0.0480363034f,
+    0.522423208f, -0.0089535946f, -0.993849516f, -1.14395516e-05f, -0.643473744f, -0.653572261f,
+    0.0703056082f, 0.554989636f, 0.33693254f, -0.782115877f, 0.116378173f, -0.603717744f,
+    0.875346601f, -0.355131954f, -0.104167536f, -0.537200451f, 0.149042055f, -0.972279429f,
+    -0.239517212f, 0.303448707f, 0.873861253f, -0.508460581f, -0.176836759f, -0.48249796f,
+    0.182100505f, -0.41633296f, 0.404736906f, -0.397265434f, -0.502414107f, -0.931331038f,
+    -0.272922635f, -0.397868365f, -0.64912051f, -0.665632427f, 0.00117737928f, -0.00565352337f,
+    0.538237035f, 0.824559331f, -0.269188195f, -0.223374128f, -0.593885601f, -0.864214659f,
+    -0.665883899f, 0.668813944f, 0.937064469f, -0.0283864476f, 0.154441938f, 0.888999879f,
+    0.14054729f, -0.146236226f, 0.37343055f, 0.257531613f, -0.822112978f, -0.700073898f,
+    0.269395143f, -0.703027606f, 0.701969445f, -0.354960114f, -0.552005351f, 0.286230296f,
+    -0.827233613f, 0.973902166f, -0.48132661f, -0.459963918f, -0.409205794f, -0.869741142f,
+    0.231300488f, -0.839732409f, 0.630746365f, -0.0800361708f, 0.878634453f, 0.358682364f,
+    0.730900288f, 0.106800489f, 0.355393767f, -0.0758855045f, -0.492360264f, 0.33536914f,
+    -0.611841142f, -0.294357985f, -0.645904601f, 0.882052064f, -0.862050593f, -0.10471347f,
+    -0.334939778f, 0.909304738f, 0.833498538f, -0.913400769f, 0.88210845f, 0.182250723f,
+    0.0620691031f, 0.702380478f, -0.703502178f, -0.864318728f, -0.81970495f, 0.492138445f,
+    -0.666373253f, 0.529805779f, -0.179101631f, -0.519390345f, 0.875531733f, 0.458116353f,
+    -0.981767058f, -0.053171169f, 0.341363847f, -0.639493525f, 0.220040128f, -0.265855372f,
+    -0.455948949f, 0.903382897f, 0.828637719f, 0.914034963f, -0.706364572f, -0.319826186f,
+    -0.687684655f, 0.119296044f, -0.124130271f, 0.702019095f, 0.298043758f, -0.1931777f,
+    0.494517148f, -0.254561752f, -0.766038656f, 0.948108733f, -0.691038609f, 0.726001799f,
+    0.754650772f, 0.803919852f, 0.641325772f, 0.285088688f, -0.806257069f, -0.122385405f,
+    0.258711994f, -0.895498216f, -0.0463002287f, 0.639431775f, -0.0539364628f, 0.0300706439f,
+    -0.96140188f, 0.192293197f, -0.663049102f, 0.140383333f, 0.00747140544f, 0.660288692f,
+    -0.327001095f, -0.722074747f, -0.403139919f, -0.386532098f, 0.919075608f, 0.111142494f,
+    -0.980725527f, 0.0555243604f, -0.545608521f, 0.320075929f, -0.591808021f, -0.892464638f,
+    -0.492364645f, -0.522760034f, -0.223590642f, 0.887056291f, -0.971833587f, 0.723912954f,
+    0.472589612f, -0.238880008f, 0.722921193f, 0.48664996f, -0.520816088f, -0.434548199f,
+    0.267073214f, -0.612897933f, -0.396684468f, -0.143489823f, 0.224863455f, 0.689730465f,
+    -0.308695883f, 0.548589051f, -0.304378718f, -0.0357798152f, -0.411667407f, 0.718207896f,
+    -0.297547072f, 0.000986316008f, -0.943853736f, -0.449847907f, -0.408327311f, 0.874787986f,
+    -0.501193106f, 0.982360244f, 0.430197537f, -0.655460835f, 0.942547381f, -0.993410766f,
+    -0.535207391f, -0.100502059f, 0.533712804f, -0.349754363f, 0.591300726f, -0.768489838f,
+    -0.124449186f, 0.345982611f, 0.655638158f, -0.290880352f, -0.143933862f, -0.215075985f,
+    -0.191774935f, 0.490774632f, 0.0945246443f, 0.00453419564f, -0.386971563f, -0.736889243f,
+    -0.329574883f, -0.724014103f, -0.141463071f, -0.467996508f, -0.0383479968f, 0.577959597f,
+    0.652395189f, -0.140461236f, 0.520418048f, 0.0243188255f, 0.623271644f, -0.910567462f,
+    -0.428225458f, 0.381363124f, -0.464914262f, 0.0101648197f, -0.16952987f, -0.362091571f,
+    0.831232488f, 0.0185441021f, 0.307731926f, 0.447813511f, -0.36042735f, 0.79404366f,
+    0.0329005457f, 0.42293492f, 0.514406323f, -0.114606038f, -0.679778874f, -0.973257601f,
+    0.186292887f, -0.647377074f, -0.42895332f, 0.0549345016f, -0.0561264418f, -0.739359319f,
+    -0.0358769223f, 0.963858485f, 0.129242077f, -0.228044555f, -0.337626636f, 0.0321004242f,
+    0.732962132f, -0.890978098f, -0.714368522f, -0.673371792f, 0.412768781f, -0.784442365f,
+    -0.687978745f, -0.277316093f, -0.0986774936f, 0.964383304f, -0.775097609f, -0.727723718f,
+    -0.869733632f, 0.632551134f, 0.46483317f, 0.839725018f, -0.161288172f, 0.849552453f,
+    -0.752112687f, 0.962865055f, -0.331879675f, 0.965615809f, -0.176101357f, 0.439368516f,
+    -0.570779204f, 0.378893942f, 0.741913557f, 0.890914679f, -0.498161554f, -0.545576334f,
+    -0.567086577f, 0.276379704f, 0.728148937f, -0.553922355f, 0.392695218f, -0.325278461f,
+    0.166492149f, 0.932845294f, -0.109085485f, -0.793538451f, -0.235997617f, -0.367360145f,
+    -0.556678772f, -0.167751297f, -0.354348868f, 0.0334040076f, -0.218434155f, 0.565596044f,
+    -0.137011096f, 0.69476074f, -0.32503134f, -0.0123963905f, 0.0707222819f, 0.741750598f,
+    -0.584503293f, -0.579120576f, 0.90900147f, -0.457193106f, 0.181224421f, -0.438228786f,
+    -0.857761621f, -0.0959780216f, 0.00555319712f, -0.322727621f, -0.489272654f, 0.179618508f,
+    -0.0379805975f, 0.274013132f, 0.953474045f, 0.971197724f, 0.953691483f, 0.933085501f,
+    0.650046229f, 0.269271404f, 0.907815635f, -0.38910383f, -0.613035083f, -0.918107629f,
+    -0.577474713f, -0.600769877f, -0.234537214f, -0.824819088f, -0.243412316f, 0.14398478f,
+    0.848632455f, 0.99636364f, -0.856326878f, 0.0326981619f, -0.601738393f, -0.558224559f,
+    0.430405438f, 0.323531717f, -0.429225892f, -0.409847707f, 0.795764446f, 0.133160427f,
+    -0.501380146f, 0.623842597f, 0.593056917f, -0.632394254f, -0.815503538f, -0.455209076f,
+    0.229710639f, 0.551048934f, -0.213831842f, -0.913965762f, -0.835127831f, -0.463369727f,
+    -0.967007875f, 0.858634472f, 0.467862815f, 0.606572449f, -0.217401937f, 0.0829433352f,
+    0.152079567f, 0.580194473f, -0.369087696f, 0.354298651f, 0.784428179f, -0.174100742f,
+    -0.0802544728f, 0.932255387f, -0.588315725f, 0.585127592f, 0.283883154f, -0.42905733f,
+    -0.713262081f, 0.963519514f, -0.242165208f, -0.856915057f, -0.454703897f, 0.757893503f,
+    0.434563518f, 0.562741876f, 0.695122719f, -0.324903011f, 0.211104468f, -0.508305848f,
+    -0.258333087f, 0.767482102f, -0.953962445f, -0.395634234f, -0.120563492f, 0.158053234f,
+    0.324620575f, -0.738349736f, 0.458012074f, -0.177571788f, -0.911731243f, 0.682007909f,
+    0.0160745662f, 0.887923479f, 0.093177788f, 0.835270822f, 0.961898088f, -0.723001361f,
+    -0.515813947f, 0.726935387f, -0.887200832f, -0.637445629f, -0.658868909f, 0.298828721f,
+    0.927532434f, 0.990013957f, 0.224245369f, -0.813162088f, 0.490589827f, 0.684311748f,
+    -0.859098554f, 0.343778044f, 0.613211572f, -0.857847035f, 0.96625942f, -0.116473846f,
+    -0.955738723f, -0.0246495791f, 0.888798535f, 0.254862398f, 0.165388659f, -0.582951307f,
+    0.592332125f, -0.495134413f, -0.617676914f, -0.481459439f, -0.317306668f, -0.182471976f,
+    -0.49598223f, 0.5677163f, -0.0236797743f, -0.719984293f, 0.815454781f, 0.780694187f,
+    -0.189039499f, -0.926456749f, 0.496238738f, -0.042083472f, -0.0967170745f, -0.000372656534f,
+    0.665450871f, -0.947831988f, -0.632317066f, -0.729888201f, 0.343179703f, -0.570666254f,
+    0.109800056f, -0.0652701408f, -0.561995029f, -0.745795071f, 0.858986616f, -0.79605633f,
+    -0.947326481f, -0.202462494f, 0.514031947f, 0.762823045f, -0.854705572f, -0.382442832f,
+    -0.201941505f, 0.225334287f, 0.249152675f, 0.00740698073f, 0.662903666f, -0.700594008f,
+    -0.0168926436f, -0.262907177f, 0.99076283f, 0.887361228f, 0.745551705f, -0.433128297f,
+    -0.612270176f, -0.236581266f, -0.2892102f, -0.907205224f, -0.0560479239f, -0.552974284f,
+    0.684755981f, 0.583379507f, 0.182493925f, -0.188876837f, -0.305159092f, -0.727936924f,
+    0.461262584f, 0.719366074f, 0.638040066f, -0.539138913f, 0.0905777141f, -0.647743881f,
+    0.359374404f, 0.429888189f, 0.244362354f, -0.0558092333f, -0.528136551f, -0.917826414f,
+    0.967492104f, -0.865828335f, -0.53673166f, -0.0128701292f, -0.241893306f, -0.00550135039f,
+    0.112199806f, -0.474361777f, 0.460950255f, -0.0180863533f, 0.825790167f, -0.0264319517f,
+    0.198049784f, -0.0892901719f, -0.958693027f, -0.161888257f, 0.329767346f, -0.440829247f,
+    0.582257152f, 0.171040893f, -0.376586556f, 0.779869378f, 0.554439187f, 0.548675239f,
+    0.203373984f, -0.667976618f, 0.156732365f, -0.598846257f, -0.173055202f, -0.550640941f,
+    0.403533489f, -0.451680511f, -0.701517403f, -0.956956685f, 0.349287421f, -0.634854555f,
+    -0.612427294f, 0.72932297f, 0.969456494f, -0.381965041f, -0.177108407f, 0.210817218f,
+    -0.786487818f, 0.0672347769f, 0.446134955f, -0.0101683466f, -0.482091218f, 0.768426657f,
+    -0.343624979f, -0.894587994f, -0.251465023f, -0.372671127f, -0.872144639f, -0.948442876f,
+    0.56575793f, -0.322190702f, 0.722628832f, -0.187490344f, -0.210733354f, 0.121665977f,
+    -0.107845478f, -0.804186523f, 0.122883812f, 0.336668879f, -0.782053232f, -0.604694128f,
+    0.985827565f, -0.447843611f, 0.889543176f, 0.722164571f, 0.324294001f, 0.590263128f,
+    0.61226815f, -0.704242468f, -0.1236232f, -0.976520777f, 0.726461112f, -0.0452342778f,
+    0.0358341858f, 0.190725669f, 0.220276967f, -0.863414586f, 0.886121035f, -0.816163599f,
+    -0.453192174f, -0.915276885f, -0.487943888f, -0.867855012f, -0.900240421f, -0.861271679f,
+    0.574255884f, 0.530365348f, -0.653993309f, 0.828795671f, -0.660338104f, 0.539739132f,
+    -0.182999015f, 0.211071432f, 0.384243906f, 0.907887578f, -0.458007246f, 0.394965947f,
+    0.00677952077f, -0.670250416f, 0.531723857f, 0.454074144f, 0.717046916f, 0.407383353f,
+    -0.0143350493f, -0.992960453f, -0.583800077f, -0.816970587f, -0.688885093f, -0.773801506f,
+    0.0964580402f, -0.616267681f, 0.377564788f, 0.284178376f, -0.35415259f, -0.695903182f,
+    0.694086432f, -0.539641201f, 0.979336023f, 0.993831336f, -0.671115875f, 0.154715508f,
+    -0.765540898f, 0.082364589f, 0.24742353f, 0.690419495f, -0.118492998f, -0.107426204f,
+    -0.0419934243f, -0.722062469f, 0.686463296f, -0.370819122f, -0.501624107f, -0.765201092f,
+    0.212403446f, 0.677052975f, -0.380889386f, 0.290220052f, -0.210931867f, 0.154031187f,
+    0.881552577f, 0.869880438f, 0.201034948f, -0.500152171f, -0.437133104f, -0.790143907f,
+    0.491448104f, 0.855941117f, -0.780121267f, 0.140447006f, 0.744911909f, 0.0539710708f,
+    0.718794107f, -0.0942840204f, -0.595237076f, 0.625318527f, 0.843783975f, 0.102071524f,
+    0.255439132f, -0.445459932f, 0.82873702f, 0.395231903f, -0.549256921f, -0.753961623f,
+    0.100530565f, 0.976113141f, -0.728007793f, -0.729594111f, -0.0788840353f, 0.418267757f,
+    0.173228219f, -0.348651618f, -0.154606462f, -0.992620885f, 0.976913452f, -0.672633648f,
+    0.839792252f, -0.0114162713f, 0.515293777f, -0.280296266f, 0.356225014f, 0.0824660659f,
+    0.452823579f, 0.127319381f, -0.765553057f, -0.500296474f, 0.0980434567f, -0.403303325f,
+    0.0551571958f, 0.790283144f, -0.293591619f, -0.829916954f, -0.440141201f, -0.6621961f,
+    -0.131313592f, 0.0684195086f, 0.767488599f, -0.169465631f, -0.0509110354f, -0.62286377f,
+    0.488945395f, -0.0211101901f, 0.84392941f, 0.317712575f, -0.424373746f, -0.921000183f,
+    0.443885714f, 0.635558605f, 0.222577646f, -0.201102957f, 0.122681953f, 0.45454964f,
+    -0.827560425f, -0.342049211f, 0.0710614547f, -0.500101447f, 0.228633806f, -0.089948304f,
+    0.0704330653f, -0.526777506f, -0.244558394f, 0.602720499f, 0.764450967f, -0.886710346f,
+    0.42694667f, -0.697682798f, -0.276608467f, -0.0514445491f, -0.696797669f, -0.679274499f,
+    -0.665433109f, -0.289157361f, -0.378788501f, -0.804921567f, 0.744291484f, 0.782504022f,
+    0.383738488f, 0.0126690343f, 0.623795331f, 0.129029319f, -0.180661857f, -0.164054692f,
+    0.554745018f, -0.666632235f, 0.927500784f, 0.603905022f, -0.297074586f, -0.970727265f,
+    0.883641422f, 0.346000075f, -0.995219529f, -0.448490918f, 0.375789821f, 0.467411697f,
+    0.481147587f, 0.322456717f, 0.92500174f, -0.309068114f, 0.266339272f, 0.324339479f,
+    -0.613671005f, -0.196475103f, -0.732795954f, -0.637442172f, -0.0318615772f, -0.604091942f,
+    0.866285622f, 0.710266113f, -0.723850369f, 0.435508758f, 0.700927317f, 0.657577991f,
+    0.826343179f, 0.515150249f, 0.883110106f, 0.256276459f, 0.0340407342f, 0.623913765f,
+    0.812401712f, 0.0485647395f, -0.981998265f, 0.73750478f, -0.486126214f, 0.427631557f,
+    -0.806349099f, 0.641051412f, 0.133881703f, -0.956251025f, 0.846652269f, -0.245674759f,
+    0.417045861f, 0.838639438f, 0.924803555f, 0.0971125737f, -0.515757263f, -0.971353114f,
+    0.736013532f, -0.450364053f, -0.378550678f, -0.235952213f, -0.341946602f, -0.00626225956f,
+    -0.929018915f, 0.464069843f, 0.910777867f, 0.924993277f, -0.265816003f, 0.868276775f,
+    -0.347113013f, 0.695370972f, -0.169319227f, -0.997673929f, 0.00157942763f, 0.714707136f,
+    -0.427484334f, 0.395409852f, -0.622131407f, -0.35546875f, -0.969151556f, 0.904441595f,
+    -0.735434949f, -0.130199686f, -0.576285779f, -0.997442245f, 0.897611797f, 0.799679279f,
+    -0.596539736f, 0.150557935f, 0.168966055f, 0.61713928f, -0.295297623f, 0.97691679f,
+    0.63490814f, -0.175155401f, -0.632708073f, -0.594675481f, 0.239848867f, -0.906032801f,
+    -0.908401847f, 0.829251409f, 0.852821231f, -0.0517150536f, -0.697992086f, 0.185090601f,
+    -0.460062385f, 0.995729327f, 0.816603839f, 0.7649014f, -0.172327757f, 0.595879674f,
+    0.294686645f, 0.396704912f, -0.639880955f, 0.265911996f, -0.372359544f, 0.885718882f,
+    0.299897999f, -0.70558089f, -0.938837469f, -0.32744047f, -0.479809493f, 0.921838701f,
+    0.0789658353f, -0.716840446f, 0.599175215f, 0.0540099964f, -0.446509808f, -0.224521264f,
+    0.837692797f, -0.535917342f, 0.645763457f, 0.938655734f, -0.295256525f, 0.265445232f,
+    0.653685451f, -0.356384367f, -0.357332677f, -0.592400908f, 0.115206897f, 0.759637356f,
+    -0.117935576f, -0.700270414f, 0.578887045f, -0.257243186f, -0.408169389f, 0.373097867f,
+    -0.539081335f, -0.781001806f, -0.393252254f, -0.850975037f, 0.812074959f, 0.415892094f,
+    -0.702043891f, 0.490653783f, -0.955769062f, -0.648892522f, 0.106807366f, 0.872371554f,
+    0.647874236f, 0.667772055f, -0.928890884f, 0.53993243f, 0.998205125f, -0.148712799f,
+    0.0490203053f, -0.0895423517f, 0.59640187f, -0.140957072f, 0.0225467123f, 0.451385856f,
+    0.474679261f, 0.289842963f, 0.522495687f, -0.0104595441f, 0.8692801f, -0.474449992f,
+    0.671904564f, 0.338569611f, -0.584738553f, 0.413220286f, 0.8631441f, 0.569939733f,
+    -0.384414375f, 0.295204759f, -0.325802445f, 0.103663094f, -0.719731987f, 0.688935578f,
+    0.126079708f, -0.413026631f, 0.1232014f, 0.568445623f, -0.514812648f, 0.600414753f,
+    -0.568773448f, -0.511427402f, -0.857745945f, -0.995874524f, 0.814939976f, -0.237075478f,
+    -0.793269992f, -0.0357495248f, 0.246977478f, 0.357779056f, 0.408150345f, 0.303857028f,
+    -0.108057439f, 0.986823559f, 0.770827413f, -0.893310964f, 0.974473953f, -0.219991833f,
+    -0.932451427f, -0.547587335f, -0.56883347f, 0.186620563f, 0.0578114651f, -0.0192705076f,
+    -0.745992601f, -0.321849048f, 0.187929779f, -0.640306294f, -0.146982729f, 0.961254776f,
+    -0.253002614f, 0.794674754f, -0.0928859189f, -0.167841032f, -0.362263501f, -0.680279493f,
+    -0.474707901f, -0.573315859f, -0.497019053f, 0.283422679f, 0.149965808f, 0.386130899f,
+    -0.506473362f, -0.142459646f, -0.817872763f, -0.391907007f, 0.798839808f, 0.581102848f,
+    -0.643503428f, -0.585311353f, 0.259041369f, -0.568018615f, -0.427942961f, -0.974124491f,
+    0.281832218f, -0.940046966f, -0.745998681f, 0.577992499f, -0.805703461f, -0.798520088f,
+    0.805393875f, -0.144406542f, 0.547562838f, 0.0292769354f, -0.579855561f, 0.780176699f,
+    -0.363996774f, 0.642685413f, -0.159339353f, 0.625730813f, -0.378759027f, 0.785443068f,
+    -0.426413804f, -0.975127935f, 0.601090193f, 0.287600845f, 0.644324183f, 0.457957327f,
+    -0.279855043f, 0.893709183f, -0.50762254f, -0.426562279f, -0.860616982f, 0.443528026f,
+    0.716169655f, 0.966525197f, 0.575016439f, -0.895945489f, 0.520718634f, -0.655269802f,
+    -0.214975789f, 0.452823937f, -0.0593072101f, 0.0556870624f, 0.0632084236f, -0.046004124f,
+    -0.350785553f, 0.401339948f, -0.36076802f, -0.77877897f, 0.353538781f, 0.281359762f,
+    -0.224272892f, -0.739543915f, -0.246133745f, -0.278106213f, -0.93339479f, 0.725668669f,
+    -0.907823563f, 0.339325517f, 0.785479307f, 0.419154793f, 0.254562616f, -0.961969435f,
+    0.772136688f, -0.799667358f, -0.461450785f, -0.555185914f, -0.522636235f, -0.0551575795f,
+    -0.0680294707f, -0.598838389f, -0.104973614f, 0.183747217f, -0.235735953f, -0.0701962858f,
+    0.602394283f, 0.601552606f, 0.492885262f, -0.266476959f, 0.227826431f, 0.594261765f,
+    -0.0527422689f, -0.615923226f, -0.456438392f, -0.760217667f, -0.488122344f, 0.450997144f,
+    -0.37659651f, 0.344034076f, 0.881575286f, -0.0587594062f, 0.625887632f, -0.321576089f,
+    0.684395552f, -0.447248459f, -0.091456078f, -0.335566998f, 0.746805668f, 0.722156823f,
+    -0.194050491f, -0.26839292f, 0.970980287f, 0.126672283f, -0.326740593f, 0.118150465f,
+    -0.821358025f, 0.0812464803f, 0.502369523f, -0.618955433f, -0.138458207f, 0.268344283f,
+    0.566957951f, 0.965039611f, -0.0222271383f, -0.143107235f, 0.589925051f, 0.260657459f,
+    0.770720243f, 0.218270928f, 0.368955106f, 0.133749619f, -0.894425213f, -0.994660676f,
+    0.336319983f, -0.761974335f, -0.344766974f, -0.626741707f, -0.378914297f, 0.0387460105f,
+    0.545496166f, 0.459254652f, -0.134077027f, -0.00123895705f, -0.24855952f, 0.806274474f,
+    -0.884641171f, 0.592522442f, 0.958872557f, -0.490507692f, -0.842473924f, -0.23622781f,
+    -0.115091607f, 0.723730803f, 0.872487903f, -0.337016582f, 0.00603747414f, 0.748137057f,
+    0.365335017f, 0.300426275f, -0.270397931f, -0.952898979f, -0.822328627f, -0.744376421f,
+    0.0444082916f, -0.0673045367f, -0.808664203f, 0.150518805f, -0.0599045791f, 0.411355406f,
+    0.10695269f, -0.673379302f, 0.777512014f, 0.441189796f, 0.0973064601f, 0.300955892f,
+    -0.0148845725f, 0.101192407f, 0.230301082f, -0.0580162033f, 0.818298757f, -0.403556645f,
+    0.326709449f, -0.363315314f, 0.840153337f, -0.0809917375f, -0.80554992f, -0.75404048f,
+    0.603936315f, -0.822441995f, 0.140125781f, 0.146385506f, 0.77488333f, -0.772530317f,
+    0.0572138131f, -0.736290097f, 0.512420475f, -0.437232405f, -0.633567572f, -0.474959761f,
+    0.206651255f, 0.0475398749f, -0.0264213644f, -0.192420289f, 0.113763958f, 0.325974941f,
+    -0.899327993f, 0.241881505f, 0.657922804f, -0.942134857f, -0.55213964f, 0.521012425f,
+    0.938171446f, 0.755684793f, -0.484503806f, 0.632578194f, -0.502667487f, 0.696449816f,
+    -0.929866433f, -0.969213128f, -0.682180166f, -0.769904971f, -0.708575606f, -0.500246048f,
+    0.960924864f, 0.664584816f, 0.0139950402f, 0.116550364f, 0.880957961f, -0.73967278f,
+    -0.86199218f, 0.838810861f, 0.604958117f, 0.652494431f, -0.434487373f, -0.1451547f,
+    0.635829508f, 0.706202149f, 0.530714035f, -0.517022431f, 0.27138865f, -0.746941864f,
+    -0.905387044f, 0.16648829f, -0.142741576f, 0.220500365f, 0.693968117f, -0.735212386f,
+    0.0595797896f, -0.62973088f, 0.414073437f, 0.587941349f, -0.0172692556f, 0.614603102f,
+    0.18244186f, 0.1119176f, 0.57420373f, 0.523164392f, -0.67768842f, -0.978566647f,
+    0.498784095f, 0.315695852f, 0.260400027f, -0.938050568f, 0.311278015f, -0.144413501f,
+    -0.847419679f, -0.696124315f, -0.863512576f, -0.32145378f, -0.9658705f, -0.26218456f,
+    -0.171995133f, -0.542510808f, -0.611896574f, 0.353710294f, -0.0388905779f, 0.508852124f,
+    0.59423399f, 0.928830206f, -0.710915685f, -0.477990001f, -0.614429295f, -0.0800385103f,
+    -0.465080827f, -0.546537697f, 0.888980389f, -0.836846173f, 0.715462506f, -0.810250521f,
+    0.402560949f, -0.0779553801f, -0.500538707f, -0.231870711f, 0.277534246f, -0.372111201f,
+    -0.10426946f, -0.70127517f, -0.947068512f, 0.302837074f, -0.423752666f, 0.448531151f,
+    -0.620286644f, -0.141739443f, 0.431930244f, -0.444008887f, -0.577993035f, -0.817499578f,
+    0.388856918f, 0.545489669f, -0.748917997f, 0.0221000165f, -0.469173551f, 0.150017142f,
+    -0.129287034f, -0.000284350652f, -0.437615722f, 0.933872283f, 0.500932038f, 0.613266528f,
+    -0.369297713f, -0.715939999f, -0.456580281f, 0.9081707f, 0.489353895f, 0.774365544f,
+    -0.895226002f, 0.0242404621f, -0.924992204f, 0.662464559f, -0.696553707f, 0.438059986f,
+    0.683207273f, -0.263170242f, 0.599769413f, -0.742880166f, -0.0885479599f, 0.219581395f,
+    -0.734541118f, -0.0302689746f, -0.217408583f, 0.449841827f, 0.988265932f, -0.36162135f,
+    0.0499313399f, -0.349356979f, -0.490446866f, -0.479046911f, 0.00103643502f, 0.0203086771f,
+    0.0836522132f, 0.833673298f, -0.254181296f, -0.397835255f, -0.1013432f, -0.603428125f,
+    0.477532536f, -0.473717004f, 0.471799105f, -0.698756754f, -0.462811023f, 0.697889149f,
+    -0.651684999f, 0.462758929f, 0.21504201f, -0.493808597f, 0.325125903f, 0.215719804f,
+    -0.370944679f, -0.844619036f, 0.62076664f, -0.0691414773f, -0.62247622f, 0.460902929f,
+    -0.710050464f, -0.120210268f, -0.681862593f, -0.169625431f, 0.897434831f, -0.164054453f,
+    -0.620151401f, -0.264252752f, -0.58250612f, 0.82169497f, -0.239925668f, 0.00326726097f,
+    0.140361026f, -0.0249597207f, -0.075494118f, 0.994657159f, -0.758639097f, -0.604529202f,
+    0.374315202f, -0.674753845f, -0.0956221819f, 0.00258761249f, -0.616036415f, 0.775572419f,
+    -0.465930074f, 0.551185191f, 0.859060228f, -0.437565953f, -0.404643774f, -0.612022579f,
+    0.122619085f, 0.729902327f, -0.991683424f, 0.765862226f, 0.618853867f, 0.605316997f,
+    -0.834286213f, 0.295803696f, -0.25775212f, 0.203963727f, 0.381071568f, -0.0218001008f,
+    0.109864682f, 0.517813385f, 0.210974023f, -0.241836205f, 0.0617124811f, 0.216534272f,
+    -0.869747996f, 0.0589436926f, -0.54329282f, 0.734859586f, -0.768472373f, -0.391185075f,
+    0.0769007429f, 0.546257854f, -0.924729347f, 0.642745137f, 0.526991844f, -0.185970396f,
+    -0.505453408f, -0.474119276f, 0.857300103f, -0.604996085f, 0.394055694f, -0.530682087f,
+    0.821551621f, 0.767290473f, -0.803913891f, 0.794395089f, -0.907617033f, 0.802809954f,
+    -0.857756197f, -0.422225982f, -0.93331778f, 0.144011378f, -0.260888696f, -0.355536133f,
+    -0.698919654f, 0.187784955f, 0.278046519f, -0.718733549f, -0.761298895f, -0.179830447f,
+    -0.909738183f, -0.00152689009f, -0.253133029f, -0.292887956f, -0.0229266081f, -0.9116593f,
+    -0.648449659f, -0.152344167f, -0.560146868f, 0.155068174f, -0.582673073f, 0.503841758f,
+    -0.670379221f, -0.750768125f, -0.830568016f, 0.902332306f, -0.339320898f, 0.1282278f,
+    -0.360994637f, 0.0257465839f, 0.904948294f, -0.387682527f, 0.370026946f, -0.61904943f,
+};
+
+inline constexpr float kH3CondAudioNoiseRows[] = {
+    -0.232232243f, -0.87013483f, 2.81512237f, 0.701163113f, 1.73194969f, -0.846551001f,
+    -0.436361432f, -0.311510473f, -0.549960554f, -0.358996242f, 0.626790226f, -0.943315804f,
+    0.116775021f, 0.101837426f, -1.11584353f, 2.31848311f, -0.0235775635f, -1.11699855f,
+    -0.312161505f, 0.089027606f, 0.558793247f, -0.259660333f, -0.0257192664f, -1.58342779f,
+    0.72372669f, -0.668247223f, 0.448859215f, -1.06576908f, 0.402738035f, 1.25684214f,
+    -0.652204812f, 1.06246483f, 0.422729522f, 1.53214991f, 0.435911924f, -1.93430817f,
+    -0.0716397762f, 0.0782210827f, -2.01838326f, 0.714629829f, -2.74713016f, 0.101901963f,
+    -0.488095343f, -0.0864038244f, 0.465998262f, -0.648765683f, -0.983644843f, 0.36971429f,
+    -0.91984731f, 0.737726748f, 1.18366325f, -1.90227997f, 0.16555801f, 1.03130984f,
+    1.51006043f, -0.0722367838f, 1.15584838f, -0.252246678f, -3.07886672f, -1.37700915f,
+    -0.6624192f, 1.84875333f, -0.862612128f, -0.776827157f, 0.280766428f, -0.771513581f,
+    -0.691236019f, 0.0327784605f, -0.660253346f, -0.974951148f, 1.00088775f, 0.157816768f,
+    0.362437755f, -1.62513185f, -1.19465387f, -0.993975282f, -1.7271446f, -0.783111095f,
+    1.38733351f, 0.591340125f, 0.152643025f, -0.349289834f, 1.00990367f, -0.0210154001f,
+    0.960879028f, -0.710947812f, -1.6482656f, 0.134246767f, -0.704308987f, 0.263697475f,
+    0.293090135f, 0.605342984f, -0.667779267f, 0.818977594f, -0.289674401f, 0.644356668f,
+    -0.401830405f, 0.114333697f, 0.30052045f, -0.537073135f, -0.890316367f, -0.205786645f,
+    -0.454772562f, -1.19692111f, 0.708384871f, 1.24815261f, 0.560065329f, -0.841548204f,
+    0.140113488f, -0.742740214f, -1.34181929f, -0.46600771f, -0.52457118f, 1.72944403f,
+    0.227655068f, 1.42888188f, 0.964678884f, 0.282213867f, 0.519491553f, 1.30080283f,
+    -1.33125186f, 0.454993725f, -2.01592302f, -1.00069904f, 1.19966686f, -0.0344661772f,
+    -0.0439754389f, 0.613338053f, -0.232232243f, -0.87013483f, 2.81512237f, 0.701163113f,
+    1.73194969f, -0.846551001f, -0.436361432f, -0.311510473f, -0.549960554f, -0.358996242f,
+    0.626790226f, -0.943315804f, 0.116775021f, 0.101837426f, -1.11584353f, 2.31848311f,
+    -0.0235775635f, -1.11699855f, -0.312161505f, 0.089027606f, 0.558793247f, -0.259660333f,
+    -0.0257192664f, -1.58342779f, 0.72372669f, -0.668247223f, 0.448859215f, -1.06576908f,
+    0.402738035f, 1.25684214f, -0.652204812f, 1.06246483f, 0.422729522f, 1.53214991f,
+    0.435911924f, -1.93430817f, -0.0716397762f, 0.0782210827f, -2.01838326f, 0.714629829f,
+    -2.74713016f, 0.101901963f, -0.488095343f, -0.0864038244f, 0.465998262f, -0.648765683f,
+    -0.983644843f, 0.36971429f, -0.91984731f, 0.737726748f, 1.18366325f, -1.90227997f,
+    0.16555801f, 1.03130984f, 1.51006043f, -0.0722367838f, 1.15584838f, -0.252246678f,
+    -3.07886672f, -1.37700915f, -0.6624192f, 1.84875333f, -0.862612128f, -0.776827157f,
+    0.280766428f, -0.771513581f, -0.691236019f, 0.0327784605f, -0.660253346f, -0.974951148f,
+    1.00088775f, 0.157816768f, 0.362437755f, -1.62513185f, -1.19465387f, -0.993975282f,
+    -1.7271446f, -0.783111095f, 1.38733351f, 0.591340125f, 0.152643025f, -0.349289834f,
+    1.00990367f, -0.0210154001f, 0.960879028f, -0.710947812f, -1.6482656f, 0.134246767f,
+    -0.704308987f, 0.263697475f, 0.293090135f, 0.605342984f, -0.667779267f, 0.818977594f,
+    -0.289674401f, 0.644356668f, -0.401830405f, 0.114333697f, 0.30052045f, -0.537073135f,
+    -0.890316367f, -0.205786645f, -0.454772562f, -1.19692111f, 0.708384871f, 1.24815261f,
+    0.560065329f, -0.841548204f, 0.140113488f, -0.742740214f, -1.34181929f, -0.46600771f,
+    -0.52457118f, 1.72944403f, 0.227655068f, 1.42888188f, 0.964678884f, 0.282213867f,
+    0.519491553f, 1.30080283f, -1.33125186f, 0.454993725f, -2.01592302f, -1.00069904f,
+    1.19966686f, -0.0344661772f, -0.0439754389f, 0.613338053f, -0.532442331f, -1.90725029f,
+    -1.46998537f, 0.70242691f, 1.25309098f, -0.492271423f, -0.0618992634f, 0.0238945093f,
+    -0.784365416f, 0.756897688f, 0.469543695f, -0.860825062f, -1.07296276f, 1.00123429f,
+    0.713763535f, -0.548255026f, 0.818922579f, -0.0287927426f, 0.437278479f, -0.11077641f,
+    -0.477410972f, -0.67662251f, -0.144806683f, -0.344874948f, -0.0720275864f, 0.459915549f,
+    0.0468702912f, 0.470587015f, -0.42125532f, -0.829775035f, 1.73453641f, -0.18068409f,
+    -0.478412986f, -0.445109099f, -0.338669151f, -1.74350607f, 0.506899178f, 1.00469089f,
+    0.707545102f, 0.0389067382f, 0.838778079f, -0.328094661f, -1.72536421f, 2.24138427f,
+    -0.519495249f, 1.27278101f, 1.304618f, 0.437058508f, -0.40266946f, 0.503555417f,
+    -0.0680214316f, -0.720567107f, 0.40618667f, 1.04849517f, 0.584725499f, -0.745890617f,
+    -0.228670716f, 0.589437842f, 1.07986605f, 0.266442984f, -0.340943098f, -1.7655884f,
+    0.115868241f, 0.972957492f,
+};
+
+inline constexpr float kH3CondAudioGolden[] = {
+    -0.415377617f, 0.952710032f, 0.850869417f, -0.87307477f, -0.723125041f, -0.616063356f,
+    -0.0230573434f, -0.827785373f, 0.640671015f, -0.404511154f, -0.96641022f, -0.222794592f,
+    -0.825677931f, 0.0418939516f, -0.831215858f, 0.882971466f, 0.237965122f, -0.914148927f,
+    0.928574085f, -0.484836489f, 0.34085682f, 0.00867388956f, -0.208941519f, -0.614958405f,
+    0.887994587f, -0.898862422f, -0.585723519f, 0.572048426f, -0.19867678f, -0.24168244f,
+    0.532558858f, 0.470686436f, -0.575649917f, -0.925315857f, 0.819261253f, 0.164609179f,
+    -0.685904384f, -0.937695682f, -0.536565363f, -0.857277632f, 0.606166482f, -0.73446703f,
+    -0.52275461f, -0.846220791f, 0.737881243f, -0.192797765f, 0.540871382f, 0.55338186f,
+    -0.50880897f, -0.849674642f, -0.691182673f, 0.86639154f, 0.144822299f, -0.350153595f,
+    -0.0335481726f, 0.545266807f, 0.0729809627f, -0.166484594f, 0.984723091f, 0.908671975f,
+    0.704199672f, -0.361607552f, -0.635014296f, 0.626313925f, -0.304408908f, 0.163406387f,
+    0.814016104f, -0.705076396f, 0.0948070511f, 0.443765253f, -0.586779654f, -0.617715061f,
+    0.543974876f, 0.142995477f, -0.295599192f, 0.248240769f, -0.879153669f, -0.670913041f,
+    -0.860533237f, 0.467713386f, 0.607648849f, -0.522050261f, 0.775767744f, 0.153855696f,
+    0.914014459f, 0.112500772f, -0.260481745f, -0.323169857f, 0.185303256f, 0.764734805f,
+    0.216473997f, -0.91957134f, -0.82070905f, -0.617330432f, 0.21656248f, 0.777814567f,
+    -0.0868391767f, 0.272209555f, -0.264975578f, 0.00977263227f, 0.987314105f, -0.220111743f,
+    0.0976882502f, 0.273672223f, -0.369862497f, -0.112635456f, -0.379100353f, 0.174218655f,
+    0.257057548f, -0.956159592f, 0.878090084f, 0.29406029f, -0.760452986f, -0.224427998f,
+    -0.739465296f, -0.90505302f, -0.703858197f, -0.348211408f, 0.637384355f, 0.91997081f,
+    0.26650247f, -0.446018189f, -0.866185129f, -0.545355082f, -0.232479647f, 0.495974153f,
+    -0.703152657f, -0.121961989f, -0.271697372f, 0.131493002f, 0.9524647f, -0.62985605f,
+    0.452956975f, -0.725747883f, -0.526967466f, -0.903488636f, -0.107440569f, 0.555659711f,
+    0.163444802f, 0.303586751f, 0.0860326812f, 0.981683552f, -0.541231632f, -0.978102684f,
+    -0.362191111f, -0.144591585f, -0.962682903f, -0.746710539f, -0.120849326f, 0.182471514f,
+    -0.672743976f, -0.991840243f, 0.471878141f, -0.66225487f, -0.235064685f, -0.21775499f,
+    0.272547454f, 0.6716277f, -0.714332581f, -0.798144579f, -0.49321714f, -0.0200693943f,
+    0.835061193f, -0.387117624f, 0.624168277f, -0.672460496f, 0.754244745f, 0.592185915f,
+    0.181354895f, 0.729043067f, -0.868849218f, -0.073103793f, 0.444486678f, -0.481487244f,
+    -0.308522075f, -0.675727189f, 0.0201969631f, -0.360571444f, 0.743547559f, 0.849825919f,
+    0.437520802f, 0.961593688f, -0.51394999f, 0.328257471f, 0.818314791f, 0.790166616f,
+    -0.857324243f, 0.731609464f, -0.736549795f, -0.952886105f, -0.961537004f, 0.050757505f,
+    0.111766353f, 0.251260281f, 0.788217664f, 0.745361865f, -0.200857341f, 0.0835313648f,
+    -0.946253359f, 0.854995012f, -0.975292921f, -0.432262808f, -0.136340454f, 0.243743107f,
+    -0.76170212f, 0.632826924f, 0.947420955f, -0.205897912f, -0.186095208f, -0.643861771f,
+    -0.456743509f, 0.102839045f, -0.104260303f, 0.93019557f, -0.670444787f, 0.109993711f,
+    -0.359706193f, -0.0327961668f, -0.784419656f, -0.432691216f, -0.0924026147f, -0.505182028f,
+    -0.50242579f, 0.411543071f, -0.213447556f, -0.309134424f, 0.200500146f, -0.199219853f,
+    0.3692801f, 0.522768557f, -0.220427364f, -0.0304305721f, 0.990132809f, -0.842747092f,
+    0.548643649f, 0.0323270075f, 0.822928965f, -0.541769445f, 0.305380046f, 0.610914111f,
+    0.644036293f, -0.845002949f, -0.102752261f, 0.802080691f, 0.843619525f, 0.85662812f,
+    -0.180491552f, 0.880937517f, 0.619813025f, -0.0240410361f, 0.81941855f, -0.73045373f,
+    -0.947191f, -0.225759774f, 0.526599824f, 0.168429196f, -0.214355603f, -0.511256456f,
+    0.311235368f, 0.384114444f, 0.810171366f, -0.310786515f, -0.904324889f, 0.182690784f,
+    -0.740924537f, 0.848167002f, 0.546213865f, -0.903746784f, 0.500112951f, 0.329281777f,
+    -0.634129941f, -0.115683347f, -0.229041144f, 0.973750114f, -0.254839748f, 0.13440679f,
+    -0.160941303f, -0.922347128f, 0.686215281f, -0.455421656f, -0.447096527f, -0.651655376f,
+    -0.693595052f, -0.126942411f, -0.563337207f, -0.558148265f, -0.0374843553f, 0.85335505f,
+    0.637519896f, -0.549617052f, -0.337285399f, 0.621603012f, -0.829061329f, 0.199093744f,
+    -0.384600073f, 0.35385707f, 0.768309832f, 0.229398459f, -0.217721447f, 0.150540382f,
+    0.148627371f, -0.036418777f, 0.668068945f, 0.148186103f, -0.758940876f, -0.882497728f,
+    -0.993454158f, -0.919954419f, -0.716453314f, -0.171228617f, -0.0598426051f, -0.474501222f,
+    0.277063847f, 0.764618695f, -0.28799352f, 0.583431721f, 0.182067394f, -0.585893393f,
+    0.256057024f, -0.757549047f,
+};
+
+// --- section 8: reference-video geometry + frame schedule ---
+inline constexpr int64_t kH3RefVidShapeCases = 5;
+inline constexpr int64_t kH3RefVidFrameCases = 4;
+
+inline constexpr int64_t kH3RefVidShapeInputs[] = {
+    1920, 1080, 1080, 1920, 1000, 1000, 3840, 1080, 800, 600,
+};
+
+inline constexpr int64_t kH3RefVidShapeGolden[] = {
+    1344, 768, 768, 1344, 768, 768, 1920, 544, 1024, 768,
+};
+
+inline constexpr int64_t kH3RefVidFrameCounts[] = {
+    13, 25, 100, 209,
+};
+
+inline constexpr int64_t kH3RefVidIndexLens[] = {
+    2, 3, 9, 18,
+};
+
+inline constexpr int64_t kH3RefVidIndicesGolden[] = {
+    0, 12, 0, 12, 24, 0, 12, 24, 36, 48, 60, 72,
+    84, 96, 0, 12, 24, 36, 48, 60, 72, 84, 96, 108,
+    120, 132, 144, 156, 168, 180, 192, 204,
+};
+
+inline constexpr int64_t kH3RefVidBlockLens[] = {
+    1, 2, 5, 9,
+};
+
+inline constexpr double kH3RefVidBlockTimestamps[] = {
+    0.25, 0.25, 1.0, 0.25, 1.25, 2.25,
+    3.25, 4.0, 0.25, 1.25, 2.25, 3.25,
+    4.25, 5.25, 6.25, 7.25, 8.25,
+};
+
+// --- section 9: presentation token tags ---
+inline constexpr int64_t kH3PresSpanCount = 5;
+inline constexpr int64_t kH3PresTagCount = 43;
+
+inline constexpr int64_t kH3PresSpanKinds[] = {
+    1, 0, 1, 0, 1,
+};
+
+inline constexpr int64_t kH3PresSpanLens[] = {
+    13, 5, 13, 7, 5,
+};
+
+inline constexpr int64_t kH3PresTagsGolden[] = {
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+    0, 0, 1, 1, 1, 1, 1,
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_nvfp4_manifest.inc b/tests/vllm/models/minimax_h3_nvfp4_manifest.inc
new file mode 100644
index 000000000..6218cbbd1
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_nvfp4_manifest.inc
@@ -0,0 +1,1075 @@
+// GENERATED by scripts/gen-minimax-h3-safetensors-manifest.py — DO NOT EDIT BY HAND.
+//
+// Tensor manifest of a REAL safetensors checkpoint (lilcheaty/MiniMax-H3-NVFP4 minimax_h3_ref2va_nvfp4_full.safetensors): 1051 tensors,
+// names/dtypes/shapes only — no weight bytes. Captured from the file's own header via
+// an HTTP range request. See .agents/specs/minimax-h3.md.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3Nvfp4TensorCount = 1051;
+
+struct H3Nvfp4Tensor {
+  const char* name;
+  const char* dtype;
+  int64_t shape[5];  // 0-padded (Conv3d weights are rank 5)
+  int32_t rank;
+};
+
+inline constexpr H3Nvfp4Tensor kH3Nvfp4Tensors[] = {
+    {"audio_patch_proj.bias", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"audio_patch_proj.weight", "BF16", {5376, 32, 0, 0, 0}, 2},
+    {"blocks.0.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.0.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.0.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.0.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.0.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.0.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.0.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.0.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.0.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.0.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.0.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.0.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.0.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.0.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.0.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.0.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.0.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.0.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.0.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.0.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.1.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.1.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.1.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.1.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.1.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.1.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.1.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.1.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.1.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.1.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.1.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.1.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.1.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.1.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.1.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.1.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.1.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.1.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.1.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.1.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.10.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.10.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.10.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.10.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.10.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.10.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.10.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.10.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.10.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.10.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.10.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.10.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.10.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.10.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.10.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.10.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.10.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.10.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.10.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.10.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.11.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.11.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.11.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.11.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.11.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.11.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.11.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.11.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.11.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.11.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.11.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.11.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.11.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.11.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.11.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.11.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.11.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.11.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.11.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.11.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.12.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.12.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.12.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.12.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.12.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.12.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.12.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.12.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.12.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.12.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.12.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.12.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.12.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.12.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.12.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.12.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.12.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.12.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.12.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.12.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.13.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.13.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.13.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.13.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.13.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.13.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.13.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.13.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.13.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.13.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.13.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.13.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.13.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.13.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.13.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.13.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.13.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.13.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.13.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.13.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.14.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.14.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.14.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.14.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.14.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.14.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.14.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.14.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.14.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.14.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.14.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.14.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.14.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.14.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.14.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.14.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.14.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.14.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.14.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.14.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.15.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.15.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.15.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.15.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.15.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.15.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.15.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.15.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.15.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.15.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.15.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.15.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.15.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.15.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.15.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.15.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.15.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.15.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.15.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.15.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.16.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.16.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.16.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.16.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.16.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.16.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.16.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.16.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.16.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.16.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.16.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.16.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.16.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.16.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.16.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.16.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.16.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.16.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.16.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.16.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.17.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.17.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.17.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.17.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.17.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.17.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.17.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.17.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.17.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.17.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.17.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.17.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.17.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.17.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.17.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.17.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.17.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.17.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.17.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.17.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.18.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.18.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.18.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.18.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.18.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.18.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.18.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.18.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.18.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.18.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.18.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.18.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.18.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.18.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.18.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.18.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.18.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.18.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.18.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.18.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.19.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.19.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.19.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.19.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.19.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.19.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.19.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.19.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.19.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.19.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.19.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.19.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.19.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.19.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.19.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.19.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.19.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.19.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.19.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.19.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.2.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.2.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.2.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.2.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.2.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.2.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.2.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.2.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.2.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.2.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.2.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.2.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.2.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.2.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.2.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.2.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.2.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.2.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.2.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.2.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.20.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.20.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.20.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.20.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.20.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.20.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.20.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.20.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.20.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.20.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.20.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.20.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.20.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.20.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.20.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.20.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.20.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.20.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.20.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.20.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.21.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.21.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.21.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.21.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.21.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.21.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.21.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.21.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.21.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.21.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.21.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.21.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.21.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.21.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.21.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.21.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.21.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.21.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.21.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.21.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.22.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.22.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.22.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.22.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.22.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.22.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.22.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.22.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.22.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.22.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.22.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.22.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.22.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.22.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.22.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.22.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.22.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.22.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.22.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.22.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.23.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.23.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.23.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.23.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.23.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.23.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.23.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.23.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.23.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.23.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.23.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.23.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.23.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.23.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.23.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.23.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.23.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.23.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.23.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.23.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.24.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.24.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.24.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.24.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.24.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.24.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.24.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.24.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.24.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.24.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.24.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.24.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.24.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.24.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.24.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.24.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.24.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.24.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.24.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.24.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.25.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.25.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.25.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.25.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.25.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.25.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.25.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.25.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.25.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.25.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.25.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.25.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.25.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.25.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.25.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.25.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.25.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.25.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.25.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.25.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.26.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.26.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.26.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.26.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.26.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.26.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.26.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.26.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.26.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.26.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.26.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.26.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.26.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.26.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.26.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.26.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.26.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.26.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.26.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.26.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.27.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.27.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.27.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.27.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.27.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.27.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.27.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.27.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.27.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.27.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.27.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.27.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.27.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.27.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.27.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.27.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.27.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.27.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.27.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.27.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.28.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.28.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.28.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.28.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.28.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.28.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.28.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.28.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.28.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.28.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.28.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.28.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.28.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.28.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.28.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.28.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.28.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.28.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.28.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.28.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.29.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.29.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.29.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.29.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.29.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.29.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.29.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.29.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.29.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.29.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.29.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.29.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.29.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.29.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.29.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.29.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.29.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.29.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.29.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.29.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.3.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.3.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.3.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.3.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.3.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.3.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.3.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.3.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.3.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.3.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.3.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.3.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.3.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.3.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.3.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.3.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.3.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.3.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.3.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.3.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.30.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.30.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.30.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.30.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.30.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.30.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.30.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.30.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.30.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.30.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.30.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.30.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.30.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.30.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.30.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.30.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.30.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.30.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.30.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.30.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.31.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.31.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.31.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.31.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.31.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.31.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.31.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.31.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.31.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.31.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.31.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.31.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.31.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.31.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.31.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.31.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.31.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.31.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.31.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.31.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.32.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.32.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.32.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.32.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.32.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.32.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.32.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.32.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.32.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.32.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.32.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.32.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.32.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.32.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.32.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.32.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.32.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.32.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.32.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.32.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.33.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.33.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.33.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.33.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.33.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.33.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.33.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.33.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.33.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.33.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.33.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.33.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.33.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.33.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.33.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.33.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.33.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.33.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.33.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.33.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.34.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.34.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.34.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.34.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.34.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.34.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.34.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.34.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.34.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.34.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.34.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.34.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.34.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.34.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.34.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.34.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.34.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.34.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.34.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.34.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.35.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.35.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.35.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.35.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.35.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.35.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.35.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.35.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.35.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.35.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.35.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.35.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.35.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.35.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.35.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.35.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.35.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.35.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.35.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.35.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.36.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.36.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.36.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.36.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.36.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.36.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.36.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.36.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.36.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.36.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.36.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.36.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.36.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.36.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.36.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.36.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.36.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.36.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.36.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.36.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.37.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.37.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.37.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.37.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.37.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.37.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.37.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.37.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.37.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.37.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.37.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.37.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.37.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.37.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.37.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.37.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.37.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.37.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.37.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.37.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.38.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.38.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.38.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.38.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.38.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.38.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.38.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.38.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.38.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.38.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.38.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.38.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.38.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.38.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.38.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.38.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.38.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.38.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.38.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.38.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.39.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.39.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.39.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.39.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.39.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.39.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.39.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.39.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.39.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.39.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.39.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.39.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.39.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.39.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.39.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.39.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.39.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.39.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.39.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.39.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.4.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.4.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.4.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.4.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.4.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.4.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.4.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.4.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.4.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.4.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.4.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.4.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.4.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.4.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.4.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.4.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.4.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.4.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.4.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.4.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.40.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.40.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.40.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.40.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.40.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.40.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.40.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.40.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.40.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.40.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.40.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.40.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.40.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.40.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.40.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.40.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.40.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.40.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.40.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.40.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.41.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.41.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.41.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.41.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.41.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.41.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.41.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.41.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.41.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.41.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.41.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.41.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.41.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.41.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.41.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.41.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.41.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.41.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.41.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.41.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.42.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.42.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.42.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.42.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.42.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.42.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.42.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.42.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.42.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.42.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.42.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.42.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.42.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.42.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.42.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.42.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.42.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.42.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.42.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.42.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.43.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.43.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.43.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.43.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.43.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.43.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.43.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.43.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.43.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.43.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.43.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.43.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.43.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.43.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.43.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.43.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.43.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.43.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.43.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.43.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.44.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.44.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.44.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.44.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.44.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.44.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.44.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.44.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.44.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.44.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.44.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.44.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.44.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.44.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.44.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.44.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.44.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.44.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.44.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.44.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.45.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.45.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.45.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.45.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.45.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.45.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.45.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.45.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.45.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.45.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.45.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.45.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.45.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.45.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.45.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.45.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.45.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.45.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.45.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.45.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.46.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.46.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.46.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.46.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.46.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.46.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.46.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.46.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.46.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.46.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.46.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.46.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.46.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.46.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.46.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.46.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.46.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.46.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.46.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.46.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.47.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.47.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.47.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.47.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.47.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.47.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.47.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.47.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.47.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.47.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.47.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.47.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.47.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.47.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.47.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.47.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.47.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.47.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.47.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.47.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.48.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.48.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.48.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.48.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.48.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.48.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.48.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.48.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.48.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.48.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.48.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.48.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.48.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.48.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.48.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.48.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.48.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.48.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.48.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.48.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.49.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.49.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.49.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.49.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.49.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.49.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.49.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.49.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.49.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.49.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.49.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.49.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.49.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.49.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.49.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.49.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.49.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.49.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.49.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.49.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.5.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.5.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.5.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.5.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.5.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.5.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.5.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.5.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.5.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.5.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.5.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.5.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.5.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.5.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.5.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.5.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.5.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.5.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.5.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.5.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.6.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.6.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.6.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.6.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.6.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.6.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.6.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.6.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.6.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.6.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.6.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.6.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.6.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.6.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.6.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.6.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.6.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.6.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.6.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.6.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.7.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.7.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.7.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.7.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.7.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.7.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.7.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.7.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.7.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.7.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.7.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.7.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.7.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.7.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.7.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.7.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.7.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.7.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.7.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.7.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.8.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.8.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.8.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.8.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.8.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.8.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.8.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.8.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.8.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.8.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.8.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.8.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.8.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.8.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.8.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.8.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.8.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.8.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.8.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.8.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.9.adaln_proj.linear.bias", "BF16", {96768, 0, 0, 0, 0}, 1},
+    {"blocks.9.adaln_proj.linear.weight", "U8", {96768, 1344, 0, 0, 0}, 2},
+    {"blocks.9.adaln_proj.linear.weight_scale", "F8_E4M3", {96768, 168, 0, 0, 0}, 2},
+    {"blocks.9.adaln_proj.linear.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.9.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.9.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"blocks.9.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"blocks.9.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.9.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"blocks.9.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"blocks.9.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"blocks.9.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.9.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"blocks.9.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"blocks.9.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.9.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"blocks.9.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"blocks.9.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"blocks.9.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"blocks.9.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"condition_proj.bias", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"condition_proj.weight", "BF16", {5376, 5120, 0, 0, 0}, 2},
+    {"final_layer.adaln_proj.linear.bias", "BF16", {10752, 0, 0, 0, 0}, 1},
+    {"final_layer.adaln_proj.linear.weight", "BF16", {10752, 2688, 0, 0, 0}, 2},
+    {"final_layer.audio_out.bias", "BF16", {32, 0, 0, 0, 0}, 1},
+    {"final_layer.audio_out.weight", "BF16", {32, 5376, 0, 0, 0}, 2},
+    {"final_layer.norm.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"final_layer.video_out.bias", "BF16", {96, 0, 0, 0, 0}, 1},
+    {"final_layer.video_out.weight", "BF16", {96, 5376, 0, 0, 0}, 2},
+    {"rope.inv_freq", "BF16", {16, 0, 0, 0, 0}, 1},
+    {"time_embedder.proj_in.bias", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"time_embedder.proj_in.weight", "BF16", {5376, 256, 0, 0, 0}, 2},
+    {"time_embedder.proj_out.bias", "BF16", {2688, 0, 0, 0, 0}, 1},
+    {"time_embedder.proj_out.weight", "BF16", {2688, 5376, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"token_refiner.blocks.0.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.0.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"token_refiner.blocks.0.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.0.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.0.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"token_refiner.blocks.0.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.0.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"token_refiner.blocks.0.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"token_refiner.blocks.1.attn.k_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"token_refiner.blocks.1.attn.out_proj.weight", "U8", {5376, 3584, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.attn.out_proj.weight_scale", "F8_E4M3", {5376, 448, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.attn.out_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.1.attn.q_norm.weight", "BF16", {128, 0, 0, 0, 0}, 1},
+    {"token_refiner.blocks.1.attn.qkv_proj.weight", "U8", {21504, 2688, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.attn.qkv_proj.weight_scale", "F8_E4M3", {21504, 336, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.attn.qkv_proj.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.1.mlp.fc1.weight", "U8", {28672, 2688, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.mlp.fc1.weight_scale", "F8_E4M3", {28672, 336, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.mlp.fc1.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.1.mlp.fc2.weight", "U8", {5376, 7168, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.mlp.fc2.weight_scale", "F8_E4M3", {5376, 896, 0, 0, 0}, 2},
+    {"token_refiner.blocks.1.mlp.fc2.weight_scale_2", "F32", {0, 0, 0, 0, 0}, 0},
+    {"token_refiner.blocks.1.norm1.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"token_refiner.blocks.1.norm2.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"token_refiner.final_norm.weight", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"video_patch_proj.bias", "BF16", {5376, 0, 0, 0, 0}, 1},
+    {"video_patch_proj.weight", "BF16", {5376, 96, 0, 0, 0}, 2},
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_vae_configs.inc b/tests/vllm/models/minimax_h3_vae_configs.inc
new file mode 100644
index 000000000..81e4631dc
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_vae_configs.inc
@@ -0,0 +1,234 @@
+// GENERATED from the REAL MiniMaxAI/MiniMax-H3 config.json files — DO NOT EDIT BY HAND.
+//
+// The shipped VAE configs, verbatim. Small enough to embed, and embedding them is
+// the point: the parsers are gated against what the checkpoint ACTUALLY says, not
+// against a hand-copied summary that could drift.
+#pragma once
+
+namespace vllm_test {
+
+inline constexpr const char* kH3AudioVaeConfigJson = R"H3JSON({
+  "_class_name": "AutoencoderKLMiniMaxH3Audio",
+  "_diffusers_version": "0.36.0.dev0",
+  "encoder_dim": 64,
+  "encoder_rates": [
+    2,
+    4,
+    4,
+    5,
+    5
+  ],
+  "latent_dim": 2048,
+  "latent_channels": 32,
+  "decoder_dim": 1024,
+  "decoder_rates": [
+    5,
+    5,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "decoder_kernel_sizes": [
+    9,
+    9,
+    4,
+    4,
+    4,
+    4,
+    4
+  ],
+  "num_attention_heads": 8,
+  "resblock_kernel_sizes": [
+    3,
+    7,
+    11
+  ],
+  "resblock_dilation_sizes": [
+    [
+      1,
+      3,
+      5
+    ],
+    [
+      1,
+      3,
+      5
+    ],
+    [
+      1,
+      3,
+      5
+    ]
+  ],
+  "sampling_rate": 32000,
+  "latents_mean": [
+    -0.020211687488382354,
+    0.3876466479950502,
+    -0.04398279799186767,
+    -0.28591514936373,
+    0.08179686214561671,
+    -0.35782641352446604,
+    0.040623809960919084,
+    -0.01552534501956604,
+    -0.223362481667332,
+    0.1821006842509091,
+    0.2941778783780663,
+    -0.07901167601970885,
+    -0.056815072777201,
+    -0.3699028221860095,
+    -0.31616315591624855,
+    0.5905951377425391,
+    -0.052139568068853864,
+    0.013673160263486295,
+    -0.03691647864630577,
+    0.09732660653298163,
+    -0.3394662328788498,
+    -0.30685677538541667,
+    -0.24504598907458763,
+    -0.034698524462007344,
+    0.02868032184767538,
+    -0.21217779266454084,
+    -0.1678263169941987,
+    0.3221287889040614,
+    -0.1223055851554907,
+    0.4356604928128464,
+    -0.0502599202236253,
+    0.3979258376211797
+  ],
+  "latents_std": [
+    1.6895524230479284,
+    2.76263727217653,
+    1.7945344281264435,
+    1.6801681847309828,
+    1.6390226546605453,
+    2.7788298348882177,
+    1.7659090095747236,
+    1.6199757612137327,
+    2.6336525640336896,
+    1.8539356672817833,
+    2.5056497896915633,
+    1.811019237886178,
+    1.9579657790720237,
+    1.6685498243529284,
+    1.4922469314453364,
+    3.298670198067373,
+    1.9491804496832168,
+    1.8720003270431442,
+    1.8334080103291832,
+    1.6488070416529093,
+    1.6176957696319716,
+    1.9131449234774398,
+    1.5695245398428617,
+    1.6943659940415912,
+    1.8318420762504692,
+    1.5540637421583379,
+    1.9344930328968526,
+    1.599198216109855,
+    1.718045989838149,
+    1.6307219190837705,
+    1.8661226051202384,
+    1.5613768203168363
+  ]
+})H3JSON";
+
+inline constexpr const char* kH3VideoVaeConfigJson = R"H3JSON({
+  "_class_name": "AutoencoderKLMiniMaxH3",
+  "_diffusers_version": "0.36.0.dev0",
+  "in_channels": 3,
+  "out_channels": 3,
+  "latent_channels": 24,
+  "block_out_channels": [
+    128,
+    256,
+    256,
+    512,
+    512,
+    1024
+  ],
+  "layers_per_block": 2,
+  "spatial_downsample_factors": [
+    2,
+    2,
+    2,
+    2,
+    1,
+    1
+  ],
+  "temporal_downsample_factors": [
+    1,
+    2,
+    2,
+    1,
+    1,
+    1
+  ],
+  "norm_num_groups": 32,
+  "norm_eps": 1e-06,
+  "spatial_padding_mode": "reflect",
+  "decoder_num_layers": 36,
+  "decoder_num_attention_heads": 32,
+  "decoder_attention_head_dim": 64,
+  "decoder_num_register_tokens": 4,
+  "decoder_ffn_mult": 4,
+  "decoder_rope_theta": 100.0,
+  "decoder_rope_dim_ratio": 0.75,
+  "decoder_norm_eps": 1e-05,
+  "clip_length": 17,
+  "token_drop": 3,
+  "latents_mean": [
+    0.858090341091156,
+    -0.9606591463088989,
+    1.0661640167236328,
+    -0.5090325474739075,
+    -0.2727581858634949,
+    -1.3675414323806763,
+    -0.2553254961967468,
+    -0.26907554268836975,
+    -0.5376840829849243,
+    -0.0464097298681736,
+    0.6657370328903198,
+    0.19690127670764923,
+    -0.5460608005523682,
+    -0.4035342037677765,
+    -0.23683024942874908,
+    0.25928452610969543,
+    -0.30133944749832153,
+    0.211341992020607,
+    -1.1206848621368408,
+    0.3581933379173279,
+    -0.04225143790245056,
+    0.2604829967021942,
+    0.22864092886447906,
+    0.7056031823158264
+  ],
+  "latents_std": [
+    1.2223774194717407,
+    1.2767263650894165,
+    1.6831774711608887,
+    1.7549455165863037,
+    1.5636216402053833,
+    2.194143533706665,
+    0.9653137922286987,
+    1.0569885969161987,
+    0.841948926448822,
+    0.7729952931404114,
+    1.8955937623977661,
+    0.946841835975647,
+    0.7996809482574463,
+    0.44988900423049927,
+    0.7197399735450745,
+    0.6936293244361877,
+    2.961095094680786,
+    2.7694199085235596,
+    3.0496184825897217,
+    2.1088054180145264,
+    3.276226282119751,
+    3.1627357006073,
+    2.2816812992095947,
+    2.6127843856811523
+  ]
+})H3JSON";
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_video_vae_goldens.inc b/tests/vllm/models/minimax_h3_video_vae_goldens.inc
new file mode 100644
index 000000000..b898a4c69
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_video_vae_goldens.inc
@@ -0,0 +1,723 @@
+// GENERATED by scripts/gen-minimax-h3-video-vae-goldens.py — DO NOT EDIT BY HAND.
+//
+// MiniMax-H3 VIDEO VAE decoder TransformerBlock goldens, produced by executing the
+// CHECKPOINT'S OWN remote-code module (FL2VA/video_vae/base_module.py) at reduced
+// dimensions. The shipped decoder is 36 of these blocks. The remote code is not
+// vendored here; see the generator's docstring. Weights come from the shared H3Rand
+// stream, so no weight byte is checked in.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3VideoVaeBlockHeads = 2;
+inline constexpr int64_t kH3VideoVaeBlockDimHead = 8;
+inline constexpr int64_t kH3VideoVaeBlockDim = 16;
+inline constexpr int64_t kH3VideoVaeBlockSeq = 6;
+inline constexpr int64_t kH3VideoVaeBlockFfInner = 64;
+
+inline constexpr float kH3VideoVaeBlockGolden[] = {
+    0.328430355f, -0.804559708f, 0.347274333f, 0.738101006f, -0.851319432f, 0.706105947f,
+    0.419730276f, -0.539133906f, 0.286779702f, 0.256491482f, 0.761140585f, -0.0335022435f,
+    0.559185922f, -0.585408032f, 0.85638535f, -0.616454244f, 0.384774536f, -0.621491969f,
+    -0.192281038f, -0.0340347663f, -0.02001906f, -0.620987356f, -0.613313913f, 0.623094857f,
+    0.732061744f, -0.767501414f, 0.464702457f, 0.00731994305f, -0.64816469f, 0.0964003727f,
+    0.00854284037f, -0.254967123f, -0.347426385f, -0.946118116f, 0.717170715f, -0.593692482f,
+    -0.728302479f, 0.698037267f, -0.598491073f, -0.679739714f, 0.708907068f, 0.828211248f,
+    -0.994477212f, 0.407447457f, 0.350214183f, 0.476883441f, -0.343815833f, -0.84654665f,
+    0.560587168f, 0.280306399f, 0.642721534f, -0.195227891f, 0.590519607f, -0.707078457f,
+    -0.508368313f, 0.762322545f, -0.499513417f, 0.111449622f, 0.5164572f, -0.863759279f,
+    -0.221609905f, -0.185210496f, 0.351244122f, 0.980201542f, -0.0933880359f, 0.0776797384f,
+    -0.908338964f, 0.150705025f, 0.420253098f, -0.483068198f, -0.564757109f, 0.660945475f,
+    -0.351661772f, 0.125627846f, -0.943108976f, -0.494674444f, -0.680933177f, -0.429059237f,
+    -0.394803941f, -0.624601245f, -0.526208758f, 0.568665922f, 0.254600525f, -0.25925535f,
+    0.106417038f, -0.695022643f, -0.58667779f, 0.188248798f, -0.661644042f, -0.115432985f,
+    -0.328081161f, -0.241062835f, 0.928992927f, 0.184090197f, 0.307149589f, -0.442929178f,
+};
+
+inline constexpr int64_t kH3VideoVaeDecLayers = 2;
+inline constexpr int64_t kH3VideoVaeDecInCh = 4;
+inline constexpr int64_t kH3VideoVaeDecOutCh = 3;
+inline constexpr int64_t kH3VideoVaeDecPatch = 2;
+inline constexpr int64_t kH3VideoVaeDecPatchT = 1;
+inline constexpr int64_t kH3VideoVaeDecRegisterTokens = 4;
+inline constexpr int64_t kH3VideoVaeDecT = 2;
+inline constexpr int64_t kH3VideoVaeDecH = 2;
+inline constexpr int64_t kH3VideoVaeDecW = 3;
+inline constexpr int64_t kH3VideoVaeDecFrameT = 2;
+inline constexpr int64_t kH3VideoVaeDecFrameH = 4;
+inline constexpr int64_t kH3VideoVaeDecFrameW = 6;
+
+inline constexpr float kH3VideoVaeDecoderGolden[] = {
+    -0.33159399f, -0.0525939986f, -0.315105915f, -0.0284571424f, -0.438838542f, -0.178674847f,
+    0.0964291319f, -0.111457981f, -0.223720074f, 0.305552423f, 0.105507486f, -0.223558158f,
+    -0.0418326259f, -0.147650123f, -0.45560962f, 0.0845928565f, -0.205480129f, -0.107214265f,
+    -0.269703209f, 0.511400878f, 0.190256298f, -0.524864852f, -0.29102692f, 0.459694594f,
+    -0.578282237f, 0.124889128f, -0.384469986f, 0.0870364681f, -0.186703801f, 0.0393126756f,
+    0.197892576f, -0.283356518f, -0.0196712818f, -0.238811448f, -0.332251012f, 0.552500069f,
+    0.00659959763f, -0.0301535521f, -0.291092694f, 0.0145031372f, -0.448399365f, 0.0544170886f,
+    -0.310496539f, 0.545208931f, -0.0106125921f, 0.144670561f, -0.0819911584f, -0.0814950392f,
+    0.0477984399f, 0.25230974f, 0.187951237f, 0.0106875524f, -0.214029431f, -0.252337158f,
+    0.00179825351f, 0.154477924f, 0.153742597f, 0.238705084f, 0.0889883041f, 0.289354742f,
+    0.0790167525f, -0.0661514401f, -0.0274583101f, -0.0261498038f, 0.112030961f, -0.144519687f,
+    -0.0529251508f, -0.0853419974f, 0.266651839f, 0.383687019f, 0.13701579f, 0.140100032f,
+    -0.145416796f, -0.0988062918f, 0.154586643f, 0.0173128359f, 0.110878132f, -0.243255556f,
+    0.00663428195f, 0.0307537019f, 0.349492997f, 0.498573363f, 0.129347667f, -0.0149930641f,
+    0.221204668f, 0.0713881776f, -0.258943439f, -0.389577866f, 0.162217319f, -0.0270094778f,
+    -0.0177244134f, -0.0877438858f, -0.0763153285f, -0.247313604f, 0.293543726f, 0.474600673f,
+    0.0201233961f, -0.166072562f, -0.164830118f, -0.117878228f, -0.0623665377f, 0.476352751f,
+    -0.333599359f, 0.0280546211f, 0.00644346699f, 0.370539069f, -0.331020564f, 0.238929138f,
+    -0.00542023871f, -0.338400841f, -0.103717953f, 0.504063845f, -0.162257984f, -0.0322581679f,
+    0.0572879687f, 0.15205653f, -0.209499106f, 0.195069015f, 0.114232898f, 0.371838808f,
+    0.0822518021f, 0.212362781f, -0.226097897f, 0.366524071f, -0.126723081f, -0.02628012f,
+    -0.309458733f, 0.0490504354f, -0.0279658753f, 0.384277999f, 0.322568715f, 0.333149195f,
+    -0.00334029924f, -0.492584437f, 0.0824163929f, 0.202136427f, -0.230301857f, 0.263518542f,
+    0.177932456f, 0.133054718f, 0.0200626496f, 0.0145068653f, -0.0634974092f, 0.433572888f,
+};
+
+inline constexpr int64_t kH3TileVaeRatio = 16;
+inline constexpr int64_t kH3TileCases = 6;
+inline constexpr int64_t kH3TileBlendExtent = 4;
+inline constexpr int64_t kH3TileBlendLen = 12;
+
+inline constexpr int64_t kH3TileInputs[] = {
+    1024, 256, 64, 768, 256, 64, 256, 256, 64, 100, 256, 64,
+    1344, 256, 64, 513, 128, 32,
+};
+
+inline constexpr int64_t kH3TileCounts[] = {
+    5, 4, 1, 1, 7, 6,
+};
+
+inline constexpr int64_t kH3TileStarts[] = {
+    0, 192, 384, 576, 768, 0, 160, 336, 512, 0, 0, 0,
+    176, 352, 528, 704, 896, 1088, 0, 80, 160, 240, 320, 400,
+};
+
+inline constexpr int64_t kH3TileLens[] = {
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 100, 256,
+    256, 256, 256, 256, 256, 256, 128, 128, 128, 128, 128, 128,
+};
+
+inline constexpr int64_t kH3TileOverlaps[] = {
+    64, 64, 64, 64, 96, 80, 80, 80, 80, 80, 80, 64,
+    64, 48, 48, 48, 48, 48,
+};
+
+inline constexpr float kH3TileBlendGolden[] = {
+    0.369998753f, -0.411502272f, 0.55181247f, 0.0489070341f, 0.059626583f, 0.199151933f,
+    -0.232086182f, -0.2580899f, -0.38048327f, 0.52126509f, 0.0402474627f, -0.326698303f,
+};
+
+inline constexpr int64_t kH3Res3dInCh = 32;
+inline constexpr int64_t kH3Res3dOutCh = 64;
+inline constexpr int64_t kH3Res3dT = 3;
+inline constexpr int64_t kH3Res3dH = 4;
+inline constexpr int64_t kH3Res3dW = 4;
+inline constexpr int64_t kH3Res3dGroups = 32;
+
+inline constexpr float kH3Res3dGolden[] = {
+    -0.419984519f, 0.538414717f, -0.537063718f, 0.112877488f, 1.73672783f, -1.10180509f,
+    1.59929574f, -1.21270454f, -0.0684084445f, -0.0739090666f, -0.152196795f, 0.37609905f,
+    1.25862932f, 0.0365633219f, 0.957886994f, -0.362648398f, 0.0405455008f, -0.353806615f,
+    1.10367918f, -0.367179304f, 0.47188127f, -0.0364980996f, 0.213360608f, -0.959347427f,
+    -1.65947008f, -0.538147092f, -1.2539717f, -1.32484174f, -0.309210092f, -0.298861474f,
+    -0.29876712f, -0.606865346f, -0.483216524f, 1.35435605f, 0.527569234f, 1.77986455f,
+    0.709511161f, -0.458319187f, 2.57001138f, -0.934900284f, -0.23060593f, 0.26287058f,
+    -0.859524965f, 0.702123046f, -0.0435336456f, -0.992881238f, 0.437346339f, -0.820216894f,
+    0.17704092f, -0.988845944f, 0.49341619f, 0.0885026455f, -0.0658368617f, -1.11883926f,
+    0.203347743f, -0.474126428f, 0.593127012f, -0.40471366f, 0.827225447f, -0.0234843493f,
+    0.0642805696f, -0.494284451f, 0.514892042f, -0.320928991f, 0.891324103f, 0.0402085185f,
+    -0.189491272f, -0.304295778f, 1.13672054f, -0.626566529f, 1.00960588f, 0.995947897f,
+    -0.827644408f, 0.693582296f, -0.361026794f, 0.0681871697f, 0.674163222f, 1.17058945f,
+    1.46307576f, 1.65091908f, -0.970554829f, 1.32605386f, 0.0805303752f, -1.92763364f,
+    2.65380883f, 2.54381824f, 1.89402127f, 0.824640989f, -1.10783875f, 0.806592345f,
+    0.738499343f, -1.45033193f, 2.32772541f, 0.897321641f, 2.54758763f, 0.484088391f,
+    0.573479414f, 1.20427513f, -0.245386347f, 0.458395749f, 0.669500411f, 0.997427583f,
+    -0.447750121f, -0.071534127f, 0.857060313f, 0.151668608f, -0.286780357f, -0.10398677f,
+    -0.132612437f, 1.44466496f, -0.132184163f, 0.317938298f, -1.72804296f, -1.30904841f,
+    -1.53256643f, 0.156738698f, 0.907365382f, -0.57558018f, 0.1760346f, -0.602768481f,
+    -0.351688266f, -2.20095539f, -0.950830042f, -0.166317135f, 0.285760641f, -1.27770138f,
+    -0.0320467949f, 0.120897412f, -3.02964902f, -1.28976548f, -1.83165812f, 0.780008316f,
+    1.0360806f, -1.5223968f, 0.456744581f, -0.27195996f, -1.21323717f, -1.16409791f,
+    -0.929139435f, 0.0179004073f, 0.697577715f, -0.86854744f, 0.566343009f, -0.157750368f,
+    -0.40863052f, -0.430371225f, -0.203998327f, -0.274632692f, 0.26374352f, -0.0305181146f,
+    0.887246072f, -0.251830429f, 0.121890679f, -0.0235877037f, -0.464517176f, -0.345798522f,
+    -0.473799884f, -0.20474264f, 0.417652041f, 0.0541642979f, -0.555644929f, -0.378202945f,
+    -1.64930677f, 0.805448472f, -1.07167971f, -0.177699104f, -0.452631116f, 0.503122687f,
+    0.0617894456f, -0.236101925f, -0.612477422f, 0.0281199217f, -0.570741057f, -0.943556905f,
+    0.125990167f, -1.40771937f, 1.66684973f, -1.85701621f, 0.134617612f, -1.37665737f,
+    -0.589712143f, 2.2736721f, -1.13918519f, -0.702645481f, -0.0510546491f, 0.493780196f,
+    0.243442714f, 0.817261994f, 0.832728267f, 3.50841141f, -0.657253981f, 2.00506639f,
+    -1.13951981f, -0.154184878f, -0.402277052f, 0.0995144546f, 0.27438879f, 0.662074685f,
+    0.376054913f, 0.264969945f, -0.607597709f, -0.853032351f, -0.124562934f, -0.261054724f,
+    0.541737854f, -0.0868035778f, 0.574261487f, -0.264957517f, 1.51346636f, -0.923378944f,
+    1.30389369f, -1.10910392f, 0.925325036f, -1.3075372f, 1.5798918f, -0.888168335f,
+    1.77598977f, -0.327132106f, 0.189335838f, 0.580862463f, 0.810105681f, -1.70444059f,
+    -0.218519241f, -1.6222403f, 0.430466384f, 1.59747374f, 1.00062251f, 0.600783408f,
+    2.0242095f, 0.967499435f, 1.16563213f, 0.0090500284f, 1.92334807f, 1.61995375f,
+    0.0589817762f, 1.984918f, 1.43176055f, 0.434746027f, 0.365061462f, 0.874324024f,
+    0.249114558f, 0.775983453f, -0.106336385f, 0.0296601504f, 0.35063377f, -0.273180544f,
+    0.142767802f, -0.218673825f, -0.510233939f, 0.62470746f, -0.915923357f, 0.439476043f,
+    0.847470582f, -0.230534434f, 0.0793968961f, 0.0788760483f, -0.358306408f, 0.478150755f,
+    -0.548306286f, -0.526718259f, -0.329908699f, 1.92545044f, -0.879713774f, 2.19143391f,
+    0.763319731f, -0.686991394f, 0.167384669f, 0.373831064f, 0.0168358088f, 1.36128592f,
+    -1.02307487f, 0.95659405f, -0.724966705f, 0.273631096f, 0.105727404f, 0.636504412f,
+    2.91819024f, 1.62154436f, 2.14464831f, 0.740133882f, 0.668194652f, 0.25362134f,
+    0.0799147338f, -0.547375083f, 0.672182679f, 2.60158587f, 0.956640422f, 2.71259594f,
+    -0.544083714f, -0.299972504f, -0.0224833786f, -0.415125728f, -0.586748302f, -0.0758699477f,
+    -0.344970495f, -0.307543665f, -1.27617145f, -1.14100707f, -0.210965529f, -1.2432524f,
+    -0.717883885f, 0.406668723f, -0.319563895f, -0.0286639817f, -0.61110121f, -0.109018132f,
+    -0.506822765f, 0.66319263f, 0.221655264f, -1.20128012f, -0.713080525f, 1.03327692f,
+    0.907658696f, -2.08930683f, 1.1674726f, -0.838287473f, -0.289165348f, -1.18131137f,
+    -1.75418139f, 0.0891197622f, -0.576361716f, 0.0721016228f, -2.36374903f, -1.12439489f,
+    -2.23135972f, -0.754176915f, -2.79504299f, -1.7739507f, 1.0190897f, 2.00962591f,
+    1.39565635f, 0.2031703f, -2.79510593f, -0.332132131f, -3.82890892f, -2.81236267f,
+    -0.663621128f, -0.981734216f, -0.249991819f, -0.363556474f, -0.244236901f, -0.0751837492f,
+    0.212000251f, 0.649521708f, -0.146902978f, -0.774070382f, -0.153232545f, -0.384206742f,
+    -0.769532084f, -0.619634926f, -0.0257901549f, 0.451335967f, 1.40012658f, -0.151732609f,
+    0.891265273f, -0.180448368f, 1.99473476f, 2.56753659f, 1.7841655f, 2.36090803f,
+    0.293875635f, 0.278036177f, 0.124876752f, 1.0064199f, 2.28069091f, 1.91637146f,
+    1.98408806f, 1.34276521f, -1.07346964f, 1.43801951f, -1.32626402f, 1.6158371f,
+    2.98336649f, -0.789279938f, 2.99861622f, -0.803568721f, 2.46857572f, 0.782599568f,
+    2.76766443f, 1.46227288f, 0.0319422185f, -0.112665042f, -0.0414934754f, 0.90119493f,
+    -1.0025593f, 0.409200281f, -0.77612704f, 0.147530451f, -0.522174239f, 0.135576993f,
+    -0.23423104f, 0.208479196f, 0.160761356f, -0.174657121f, 0.327540368f, -0.868467033f,
+    -1.02832329f, 0.56867975f, -0.603770077f, 0.429255307f, 1.42378187f, 1.36902499f,
+    0.5742293f, 1.10275877f, -0.322385073f, 0.293227553f, -0.765052378f, -0.0395277441f,
+    2.47634912f, -0.209829509f, 0.578415632f, -0.508690596f, -0.168413907f, 1.03276503f,
+    -0.21122326f, -0.13580367f, -1.32909274f, 0.900385499f, -0.659458935f, 1.24211955f,
+    -3.14564037f, -1.77536845f, -0.604450583f, -0.633298397f, 1.20469964f, 1.08019662f,
+    1.04158008f, 1.99067926f, -1.5459621f, -1.961496f, 0.891231477f, -1.52054691f,
+    1.50535953f, -1.49280131f, 1.74442029f, -2.11856365f, -0.4475618f, -0.535425544f,
+    -0.729699492f, -0.481821269f, 1.41057551f, -0.578731835f, 0.905929208f, -1.39168251f,
+    0.484703988f, -1.30265856f, 0.368130386f, -0.94108218f, -2.15126324f, 0.679279983f,
+    -1.88681889f, -0.266961247f, -1.00374198f, -0.582391143f, -0.755287826f, -0.6933676f,
+    -2.82343531f, -1.50111389f, -2.79400086f, -1.48150373f, -2.25229454f, -0.28897354f,
+    -1.796314f, 0.0966628492f, -1.77975404f, -0.927144766f, -0.509858906f, 0.481116563f,
+    0.308937132f, 2.03225327f, -0.260191083f, -0.546583652f, -2.55041432f, -1.73970807f,
+    -3.09260058f, -0.341931403f, 0.389729023f, 0.605692327f, -0.0547046959f, -1.78800035f,
+    0.365852624f, 0.139908195f, -0.199724615f, -0.291409314f, -0.736817956f, -0.356474876f,
+    -1.0920459f, -0.524775088f, -0.268081546f, 0.30601722f, -0.681635201f, 0.38243255f,
+    -0.232750848f, -0.450568616f, -0.436790615f, -0.762665033f, 1.08971632f, 1.71045494f,
+    3.10860538f, 1.77683735f, 0.640139639f, -1.23569691f, -2.3025434f, -1.28973556f,
+    -0.0786036104f, 1.63239145f, 0.786816537f, 1.85517371f, -0.867397845f, -1.15576434f,
+    -1.02329218f, -1.63106549f, -1.79613984f, -1.80509901f, -1.57228231f, -1.10850251f,
+    1.25030482f, -0.39021492f, 2.61183381f, 0.767622232f, -2.18114328f, -1.30885267f,
+    -3.22062802f, -0.762849629f, -0.0936308056f, -0.774862349f, 0.573585629f, -0.564514279f,
+    -1.01890957f, -0.627498507f, -0.665906191f, -1.00552654f, -1.28283226f, -0.267548203f,
+    -0.0660983995f, -0.634502053f, -1.54192328f, -1.60491347f, -1.32755876f, -1.6370455f,
+    -0.2492989f, 0.406520128f, 0.698272943f, -0.702975988f, 0.310436785f, -0.915795267f,
+    -0.459004879f, -0.281689584f, 0.550112486f, -0.494909763f, 0.159819961f, -0.702569962f,
+    0.947640896f, -1.98774111f, 1.16022587f, -1.38768494f, -0.236812949f, -0.0507012494f,
+    -0.421823204f, -0.992871523f, -1.04079497f, -0.813180089f, 0.159939975f, 1.1649437f,
+    -0.937250376f, -0.0578891896f, 0.158304542f, -2.13502026f, 1.04333901f, -0.206050992f,
+    1.26301467f, 0.454620838f, -2.22873878f, 1.37196112f, -0.127311513f, 0.138858452f,
+    -0.242880136f, -0.248718545f, -0.248030782f, 0.292909473f, 0.144940674f, -0.628292441f,
+    0.461137354f, 0.0294038802f, -0.378051907f, -0.435663432f, -0.245362997f, -0.12592113f,
+    0.686705351f, -0.819919407f, 0.37412411f, 0.65549922f, -0.217255801f, -0.472015917f,
+    -0.342802227f, 0.648489892f, -0.740233839f, 0.961862266f, -1.1142565f, 0.365292609f,
+    0.425765872f, 0.683435798f, -1.39205098f, 0.970962346f, -0.895201862f, 0.0362391993f,
+    0.413969517f, 0.0943643749f, 1.99015093f, -2.23818517f, 0.823161304f, -0.258417726f,
+    0.0746402442f, -1.58961999f, -1.3794235f, 0.635411322f, 0.849481285f, -1.41462862f,
+    -0.0897139758f, 0.337659895f, 1.51573074f, 0.449855387f, 0.563115597f, 1.72037709f,
+    -0.365094662f, 0.410166234f, -0.308951795f, 0.365512133f, -0.580391526f, 0.133035436f,
+    -0.773986757f, 0.532702744f, -0.24954325f, 0.866452694f, -0.275209963f, 0.236380979f,
+    -0.529762506f, 0.237834692f, -1.31042659f, 0.140022561f, -0.629038692f, 0.0055386126f,
+    -1.71984291f, -0.928757191f, -1.62422323f, 0.41194278f, -1.88422859f, 0.700061321f,
+    -0.438699454f, -0.559094071f, 0.114665613f, -1.21989632f, -1.44156134f, 0.722412884f,
+    -2.42032981f, -0.467461884f, -2.55848694f, 1.13268411f, -2.41456389f, 0.256621689f,
+    -2.20605469f, -0.983933687f, -2.14807487f, 0.589749873f, -0.462837279f, 0.333577186f,
+    -2.50296545f, -0.0187642761f, -1.66103554f, -1.19347405f, -1.32162189f, -0.105706841f,
+    -0.836368203f, -0.114373505f, 0.0581659824f, 0.241666868f, -0.475705922f, -0.0965321064f,
+    -0.79100585f, -0.748468041f, -0.392618597f, -0.0977259725f, 0.65661335f, 0.127362579f,
+    -0.991597891f, -0.713136792f, -0.523957729f, -0.438147515f, -1.07130229f, -0.180353194f,
+    0.264445841f, 0.0163280219f, 0.325219542f, 0.190661728f, 0.188681364f, -0.299738288f,
+    0.571213841f, -1.72900248f, 1.50310719f, -0.0750390589f, -0.436439455f, 1.07486224f,
+    -0.608142257f, 0.307467878f, 2.53485656f, 1.7468822f, 3.11935186f, 2.19120169f,
+    -1.22921455f, -0.348632753f, 0.439942747f, 1.58539593f, 2.93022799f, -0.201819181f,
+    2.41787958f, 0.245071501f, 0.521638334f, 1.48574936f, 2.43206668f, 3.29304028f,
+    0.449385345f, -0.164436519f, 0.945558608f, -0.7427876f, 0.305109918f, -0.204615235f,
+    1.0609802f, 0.0298992693f, -0.486094356f, -0.541718841f, -0.0936733112f, -0.120189995f,
+    1.2692194f, 0.37670809f, 1.53404284f, 0.028208375f, 0.0590121299f, 0.0554797649f,
+    -1.02212572f, -0.263207674f, 1.97210169f, 1.24556398f, 0.821009994f, 1.74549615f,
+    -0.528538108f, -0.0736899525f, -1.33415163f, -0.269204974f, 0.348429829f, 0.561982512f,
+    -0.0794841349f, 0.851943135f, -0.545982718f, 0.174488604f, 0.480484664f, 1.76159024f,
+    -0.459899485f, 1.00562274f, 1.21581697f, 1.28048635f, 0.671006858f, 1.23123014f,
+    -0.269982845f, 3.4127264f, 1.22832048f, 1.13602388f, 1.80809116f, 3.45978856f,
+    -0.741648197f, 0.447898149f, -0.985641897f, 0.535587847f, 0.445654184f, -0.339240998f,
+    0.805393219f, -0.497445911f, -0.636054218f, -0.676925957f, -0.125690252f, -0.682434678f,
+    0.408564925f, 1.06353533f, 0.575202942f, -0.0780877471f, 0.355163574f, 0.286557019f,
+    -0.441620827f, 0.321694076f, -0.789547443f, 0.559432507f, -1.29323947f, 1.96870553f,
+    -0.676439464f, 0.47754091f, -1.15921032f, 0.192160562f, -1.16982758f, -0.0576772653f,
+    -0.130142868f, 0.853913844f, 0.990605891f, -1.96895862f, 1.0234611f, -0.33194831f,
+    2.57222009f, 0.054656148f, 0.165877655f, -0.90673095f, -1.77762914f, -2.07549095f,
+    -0.175165787f, -0.307166636f, 0.450920135f, 0.952438235f, 1.52292717f, -0.0961315185f,
+    0.153859541f, -0.553445458f, 0.341500461f, -0.477125347f, 0.0143383741f, 0.359676361f,
+    0.927227616f, 0.232442468f, 0.54767859f, 0.405341268f, 1.10087442f, 0.482518882f,
+    0.589688659f, 0.352700859f, 0.952661872f, 0.310123235f, -1.32465017f, 1.23611879f,
+    0.0996393114f, -0.629447937f, 0.260761678f, -1.39942849f, -0.571209669f, 0.307004392f,
+    -0.266467899f, 0.604355574f, 0.33009252f, 0.232613415f, 0.630968869f, 1.25577021f,
+    -0.616139889f, 0.596038878f, 2.1833787f, 1.84135079f, 1.46124125f, -0.743691146f,
+    1.61561143f, 1.91382456f, 2.03188729f, 1.86160541f, 1.4328028f, 1.70623899f,
+    1.26124823f, -1.79222298f, 1.14922106f, 1.36894691f, 1.11918056f, 1.95069075f,
+    -0.287064642f, 0.657129467f, -0.0659475252f, 0.946409166f, -0.625318587f, 0.313477039f,
+    -1.09315085f, -0.0032786876f, 0.690721273f, 0.22908771f, 0.395901144f, 0.201985374f,
+    -0.0807985291f, -0.036920853f, -0.739351988f, 0.5019117f, 0.787716985f, -0.755550981f,
+    0.0694206506f, -0.314264596f, 0.0628868043f, -0.263113439f, 1.11122358f, -0.250379831f,
+    1.29056704f, -1.45024168f, 0.171196178f, -1.83116519f, 0.113148749f, 0.618173599f,
+    0.726890564f, -0.117562056f, 1.07482886f, -0.549574256f, 2.26461506f, -0.508555532f,
+    1.04192853f, -0.545312881f, -1.10572374f, -0.14292343f, 1.36309099f, 0.876701415f,
+    3.11865664f, -0.441968739f, 0.174546733f, -1.30656779f, -0.437310368f, -0.386171401f,
+    0.239922225f, -0.874618173f, 0.447815537f, -0.562787592f, -0.540406942f, -1.2288332f,
+    0.470448881f, -0.883939624f, 0.754112005f, -0.0752474368f, 0.38764149f, -0.866512358f,
+    -0.918582082f, -0.480017632f, -0.410256296f, -1.01788998f, 0.0568808913f, 0.257570595f,
+    0.241648376f, -0.655934274f, -0.340499043f, -0.875147521f, 1.36878538f, -1.32154799f,
+    1.48704684f, -0.125263989f, 0.000745117664f, -0.182931691f, -0.583889127f, -0.790172935f,
+    -0.615726531f, -2.58819723f, 0.89779073f, -0.395374209f, 1.05061841f, -0.402782649f,
+    -1.40418267f, -2.6789546f, 0.0357614383f, -2.0300374f, 0.488276243f, -2.5574441f,
+    1.60173512f, -0.831284285f, -1.83490455f, -3.1807909f, -1.64028311f, -3.80785441f,
+    -0.136234075f, 0.123011902f, -0.0781145543f, 0.184590742f, -0.11761561f, -0.394656241f,
+    -0.854217708f, -0.552359343f, -1.11081827f, 0.0110595524f, -0.67138958f, 0.129767567f,
+    -0.531760693f, -1.32265878f, -0.52147162f, -0.500971854f, -1.92427874f, -0.199353486f,
+    -0.97843504f, -0.403051138f, -0.359670758f, -0.0132812858f, -1.54867387f, 0.151998922f,
+    -1.42726707f, -2.41337919f, 0.115662724f, -1.58333886f, 0.438695282f, 0.105402529f,
+    -0.665075898f, 0.121533804f, -2.84130931f, -0.773985326f, -1.55929244f, -3.1838944f,
+    -1.7485019f, 3.33806682f, -1.40727317f, 1.46508074f, -1.59483933f, -1.10733831f,
+    -1.18750179f, -1.18842769f, -1.49734521f, 2.03141332f, -0.711408377f, -0.605653524f,
+    -0.0114756674f, -1.39360499f, -0.553097844f, -1.45840096f, -2.10415196f, -0.772920847f,
+    -0.965589404f, -0.471265048f, -0.718929768f, -0.714523256f, -0.42646125f, -0.595556736f,
+    -1.2156266f, -0.459330559f, -0.916463673f, -0.783815265f, 0.463913381f, 1.42563844f,
+    0.0832737982f, 1.30852008f, 0.517603159f, 1.1210624f, 0.398731053f, -0.463261902f,
+    1.26745844f, 0.979535699f, 0.0419786125f, 1.01635396f, 1.14397275f, 1.73989189f,
+    1.04818118f, -0.597580433f, 1.81051826f, -0.336768597f, 2.31603718f, -2.56932235f,
+    -0.860390127f, 0.0379248336f, -0.585913777f, 2.07147741f, 0.794869244f, 0.568951011f,
+    1.55643201f, 0.705373287f, 1.3398937f, 0.253131479f, -0.270797402f, 1.16445971f,
+    0.277894497f, -0.0724052638f, 0.0862479806f, 1.0897125f, 0.674562454f, 0.456170946f,
+    -0.229464307f, -0.736189663f, 0.148604587f, -0.335010886f, 0.347076744f, 0.490404248f,
+    0.488295615f, 0.775446951f, -0.35697037f, -0.88523531f, -1.06653583f, 0.251413167f,
+    -0.73938942f, -0.66277051f, -0.644259512f, -0.790972233f, -0.627088189f, 0.0636566281f,
+    -0.832249999f, -1.01190782f, 1.09528625f, -0.884879827f, -0.712613225f, -1.69643152f,
+    0.738381684f, -0.622581363f, -0.273715287f, 1.28461444f, 0.23944208f, 1.76187289f,
+    0.764227092f, -2.09187937f, -1.15516448f, -1.78470397f, 1.41283858f, 1.03446293f,
+    2.32642508f, -0.887838662f, 1.65083063f, -1.7973994f, 0.415508658f, -1.19655323f,
+    0.453855693f, -0.045652613f, 0.595712602f, 0.0558228493f, 0.206303626f, 1.05148816f,
+    -0.670423031f, -0.191573411f, 0.721706331f, 0.262637973f, 0.983645558f, 0.378374457f,
+    0.897212625f, 0.443402648f, 0.181511328f, -0.536882639f, -1.36970711f, -1.0937624f,
+    -0.959488213f, -0.540375948f, 1.07802749f, -0.345880657f, 0.721312284f, -2.25594425f,
+    -0.971094608f, 0.438586831f, -1.42322385f, 1.28967988f, 0.188458085f, 0.337536752f,
+    0.585238636f, 0.0966890603f, 1.33477747f, 0.85310328f, 0.965290725f, 0.726543069f,
+    -2.33810186f, 0.901199996f, -3.16214705f, 1.49097359f, 0.681182623f, -0.666269302f,
+    -0.0234448016f, -1.43743253f, -2.06921387f, 0.00755032152f, -2.11878896f, -0.718573689f,
+    0.593591928f, 0.432675213f, 0.560093045f, 0.900131881f, -0.12542361f, 0.888366222f,
+    -0.110344812f, 1.04575121f, 0.654099166f, 1.24252105f, 0.504583716f, 0.803042352f,
+    0.256524593f, 0.16947946f, 0.407452345f, 0.483076155f, -0.443027377f, 0.454685688f,
+    -0.447481751f, -0.532212138f, 1.79270816f, 0.549476564f, 0.502227783f, -0.398668587f,
+    1.80041444f, 0.333701342f, 2.01978207f, -0.698687553f, 2.55978322f, -0.241643697f,
+    1.16108859f, -0.707565784f, -0.202684611f, 1.56892729f, -0.503856659f, 0.0655332208f,
+    -0.0929923505f, 0.818142295f, -0.322163343f, 2.8386426f, 0.603280902f, 1.91192162f,
+    -0.189975023f, 0.779018581f, -0.411332846f, 0.603114545f, -0.831996441f, 0.625022233f,
+    0.213205308f, -0.3239066f, 0.305553019f, 0.014837265f, 0.195899636f, -0.218557104f,
+    -0.3501046f, -0.665264606f, 0.332263678f, 0.475917548f, 0.17046538f, -0.562429249f,
+    0.126848817f, 0.557108402f, -0.563508451f, -0.409746706f, -1.33280206f, -1.80763435f,
+    0.970149577f, -1.8097347f, 1.46749568f, -0.672820151f, 2.45523477f, 0.00842699409f,
+    -0.679206669f, -0.429295272f, 1.13401639f, -0.33901009f, 2.07681179f, 0.174857095f,
+    2.50786972f, 0.668903351f, 2.25679255f, -1.64893985f, 1.621696f, -1.92164683f,
+    -0.0217903741f, -0.651300013f, -0.995147407f, 0.397641122f, 2.99399304f, -2.53497934f,
+    3.2001183f, -3.43262839f, -2.38202357f, -1.58050144f, -2.00133681f, -0.020763386f,
+    0.735411644f, 0.162553996f, 0.410415202f, -0.640384316f, -0.38605243f, 0.161388502f,
+    -1.16036606f, 0.278449595f, 1.00822425f, 0.231790677f, 0.0910386443f, 0.0874672234f,
+    -1.01510859f, -0.369240701f, -0.908908904f, 0.674764633f, -0.0853851438f, 0.00439215451f,
+    -0.521034956f, 0.417278051f, -0.881767035f, 0.0210699141f, 0.110337362f, -0.351395637f,
+    -0.897606134f, -0.401626378f, 0.0886554867f, -1.15119386f, -1.89760697f, -0.57110858f,
+    -0.665583313f, 0.281567246f, -0.471578002f, -0.298027515f, -0.355744869f, -0.923781633f,
+    -1.8048017f, -0.113230333f, -2.31576586f, 0.902165055f, -1.26793444f, 1.91491699f,
+    -2.43655467f, 1.07931376f, 0.281067729f, 0.949197233f, -0.355248898f, 0.722253919f,
+    -0.320546895f, -1.14303637f, -0.359285474f, -0.547952533f, -1.08992589f, -0.683523059f,
+    -0.6981529f, -0.903846025f, -1.11918211f, -1.24519348f, -0.483175367f, -0.50459224f,
+    -0.469579428f, -0.878714144f, -1.04842329f, -1.44885898f, -0.488818258f, -2.58025861f,
+    0.121454358f, -1.69201505f, 0.504559755f, 0.239741325f, 0.763957322f, 0.0975732505f,
+    -0.0792606175f, -1.75165176f, -0.608846664f, -1.1813103f, -1.2519207f, -0.0910746008f,
+    0.882299304f, -0.553369284f, -1.31198525f, -0.100244075f, -1.26083112f, -1.83530891f,
+    -0.317557335f, -0.943009198f, 1.60973632f, -2.60066986f, -1.34945643f, 0.766572416f,
+    -1.70791721f, -0.355098844f, -2.36828256f, -2.65046883f, -0.142095506f, -1.64806616f,
+    -0.145923391f, 0.110432237f, -0.217473015f, 0.782186031f, 0.43629396f, -0.845192313f,
+    0.470950186f, -0.762888908f, 0.395100713f, -0.225573778f, 0.341910899f, 0.280447274f,
+    0.514084399f, 0.262013137f, 0.549719274f, -0.123031259f, 0.706253469f, 0.85323f,
+    0.632175922f, 0.736845672f, 0.79665941f, 0.261659294f, -0.676514089f, 0.265398085f,
+    -0.0770447254f, -0.0410069004f, 0.815489292f, 0.392760694f, 0.3797144f, 0.239686668f,
+    -1.24453175f, 0.17702882f, -0.162342221f, 2.34937859f, -0.621231258f, -0.330643356f,
+    1.71315312f, -1.31540632f, 0.240682408f, -0.708246887f, -0.456597567f, 2.07872677f,
+    -0.0124036241f, 1.64885342f, -0.955107331f, -1.46686268f, -2.10002923f, -1.30522895f,
+    -0.447377205f, 0.0375658199f, 0.314301401f, -0.34145686f, -0.745308936f, 0.219846219f,
+    -0.202578977f, -0.169945627f, 0.740029216f, 0.165283352f, 0.82296288f, 0.5569098f,
+    0.0957834497f, -0.700918794f, 0.274726599f, -1.17685127f, -0.122115314f, -1.14060211f,
+    -1.24403405f, -1.40176439f, -0.577083766f, 0.995118022f, -0.713246703f, 0.39725545f,
+    1.35815775f, -0.429230809f, 0.234582797f, -1.18077374f, 0.568953216f, 0.873431981f,
+    -0.216670394f, -0.151741207f, 1.06221151f, -1.66839027f, 0.431427032f, -1.04848492f,
+    -3.1385169f, 1.99385846f, -1.15406227f, 1.14546299f, 1.57075894f, -0.984596372f,
+    0.443231106f, -0.150516629f, -3.60216594f, 2.01835561f, -1.43451285f, 1.01921034f,
+    -0.165774435f, 1.13102365f, 1.44880378f, 0.249187604f, 0.471351117f, -0.522010505f,
+    0.6178267f, -0.610388279f, 0.393794626f, 0.271736264f, 1.36462629f, -0.793689668f,
+    0.826388419f, -0.146819234f, -0.324207306f, -0.302445352f, -0.400349736f, 0.307482183f,
+    -0.816148937f, 0.101934776f, 0.588583827f, -0.973602235f, 0.160924599f, 0.413589507f,
+    -0.339502394f, -0.147013068f, 0.379731357f, 0.782193661f, 0.250495881f, 1.50922537f,
+    0.708812833f, 1.3210212f, 0.699891329f, 1.3034445f, 0.816239178f, 1.93429923f,
+    3.47214627f, 0.969521523f, 1.39797568f, 2.39908528f, 1.95767105f, 2.49498367f,
+    1.76772308f, 1.23848999f, 0.456626952f, 0.433012843f, 0.987527192f, 0.593717158f,
+    -0.293125302f, 0.539749682f, 0.0150157809f, 0.786807001f, -0.169771492f, -0.142000094f,
+    0.0468406677f, 1.11354172f, -0.4826473f, -0.650042355f, -0.287846476f, 0.394602656f,
+    0.470792741f, -0.0222789049f, 0.221499756f, 0.666719079f, 1.40131545f, -0.276235968f,
+    0.757678151f, -0.101646125f, 0.660259426f, -1.50484371f, -0.560315132f, -2.03982115f,
+    1.13165462f, 0.0204583481f, 1.58377719f, -0.10115245f, -0.693044543f, -1.18843997f,
+    -0.978253245f, -2.23142672f, -2.8197825f, -1.75872386f, 0.916714549f, -2.0760386f,
+    0.0239712596f, -1.03136015f, -0.291740537f, -0.339004964f, -2.60108995f, -0.796180248f,
+    -0.765576899f, -1.29591537f, 0.885297596f, -0.66686517f, -0.460562676f, -0.558535337f,
+    -0.148539171f, -0.160049841f, 0.0580919161f, -0.0030913204f, 0.399603814f, 0.44639799f,
+    0.0817591548f, 0.265116453f, 0.122342944f, -0.190202892f, 0.196458057f, -0.044117298f,
+    0.918744802f, -0.239289731f, 0.0387994945f, 0.0825026035f, -1.59817779f, -1.22430646f,
+    -0.395330131f, -0.780927122f, -0.664102733f, -1.25551403f, -2.18673849f, 0.0627481341f,
+    -1.19461644f, -1.26565301f, -0.829935908f, -0.36939168f, 0.352181405f, -2.05338621f,
+    0.106409788f, -1.02263522f, -2.43366289f, 0.590074956f, -2.17819023f, -2.8063581f,
+    1.02188635f, 0.263191402f, -0.175200582f, -0.156659931f, -1.92224038f, 0.610443354f,
+    -1.06950068f, -0.774141788f, 1.08041322f, -0.555140615f, 1.5659287f, -0.478072107f,
+    0.479259282f, -0.354188919f, 1.26666784f, -0.582451224f, -1.24833286f, -0.191338718f,
+    -0.567591429f, 0.661991894f, 0.0606334805f, -0.00443285704f, 0.798490942f, 0.241470441f,
+    -0.25046891f, -0.68635571f, -0.282356054f, 0.905184031f, 1.12802517f, -0.388222009f,
+    1.43830884f, 1.13320529f, 1.36783719f, -1.13393879f, 0.549605787f, -0.932261527f,
+    1.16317534f, 1.12959802f, 0.980282187f, 2.8392446f, -0.23453781f, -0.586666942f,
+    0.367043108f, 0.516118526f, -0.631683469f, 3.56408596f, 0.432881653f, -0.0219511539f,
+    -0.970574439f, 1.22007394f, -1.99607909f, 0.600558102f, 0.267237216f, 0.28251183f,
+    -0.62675631f, -0.262426227f, 1.95713866f, 0.604845107f, -0.249285385f, -0.723476052f,
+    -0.312097907f, 0.526509225f, 0.16773051f, 0.946626782f, -0.462882847f, 0.296354741f,
+    0.0560797751f, 0.341320455f, -0.00326016545f, 0.541273892f, 0.716104329f, 0.588690042f,
+    -0.178994596f, -0.000483468175f, 0.195197999f, 1.19869161f, 0.381393492f, 0.808861613f,
+    0.0792517662f, 0.0568512976f, 0.874884844f, -1.6514641f, 0.879906058f, -0.746301174f,
+    0.464733541f, 0.0798117667f, -0.0364769399f, -0.510188282f, -1.14917564f, -0.78813231f,
+    -0.54781276f, -0.76612699f, 2.50928664f, 0.601609826f, 1.22111619f, -0.12846376f,
+    0.749274313f, -0.062244907f, -0.171323508f, 0.610806823f, 2.01296377f, 1.60044265f,
+    1.63325655f, 1.39511132f, -0.253953308f, 2.49758267f, 1.50015116f, 2.84191632f,
+    -0.320730329f, 1.27467334f, -0.749408126f, 1.36457145f, 0.730800629f, -0.518343329f,
+    0.041258499f, -0.198795438f, 0.709250212f, 0.822722733f, -0.333357275f, 0.658611238f,
+    0.205072612f, -0.149105072f, 0.0642186701f, 0.233382061f, 0.760163188f, 0.166204721f,
+    1.63639915f, 0.0277714431f, 0.111387186f, -1.4407382f, -0.938398361f, -3.02830601f,
+    0.145070866f, 1.10630929f, 0.865453005f, 0.911309123f, 0.976272345f, -0.0815397203f,
+    -0.379113525f, -2.06553531f, -3.44887137f, -0.532365322f, -4.29330444f, -2.40784287f,
+    0.791849136f, -3.40324831f, 0.920961797f, -3.79515839f, -2.02287364f, -0.432723373f,
+    -2.27003479f, -1.3071475f, 0.856294036f, -1.85471153f, -0.0368882231f, -1.64085639f,
+    -1.20306778f, 0.353305042f, 0.422302395f, -0.217336118f, -0.377511084f, -0.380042762f,
+    0.110072836f, -1.00659573f, -0.857215643f, -0.414616048f, 0.156052455f, -0.713705242f,
+    -0.297441512f, -0.830873966f, 0.543721497f, -0.188197896f, 0.11741665f, -1.16978228f,
+    -0.254156142f, -0.164634079f, 0.218394518f, 0.172486052f, 1.44210005f, -0.207554892f,
+    0.326346219f, -0.727197766f, -1.08580935f, -0.847755432f, 0.305855632f, 0.0788633823f,
+    0.319655657f, 0.474884689f, 1.59559023f, 1.00531697f, 1.63597155f, 0.0927968696f,
+    3.09614372f, -1.67889059f, 4.96779537f, -1.73390841f, -0.418587029f, 1.74842834f,
+    0.598504424f, 1.14408028f, 1.58344865f, 1.79986262f, 3.03411508f, 0.374795914f,
+    0.689121485f, -1.56262171f, 0.451111794f, -1.27730441f, -0.633408368f, -0.563028395f,
+    -0.11371161f, -0.104905188f, 0.0139587931f, 0.0108632669f, 0.407300889f, -0.0252500549f,
+    0.210786253f, -0.642554641f, 0.365750253f, -0.910092413f, 1.43836057f, 0.0827621073f,
+    0.359137505f, -1.39126015f, -0.60702014f, 0.273378849f, -0.55658114f, 0.467786402f,
+    -0.19117488f, 0.473882824f, 0.815976143f, -0.851721346f, -0.304011285f, -0.14438203f,
+    -0.0594349504f, 0.128174126f, -0.281803071f, 0.639901519f, 0.856201053f, 0.355681062f,
+    -2.01784158f, 0.333312809f, -1.83325279f, 1.71588027f, 0.566991866f, 1.3734169f,
+    1.54037189f, 0.352604926f, -2.51975274f, -1.25673246f, -2.88650298f, 1.21922982f,
+    -0.783699334f, -1.41515064f, -0.515500307f, -1.99398959f, -0.146859407f, 0.108118773f,
+    -0.18870762f, -0.0544349626f, -0.899968386f, -0.677823067f, -0.566721201f, -0.691440225f,
+    -0.960495293f, -0.425811052f, -1.00875521f, -1.53178191f, -0.126167268f, -1.59756529f,
+    -0.833079338f, -0.116158187f, -1.31147957f, -0.0948346704f, -2.01829171f, -0.699615955f,
+    0.187134832f, -0.786607921f, -0.729112446f, -0.432996809f, -0.586878538f, -1.24272776f,
+    -2.98301983f, -1.19439089f, 1.24693429f, 0.421667397f, 1.14624035f, -1.21860456f,
+    -0.605297267f, -0.618986666f, 1.24904621f, -0.0523681194f, 0.627501726f, -0.660233617f,
+    0.279797465f, -1.78157377f, -0.503575861f, 1.24847531f, -0.387974024f, 0.623356819f,
+    -0.190097481f, 0.357546657f, 0.124145731f, -0.560937047f, -0.376266956f, -1.2188046f,
+    -0.492882848f, -0.537324905f, -0.145532817f, 0.318837047f, 0.780664802f, 0.37347582f,
+    -1.03503752f, -0.168068975f, -0.977259099f, -0.470744163f, 0.058032006f, 0.548796594f,
+    -0.322682321f, -0.138952345f, -3.26595473f, -1.1732434f, -2.57339406f, -0.358343452f,
+    -1.48255491f, -0.618433774f, -0.190514266f, -0.539483905f, -2.53520679f, -0.464199662f,
+    -2.58698893f, 0.323561609f, 0.247155592f, 0.289025724f, 1.83044219f, -0.536594152f,
+    0.986843228f, -1.32357907f, 0.517787158f, -0.741659999f, 0.798276901f, 1.14056611f,
+    2.44999957f, 0.866249263f, -0.674501657f, 0.685531497f, -0.0293827131f, 0.121972442f,
+    -0.153072566f, 0.381502748f, 0.248052597f, 0.526518345f, 0.256700277f, -0.531300128f,
+    0.388295382f, 0.950649858f, 0.827756286f, 0.767439008f, 0.974306345f, 1.02471519f,
+    -1.09482026f, -0.85121417f, -0.416752577f, 0.0207621753f, -0.0913940147f, 0.63691175f,
+    -0.982604325f, 0.224169165f, -1.33086061f, 0.33352679f, -0.624317169f, 0.793445826f,
+    -0.398100257f, 0.279532582f, -0.170260504f, 1.15153933f, 0.731488645f, -0.479657412f,
+    -0.27393952f, -0.57758069f, 2.78090382f, 1.18895829f, 2.46708798f, 1.29134607f,
+    1.05048048f, 1.00810611f, 1.11204946f, 1.746557f, 2.05791998f, 0.00660292059f,
+    2.38563609f, 1.00431395f, 1.16871691f, -0.0664702654f, 1.58445215f, 0.473596871f,
+    -0.917562127f, 0.572677732f, -0.151504755f, 1.07462323f, 0.051321432f, 0.915694892f,
+    0.015573442f, -0.589109898f, -1.15575278f, -0.438597322f, -0.835140407f, -0.308367312f,
+    0.430940062f, -0.0763975233f, 0.843490362f, -0.563052654f, 1.16113472f, -1.42698443f,
+    0.772834837f, -2.15575933f, 0.185644031f, 1.1020447f, 0.104972757f, 0.467704386f,
+    0.621937811f, -1.24967682f, -0.302434176f, -1.69747305f, 0.561684072f, 0.291412264f,
+    -0.0896055549f, 1.14409244f, 0.348240852f, -2.26255393f, -0.912858784f, -0.469170362f,
+    -1.0421313f, 1.03904796f, -0.280577213f, 0.60520947f, 1.89293337f, -3.09293389f,
+    0.91247648f, -0.504760027f, -0.488716424f, 1.74689281f, -0.445808887f, -0.823105454f,
+    -0.712760091f, 0.658702254f, -0.527992606f, 0.134729937f, 0.380513638f, -0.7090801f,
+    0.632309616f, -1.52325618f, 0.571901262f, 1.02701294f, 0.550040126f, 0.76118952f,
+    0.292888492f, -0.529526651f, 0.119289443f, -1.23939204f, -0.635902822f, -2.22676563f,
+    0.329634607f, -1.6747818f, -1.54211438f, -1.13875318f, -0.878213286f, -0.566586137f,
+    -1.08253956f, -1.66573775f, -1.01607955f, -2.48936391f, -0.212656736f, -1.22704387f,
+    -0.649483085f, -1.19233334f, 1.28837049f, -1.73959303f, -0.56796062f, 0.566693604f,
+    -0.489375412f, 0.962749481f, 1.82348812f, 1.08686566f, 1.00953126f, -3.64272499f,
+    0.224616408f, -1.41633058f, -0.465973705f, 0.956227839f, 1.23105919f, -0.214552075f,
+    -0.0608353466f, -1.51921582f, 0.349716187f, -1.23074985f, -0.678530455f, -0.593720615f,
+    -0.901671708f, -0.16099894f, -0.658283591f, -0.787604451f, -0.417816341f, -0.631452441f,
+    -0.907802463f, -0.850726306f, -0.152414173f, 0.0878714323f, -0.663883269f, -1.78760147f,
+    0.710227549f, -0.5471856f, -0.310091376f, 1.02669215f, -0.349567533f, 0.170489684f,
+    -1.59736526f, -1.73122597f, -0.913517714f, -1.33870184f, -0.88546133f, 0.946244001f,
+    -0.481910884f, 0.557221174f, -2.11142421f, 0.753892779f, -1.0004046f, 1.11526644f,
+    0.0981916264f, -0.310015351f, 0.675571382f, -0.982985854f, -0.380949587f, -0.167519569f,
+    -0.187143564f, 0.392114013f, 0.716797948f, -0.612033427f, 0.189992353f, -0.339531243f,
+    0.0273705721f, 1.63313985f, 0.352041751f, 1.30799031f, 0.239177614f, -0.39220506f,
+    1.36516714f, -0.227220327f, 0.84093219f, 1.13902879f, 1.86341739f, 0.373104006f,
+    0.588225484f, -0.954599023f, 0.504371762f, -0.0899376199f, 1.66228437f, 0.418859124f,
+    0.732491493f, 0.828848302f, 0.552897394f, 0.435901821f, 0.539030075f, -1.12454462f,
+    0.353547215f, 2.46267843f, -0.0534369051f, 2.45603824f, 0.860985219f, 0.385326684f,
+    0.664282799f, 0.672963142f, 0.52315706f, 0.346081257f, 1.03010654f, -2.78870153f,
+    -0.302617669f, -1.53742373f, -0.255502969f, 0.235126138f, -1.75391209f, 0.397069752f,
+    1.46762753f, -1.91905141f, -0.166865736f, -0.944556475f, -0.0550298989f, 0.40535444f,
+    0.346436262f, 0.110141411f, 0.518971264f, -0.0539412796f, -0.997352302f, 1.09787047f,
+    0.113542736f, 0.116672009f, 0.332093537f, 0.62442255f, -0.512346685f, 0.449414253f,
+    1.31846178f, 0.299796939f, 1.50959527f, -0.519374013f, 1.58256996f, -0.119680524f,
+    0.3909477f, -1.58664525f, -1.21271122f, 0.376748443f, -0.891944945f, 0.786614895f,
+    0.983828783f, 0.714116216f, -0.617729723f, -0.0585962236f, -1.43273056f, -1.41909242f,
+    -0.961495042f, -0.0481939316f, 1.48966074f, 1.44264269f, 2.22214293f, 1.28790784f,
+    -3.62982225f, -1.1337589f, -2.34114504f, -1.51369596f, 1.01965272f, -1.42181289f,
+    1.82932472f, 0.72451061f, -2.74013209f, -0.761267841f, -3.1240747f, -1.2696352f,
+    0.187819183f, -0.894809246f, -0.0738969594f, -0.368572503f, 0.000466801226f, -0.340349108f,
+    0.222431064f, -0.719160914f, 0.0898523554f, -0.482562691f, -0.155767068f, -0.337192595f,
+    -0.344517231f, -0.0307555795f, -0.945246994f, -0.0470660105f, -0.170253873f, -0.592770934f,
+    -0.277335823f, -0.539188862f, 0.491530836f, -2.14620471f, 0.387322813f, -1.65016103f,
+    -0.460243374f, -0.656793058f, -1.06145775f, 0.194036692f, -0.429475427f, -0.770547748f,
+    -0.361679286f, 0.594542503f, -0.294423848f, 0.959836483f, -1.33943355f, 0.617384911f,
+    1.27169168f, -1.12111127f, 0.973979831f, -1.16881835f, 0.116070449f, -1.62943983f,
+    0.740995765f, -1.9884727f, 1.11272192f, -2.05357242f, 1.14343381f, -0.810320258f,
+    -0.151388302f, 0.287288785f, -0.197597072f, -0.728326023f, 0.154999748f, -0.276879936f,
+    0.0794901848f, -0.418774217f, 0.517701626f, 0.293687165f, 0.331002682f, -0.699944735f,
+    -0.300198406f, -0.348686039f, -0.111724794f, -0.811154604f, -0.855704725f, -1.25536561f,
+    0.179377645f, -0.944881141f, -0.308322847f, 0.954666615f, -0.393661618f, 0.265477479f,
+    0.31265834f, -0.106441557f, 0.867099643f, -0.248486966f, -0.853386343f, 0.353736728f,
+    -0.430221558f, 0.611265063f, -0.708373427f, 0.0861033648f, -1.08604157f, 1.10639215f,
+    -0.228491157f, 1.01819909f, 0.79306972f, 1.3858161f, -0.690687835f, 0.342097193f,
+    -1.12495279f, 1.77339673f, 3.53774214f, 1.48499489f, 3.40667725f, 2.35694027f,
+    1.18133414f, 0.248269513f, 0.929658413f, -0.0588589422f, -0.159921825f, 0.103050455f,
+    0.262997895f, 0.180002242f, 0.33913663f, 0.0590006411f, 0.593616366f, -0.481279671f,
+    0.901518047f, -0.0480006635f, 0.792771399f, 0.310739219f, 0.0115054194f, -0.188385278f,
+    -0.222671449f, 0.241575092f, 0.479964435f, 1.31073678f, 1.41512883f, 1.42355824f,
+    0.0777398497f, -0.271371543f, 0.3768484f, 0.172859713f, 0.591648698f, 2.35010767f,
+    0.934806585f, 1.54793525f, 1.73654962f, 0.104785226f, 1.14628828f, 0.463307917f,
+    -0.693243027f, -0.734459519f, -1.26977754f, 0.540984988f, 0.773798943f, 0.905047476f,
+    -0.0471021831f, 1.80167365f, -0.915615082f, -1.46105421f, -0.56558609f, -0.205372572f,
+    0.314927965f, -0.56266886f, 0.0926958621f, 0.479954243f, 0.574627995f, 0.460220248f,
+    0.690247834f, 0.0517359972f, -0.605604112f, -0.278945148f, 0.386985719f, 0.679263055f,
+    0.737624824f, 0.357514024f, 0.635686874f, -0.0413636863f, 0.637683809f, -0.723137617f,
+    0.991826653f, 0.381614089f, 0.624890327f, 0.0654899925f, 0.935985863f, 0.505857527f,
+    0.970716119f, -0.599929512f, 1.17384148f, -0.127457917f, -1.15453064f, -0.439123273f,
+    0.459930331f, -1.29666793f, 0.0961865485f, -0.0285708904f, 3.05720568f, 2.36924076f,
+    1.4689815f, -0.462846935f, 2.32707167f, -0.26099211f, 0.604849935f, -1.45436597f,
+    1.45353639f, -1.00482833f, 2.69001603f, 1.30508232f, 1.17704809f, 2.25321674f,
+    0.946939707f, -0.627906919f, 0.426633716f, -1.04229414f, 0.527176201f, -0.52611059f,
+    0.366200566f, -0.434755623f, 1.13690877f, -0.211717159f, 1.276788f, -0.882118046f,
+    -0.382635325f, -0.603686512f, -0.146801382f, -0.40395087f, -0.726884186f, -2.02757645f,
+    -1.22565591f, -2.0721097f, 0.380872369f, 0.99940002f, 0.136678874f, -0.718703926f,
+    -0.00927332044f, -2.76359797f, 0.064920187f, -1.9483242f, -0.24646087f, 0.907971799f,
+    -0.674075961f, -0.462146103f, -0.672677875f, -1.79736018f, -2.81509376f, -0.608086824f,
+    -1.79641366f, -1.43491542f, -1.90879524f, -3.14597034f, -0.156173483f, 1.41928041f,
+    -1.15660071f, -1.36100674f, -0.0702432543f, 0.749534726f, 1.34459519f, -1.66076708f,
+    0.0243721604f, 1.72807574f, 0.818402886f, 1.34769344f, 0.508430302f, 0.644586444f,
+    0.599119127f, -0.738998294f, 0.275805086f, 0.971357048f, 1.12259459f, 0.597197652f,
+    1.06565213f, 0.37628597f, -0.122345597f, 0.186332867f, 2.28937626f, 0.371085912f,
+    0.363642305f, 0.0760459155f, 1.73475242f, 0.374894738f, 2.69835806f, 0.598186612f,
+    2.21827364f, 1.05812693f, 0.0636130422f, 0.298440993f, 1.07662344f, 0.115485504f,
+    1.28572381f, 0.382727355f, -0.886809766f, 1.829023f, -0.291502923f, 1.78602982f,
+    0.375234872f, 2.62608385f, 0.79974252f, 1.43555832f, -0.791759491f, 0.705427587f,
+    -2.23432708f, 2.60105705f, 0.393243372f, 1.73123574f, 0.72371906f, -0.0115321279f,
+    -0.764390826f, -0.475678325f, -0.693066895f, -0.27078867f, 0.349005938f, -0.101094842f,
+    -0.191839129f, -0.719009638f, -1.20409453f, 0.19598794f, -0.980667949f, 0.166326702f,
+    0.102932468f, 0.301551193f, -0.40336436f, 0.187419713f, -0.215877533f, -0.372534335f,
+    -0.869758487f, -0.122791901f, 0.635035753f, -0.265806705f, 1.27733207f, 1.59045315f,
+    0.0142300427f, -0.0173396021f, -0.119000882f, -0.0610104352f, 0.0805175006f, 0.0339857414f,
+    0.722632229f, 1.02582014f, -0.152104586f, 1.73376334f, -0.745926857f, 1.04407144f,
+    2.51382494f, -0.0358506367f, 0.790658772f, 0.672186852f, 0.966412306f, -0.662946701f,
+    0.166746825f, 1.10539567f, 2.4661119f, 0.189756915f, 2.22032166f, 1.45020401f,
+    1.04591966f, 0.254188806f, 1.38362861f, -0.00714214146f, -0.146559432f, -0.137671307f,
+    -0.25849399f, -0.333635747f, 0.680367589f, 0.415059149f, 1.03225124f, 0.61445117f,
+    0.138629645f, -0.353555858f, 0.172198653f, -0.17591545f, 1.46823239f, 0.469656676f,
+    0.32556954f, 1.28888106f, -2.16353607f, 1.5818404f, -0.6637339f, 1.29411674f,
+    1.19401026f, 0.485587656f, -0.341274858f, 0.798940718f, -0.135739475f, -0.133558273f,
+    0.805806696f, 0.768011391f, 0.65404135f, -0.0851048082f, 0.432082504f, 1.01460958f,
+    -0.584148288f, 0.274727017f, -0.184433818f, 1.12357485f, 2.09108138f, 0.139514476f,
+    1.55192459f, -0.307727307f, -1.68425786f, 1.17875075f, -1.6286422f, 1.52357697f,
+    0.702199578f, -0.101898983f, 0.699934721f, -0.0165697243f, 1.1337378f, 0.0907931924f,
+    0.666989923f, 0.714278042f, 0.58400172f, 0.119345859f, 0.512979865f, -0.113646001f,
+    1.11316299f, 0.957820535f, 0.943998754f, 1.29164922f, -1.63755035f, 1.22997427f,
+    -1.37849486f, 0.214864641f, -0.364940822f, -0.133732885f, -0.66288805f, -0.113698542f,
+    -0.752074361f, 0.527158558f, -1.65628314f, -0.0357487127f, -0.720153451f, 0.766191959f,
+    -0.963373542f, -0.132270336f, 1.10539401f, 2.6192975f, -0.671785593f, -0.255433708f,
+    0.808550417f, -1.77311635f, 0.720005155f, -0.6554299f, -0.976715446f, 1.12050986f,
+    -0.557216108f, 2.01000357f, 1.63850188f, 0.431308329f, 1.02280068f, 1.29357493f,
+    -0.920763969f, 0.0131440163f, -0.277792782f, 0.0906026289f, 0.180594087f, -0.681260228f,
+    -0.384726286f, -0.158666641f, -0.741247535f, 0.14502877f, -0.13852872f, -0.0289041251f,
+    -0.725854039f, -0.538401246f, -0.730512798f, 0.46606788f, 0.671804905f, -0.229285449f,
+    -2.27864695f, -1.29215252f, -0.832833767f, 1.55838752f, -1.86998761f, 1.93727314f,
+    -0.768530905f, -0.830839753f, -1.27679729f, -1.19470358f, 1.25836527f, -0.0361285284f,
+    -0.370216727f, -0.114933804f, -1.29038668f, -0.513073862f, -0.395652533f, -2.67044878f,
+    1.60405087f, -1.60367548f, 1.68035364f, -0.355001599f, 2.07829762f, -1.15242183f,
+    0.327813327f, -2.557096f, 1.03407753f, -1.73680103f, 0.725988865f, -0.185674325f,
+    0.975352108f, 0.619941056f, 1.32080126f, 0.230277017f, -0.298447281f, -0.00258105248f,
+    -0.626517832f, 0.381723106f, -0.303569376f, 0.770837605f, 0.0774061829f, 1.23284435f,
+    -0.211232126f, -0.704777062f, -0.326483876f, -0.484779745f, -0.24553372f, 1.10466576f,
+    1.29255342f, 1.77970564f, 0.378100425f, -0.110822894f, 1.10019588f, -0.210907191f,
+    0.54719013f, 0.292691469f, 1.27295887f, 1.53404105f, 0.310892463f, 0.605400562f,
+    0.766685963f, 1.1490345f, 0.279192656f, 1.05471373f, -2.00999093f, 1.86651707f,
+    0.25548768f, 2.71279025f, 0.812196732f, 1.28583717f, 0.138937414f, 0.596630573f,
+    0.471693099f, 1.1814729f, -0.871329665f, 1.70329928f, -0.613817096f, 0.947556496f,
+    0.152479142f, 0.343172371f, -0.37031275f, 0.0176607706f, 0.202226147f, 0.191098437f,
+    -0.184345543f, 0.225251943f, -0.506193578f, 0.367503762f, -0.057647571f, -0.312884748f,
+    0.369700134f, 0.363011718f, -0.0459952652f, -0.350229025f, -0.906503379f, -0.982846439f,
+    0.810753345f, -0.693624854f, 0.0833772644f, -0.189091861f, -0.797521114f, 0.959904671f,
+    -1.75344872f, -0.0490136743f, 0.58313638f, -0.149663493f, 0.0805282146f, -0.811264277f,
+    0.411988854f, -1.37294638f, -0.3402147f, -0.745366454f, 1.93733668f, -0.734301329f,
+    1.70428467f, -0.381906867f, 1.16393149f, -0.883846879f, -0.541927397f, 0.0474945456f,
+    0.421721876f, -0.128352121f, 2.57097697f, 0.940547585f, 1.02152848f, -0.806737363f,
+    -1.13248825f, -0.741330683f, -1.11326528f, -0.584133565f, -1.03142893f, -1.55131078f,
+    -0.877144098f, -1.42078125f, -1.79144621f, -0.868366599f, -0.935172141f, -1.34276736f,
+    -1.02783406f, -1.69862545f, -0.871695817f, -1.50417256f, 0.758466959f, 0.333802998f,
+    0.273310989f, -0.878455162f, 0.648461938f, -1.13407636f, -0.468322664f, -0.592258215f,
+    0.805475652f, -0.828303337f, -0.0979325995f, -1.57537937f, -0.441352099f, 0.442578256f,
+    -1.85446715f, 1.13864398f, -1.02746081f, 0.453688204f, -1.21679521f, 0.630716383f,
+    -1.01561713f, 0.22846891f, -1.65237093f, -1.24577987f, 0.285968721f, 0.34989965f,
+    0.82531631f, 0.987621069f, 0.527718365f, 0.207064345f, 0.799036324f, 0.664564312f,
+    0.580007613f, 0.315022856f, 0.563670635f, 0.230819985f, 0.438564152f, 0.253639728f,
+    0.741283655f, 0.064775914f, 0.174894243f, -0.242580235f, 0.256006271f, 0.229172319f,
+    0.811493099f, -0.348293155f, 0.570601285f, 0.097572431f, 0.942815423f, 1.39002395f,
+    1.63505626f, 1.05517399f, 0.205864638f, -0.00106392009f, 0.780276418f, -1.78859615f,
+    1.11905301f, 0.212225527f, -0.254850209f, 0.386627525f, -0.0508717597f, 0.414651573f,
+    0.732338309f, 0.566278934f, -0.947662592f, -0.441434354f, -2.40714002f, -2.44455338f,
+    2.6084888f, -1.14364159f, 3.68240595f, -0.0266824365f, -0.27412498f, -0.83050859f,
+    -0.335159481f, -2.62349534f, 0.223992392f, -1.01770759f, 0.733003438f, -1.08573592f,
+    -0.101373225f, 0.59019208f, 0.180633172f, 0.32369709f, 0.36197859f, -0.468543589f,
+    0.29511717f, -0.283015668f, -0.013806548f, -0.387196183f, 0.428006649f, -0.127721056f,
+    -0.0940038115f, 0.39947322f, 0.266183078f, 0.358465433f, 0.399247974f, -1.17053199f,
+    0.531321824f, 0.546497643f, -0.157679737f, 0.487466186f, -0.317738533f, 1.10173714f,
+    0.151536435f, 0.168651402f, 1.33994865f, 0.866422594f, 0.682677507f, -0.599033237f,
+    0.270880103f, 0.195377067f, -0.642744005f, -0.351658583f, 0.705999017f, 1.06269836f,
+    -2.21629643f, -0.65782547f, -0.536466241f, 0.969233215f, -1.36539209f, 0.262290984f,
+    0.641568303f, 0.353146613f, -1.0398165f, 1.40336418f, 0.95117718f, 0.921127081f,
+    -1.55780876f, 0.42737639f, -0.627236664f, 0.210672259f, -0.551584423f, -0.0742082298f,
+    0.688006401f, -0.617396414f, -0.656969368f, 0.45618549f, 0.208773226f, 0.340396404f,
+    -0.728688478f, 0.164274991f, -0.642481863f, -0.508753777f, -0.615605712f, -1.27495408f,
+    -0.501742542f, -0.753534555f, 0.279789984f, -1.58396518f, -0.100974917f, 0.614267349f,
+    -2.93521118f, -1.1070596f, -1.30707324f, -0.906187057f, -0.694340587f, -2.18101263f,
+    -0.392606795f, -0.747120202f, -0.434580505f, -1.11019671f, 0.688495219f, 0.162167281f,
+    0.51377821f, 1.54247475f, 0.624765873f, 2.96909213f, -0.167388767f, -1.67517185f,
+    1.62493587f, 0.663918078f, 1.26436687f, -1.37805247f, 0.329349697f, 0.619854927f,
+    1.04924214f, 0.386457592f, 1.57385576f, 0.358336419f, -0.661982238f, 1.10772991f,
+    0.0531502664f, 0.500880003f, 0.46137464f, 0.92547524f, 0.991194487f, 0.5839957f,
+    -0.834593892f, 0.181830883f, 0.0376493037f, 0.418563128f, 1.45743608f, 2.09858561f,
+    1.15998614f, 2.19879174f, 1.25648487f, 0.767534733f, 1.30470848f, 0.558423877f,
+    0.392835408f, 1.90780318f, -0.49875319f, 1.16581476f, 1.13627899f, 1.3579179f,
+    0.735267401f, 0.188626558f, 0.271162182f, 1.28064215f, 0.846098185f, 3.3360219f,
+    1.51779795f, 4.02323818f, 0.283974797f, 1.57701564f, 2.29602361f, 2.04653859f,
+    1.73156035f, 2.8329196f, 1.6767422f, 3.50238562f, 1.30404127f, 0.316214144f,
+    -1.28735805f, -0.62079668f, -1.38580775f, -0.450560808f, -0.186096609f, 0.601189375f,
+    0.26588136f, -0.213657632f, -0.973613977f, -0.109458692f, -0.690241158f, -0.670991302f,
+    -0.728328049f, -0.0249587893f, -0.977336228f, -0.983949304f, -1.90761101f, 0.255103052f,
+    -0.600427508f, 0.27379626f, -2.76280618f, -2.40664959f, -3.69302344f, -1.37471974f,
+    -2.36237359f, -0.206348032f, -0.104493231f, 0.197016463f, -1.62341344f, -0.446072489f,
+    -3.81671667f, -0.761239052f, -0.494723797f, -0.639970064f, 1.6163063f, -1.92226744f,
+    -2.37455177f, -3.44429255f, -1.59986591f, -4.08712101f, 0.257780433f, -1.15845227f,
+    1.82627165f, -2.72448707f, -4.79249048f, -2.49916744f, -2.91789389f, -4.45742035f,
+};
+
+inline constexpr int64_t kH3Down3dInCh = 32;
+inline constexpr int64_t kH3Down3dOutCh = 32;
+inline constexpr int64_t kH3Down3dT = 3;
+inline constexpr int64_t kH3Down3dH = 4;
+inline constexpr int64_t kH3Down3dW = 4;
+inline constexpr int64_t kH3Down3dOutT = 2;
+inline constexpr int64_t kH3Down3dOutH = 2;
+inline constexpr int64_t kH3Down3dOutW = 2;
+
+inline constexpr float kH3Down3dGolden[] = {
+    0.0593633503f, 0.854409516f, 0.282673329f, 0.0519230068f, -0.348627985f, -0.730444133f,
+    -0.670470595f, -1.10369039f, -0.46676138f, -0.0190521628f, 0.0824816599f, 0.863686442f,
+    -1.29026628f, 0.839108646f, -0.182065532f, 1.4816463f, 0.464630187f, 0.27641201f,
+    0.664912105f, 1.01213968f, 0.957999527f, 0.890960574f, 1.23636019f, 1.302966f,
+    -0.92121011f, -0.803000212f, -1.04447281f, -0.898911238f, -0.759400845f, 0.176139563f,
+    -0.751273453f, -1.61597681f, 0.155430526f, 0.404587924f, 0.108482309f, 0.0952067003f,
+    -0.641188145f, 1.2977351f, 0.488934398f, -1.40841997f, 0.31691879f, -0.454471767f,
+    0.369484246f, 0.262270004f, 1.11643767f, -1.35455489f, -0.260002643f, -0.918019593f,
+    -0.486029178f, -0.833315372f, -0.280989051f, -0.115407094f, -0.206099719f, -0.172068134f,
+    1.43868816f, -0.295117736f, 0.068095997f, 0.382949263f, 0.0272652283f, 0.256291926f,
+    0.8549999f, 1.10717738f, 1.07490957f, 0.942138255f, 0.794266522f, 0.455329359f,
+    0.442891359f, 0.321718335f, 1.05304241f, -0.978982151f, -1.20742726f, -1.79241514f,
+    0.340209931f, 0.509981871f, -0.115671337f, 0.5931499f, 0.307853699f, 0.316330999f,
+    -1.30492342f, -2.00652361f, -1.07159734f, -0.822180748f, -0.780112743f, -1.20236349f,
+    -0.418979824f, -0.36726737f, -0.535298645f, 0.0158574842f, -0.0520883016f, -0.383299142f,
+    -0.296979636f, -0.102216527f, -0.92912519f, -0.372703373f, -1.42185533f, 0.298323035f,
+    0.326251328f, 0.852389455f, -0.182163611f, -0.449586123f, -0.614613771f, -0.879315674f,
+    -0.0236094613f, 0.783725202f, -0.390048146f, -0.0335095152f, 0.640842199f, 0.776861012f,
+    -0.000458281487f, -2.0383265f, -1.82477331f, -3.14902091f, 0.0543720424f, -0.226545557f,
+    -0.0882864147f, 0.469824195f, 0.371305913f, -0.69052279f, 0.0897778869f, -0.872834325f,
+    -0.428034782f, -1.40485168f, -0.258498967f, -0.687058568f, 0.317887783f, 1.29008448f,
+    0.320992053f, 0.902184606f, -0.238192186f, 0.400717437f, -0.414333761f, -1.23534763f,
+    0.843887806f, -0.318893284f, 0.336444288f, -1.16321933f, 0.0235498846f, 0.366782665f,
+    -0.0484051071f, 0.919250607f, 0.700081348f, -0.754561663f, 0.57846576f, -0.243830934f,
+    -0.444780201f, -0.732186794f, -0.252744704f, -0.0470120385f, -0.302375674f, 1.43302131f,
+    2.57794166f, 1.66174102f, 0.657335162f, 0.854263425f, 0.386012852f, 0.241392091f,
+    0.0521072559f, 0.525878847f, -0.946994662f, 0.486572713f, -0.33931917f, -0.229010001f,
+    -0.00244414061f, -0.735577345f, -0.553558767f, 1.03944421f, 0.14553684f, 0.196823418f,
+    0.347101122f, 0.561992586f, -0.358297318f, -0.149445564f, -1.47662258f, -1.34118938f,
+    -0.610663772f, 0.545788765f, -1.26432514f, -0.0591426268f, -0.0459947959f, 0.492431641f,
+    -0.787451148f, -1.56436539f, -0.45289579f, -0.495435566f, -0.730618656f, 0.559126973f,
+    -0.528380036f, -0.104648829f, 0.620331466f, -0.534864128f, 0.538309753f, 0.574474752f,
+    -0.128882498f, 0.446184605f, 0.401505709f, -0.30383575f, -1.97197509f, 0.475587219f,
+    -2.22417927f, 1.16275477f, -0.241254419f, -0.457704395f, -0.0738358647f, 0.0567373224f,
+    0.016951751f, 1.15956664f, -1.38928735f, 0.901893139f, 1.31106472f, 0.980654955f,
+    0.359632134f, 0.416215897f, -0.497530937f, -0.0799726769f, -0.0134168789f, -0.904170573f,
+    0.591278553f, 1.05504012f, 0.16234687f, -0.0815016031f, -0.274205893f, -0.0362337902f,
+    0.72954154f, 1.75086701f, 0.854647696f, 0.111505665f, 1.37652671f, -0.0450520292f,
+    -0.434969366f, -0.962760866f, -0.277961224f, -1.28341198f, -1.13283396f, -0.396017224f,
+    -0.0931712687f, 0.772340655f, -1.08637881f, 0.283284426f, -1.34891856f, -0.24807319f,
+    0.594409108f, -0.0137392879f, 0.0216962807f, -0.596247554f, 0.656379879f, 1.73508692f,
+    -0.330626786f, 1.25199485f, -0.655357599f, -0.290577769f, 0.611892521f, 0.115062997f,
+    0.240882233f, 0.655156732f, 1.73944545f, 1.30386937f,
+};
+
+inline constexpr int64_t kH3EncFcnCh = 32;
+inline constexpr int64_t kH3EncFcnLevels = 2;
+inline constexpr int64_t kH3EncFcnResBlocks = 1;
+inline constexpr int64_t kH3EncFcnInCh = 3;
+inline constexpr int64_t kH3EncFcnZCh = 4;
+inline constexpr int64_t kH3EncFcnT = 3;
+inline constexpr int64_t kH3EncFcnH = 4;
+inline constexpr int64_t kH3EncFcnW = 4;
+inline constexpr int64_t kH3EncFcnOutT = 2;
+inline constexpr int64_t kH3EncFcnOutH = 2;
+inline constexpr int64_t kH3EncFcnOutW = 2;
+
+inline constexpr int64_t kH3EncFcnChMult[] = {
+    1, 2,
+};
+
+inline constexpr int64_t kH3EncFcnSpaceDown[] = {
+    2, 1,
+};
+
+inline constexpr int64_t kH3EncFcnTimeDown[] = {
+    2, 1,
+};
+
+inline constexpr float kH3EncFcnGolden[] = {
+    -0.647403002f, -1.08679593f, -1.2458874f, -1.09321702f, 0.658367097f, -0.010494682f,
+    1.4137609f, 0.526135743f, -0.074380286f, 0.370558113f, -0.594323337f, -0.00315129361f,
+    -0.177218556f, -1.05845392f, 0.194596648f, 0.377935022f, -0.626861393f, -0.220532134f,
+    -0.0755905882f, -0.147749916f, -1.02707064f, -0.566771746f, 0.0391352698f, 1.44189084f,
+    -0.189376622f, 0.130435646f, -0.0821180269f, -0.175276399f, 0.353344172f, -0.58102107f,
+    -2.27422833f, -1.54143059f,
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/minimax_h3_video_vae_manifest.inc b/tests/vllm/models/minimax_h3_video_vae_manifest.inc
new file mode 100644
index 000000000..1b8ad9e09
--- /dev/null
+++ b/tests/vllm/models/minimax_h3_video_vae_manifest.inc
@@ -0,0 +1,584 @@
+// GENERATED by scripts/gen-minimax-h3-safetensors-manifest.py — DO NOT EDIT BY HAND.
+//
+// Tensor manifest of a REAL safetensors checkpoint (MiniMaxAI/MiniMax-H3 FL2VA/video_vae/source/model.safetensors): 560 tensors,
+// names/dtypes/shapes only — no weight bytes. Captured from the file's own header via
+// an HTTP range request. See .agents/specs/minimax-h3.md.
+#pragma once
+
+#include <cstdint>
+
+namespace vllm_test {
+
+inline constexpr int64_t kH3VideoVaeTensorCount = 560;
+
+struct H3VideoVaeTensor {
+  const char* name;
+  const char* dtype;
+  int64_t shape[5];  // 0-padded (Conv3d weights are rank 5)
+  int32_t rank;
+};
+
+inline constexpr H3VideoVaeTensor kH3VideoVaeTensors[] = {
+    {"decoder.mask_token", "F32", {1, 1, 2048, 0, 0}, 3},
+    {"decoder.norm_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.norm_out.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.proj_out.bias", "F32", {3072, 0, 0, 0, 0}, 1},
+    {"decoder.proj_out.weight", "F32", {3072, 2048, 0, 0, 0}, 2},
+    {"decoder.register_tokens", "F32", {1, 4, 2048, 0, 0}, 3},
+    {"decoder.transformer_blocks.0.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.0.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.0.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.0.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.0.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.0.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.0.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.0.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.0.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.0.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.0.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.0.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.1.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.1.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.1.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.1.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.1.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.10.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.10.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.10.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.10.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.10.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.11.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.11.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.11.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.11.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.11.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.12.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.12.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.12.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.12.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.12.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.13.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.13.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.13.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.13.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.13.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.14.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.14.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.14.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.14.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.14.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.15.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.15.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.15.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.15.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.15.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.16.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.16.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.16.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.16.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.16.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.17.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.17.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.17.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.17.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.17.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.18.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.18.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.18.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.18.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.18.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.19.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.19.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.19.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.19.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.19.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.2.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.2.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.2.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.2.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.2.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.20.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.20.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.20.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.20.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.20.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.21.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.21.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.21.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.21.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.21.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.22.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.22.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.22.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.22.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.22.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.23.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.23.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.23.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.23.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.23.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.24.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.24.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.24.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.24.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.24.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.25.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.25.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.25.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.25.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.25.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.26.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.26.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.26.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.26.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.26.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.27.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.27.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.27.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.27.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.27.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.28.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.28.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.28.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.28.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.28.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.29.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.29.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.29.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.29.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.29.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.3.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.3.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.3.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.3.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.3.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.30.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.30.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.30.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.30.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.30.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.31.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.31.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.31.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.31.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.31.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.32.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.32.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.32.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.32.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.32.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.33.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.33.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.33.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.33.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.33.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.34.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.34.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.34.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.34.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.34.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.35.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.35.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.35.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.35.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.35.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.4.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.4.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.4.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.4.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.4.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.5.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.5.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.5.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.5.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.5.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.6.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.6.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.6.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.6.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.6.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.7.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.7.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.7.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.7.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.7.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.8.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.8.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.8.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.8.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.8.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.attn.to_out.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.attn.to_out.weight", "F32", {2048, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.9.attn.to_qkv.bias", "F32", {6144, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.attn.to_qkv.weight", "F32", {6144, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.9.ff.w1.bias", "F32", {16384, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.ff.w1.weight", "F32", {16384, 2048, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.9.ff.w2.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.ff.w2.weight", "F32", {2048, 8192, 0, 0, 0}, 2},
+    {"decoder.transformer_blocks.9.norm1.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.norm2.weight", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.scale1", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.transformer_blocks.9.scale2", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.x_embedder.bias", "F32", {2048, 0, 0, 0, 0}, 1},
+    {"decoder.x_embedder.weight", "F32", {2048, 24, 0, 0, 0}, 2},
+    {"encoder.conv_in.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.conv_in.weight", "F32", {128, 3, 3, 3, 3}, 5},
+    {"encoder.conv_out.bias", "F32", {48, 0, 0, 0, 0}, 1},
+    {"encoder.conv_out.weight", "F32", {48, 1024, 3, 3, 3}, 5},
+    {"encoder.down.0.block.0.conv1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.0.conv1.weight", "F32", {128, 128, 3, 3, 3}, 5},
+    {"encoder.down.0.block.0.conv2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.0.conv2.weight", "F32", {128, 128, 3, 3, 3}, 5},
+    {"encoder.down.0.block.0.norm1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.0.norm1.weight", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.0.norm2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.0.norm2.weight", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.1.conv1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.1.conv1.weight", "F32", {128, 128, 3, 3, 3}, 5},
+    {"encoder.down.0.block.1.conv2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.1.conv2.weight", "F32", {128, 128, 3, 3, 3}, 5},
+    {"encoder.down.0.block.1.norm1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.1.norm1.weight", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.1.norm2.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.block.1.norm2.weight", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.downsample.conv.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.0.downsample.conv.weight", "F32", {128, 128, 3, 3, 3}, 5},
+    {"encoder.down.1.block.0.conv1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.0.conv1.weight", "F32", {256, 128, 3, 3, 3}, 5},
+    {"encoder.down.1.block.0.conv2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.0.conv2.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.1.block.0.nin_shortcut.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.0.nin_shortcut.weight", "F32", {256, 128, 1, 1, 1}, 5},
+    {"encoder.down.1.block.0.norm1.bias", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.0.norm1.weight", "F32", {128, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.0.norm2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.0.norm2.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.1.conv1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.1.conv1.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.1.block.1.conv2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.1.conv2.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.1.block.1.norm1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.1.norm1.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.1.norm2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.block.1.norm2.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.downsample.conv.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.1.downsample.conv.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.2.block.0.conv1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.0.conv1.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.2.block.0.conv2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.0.conv2.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.2.block.0.norm1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.0.norm1.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.0.norm2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.0.norm2.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.1.conv1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.1.conv1.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.2.block.1.conv2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.1.conv2.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.2.block.1.norm1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.1.norm1.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.1.norm2.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.block.1.norm2.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.downsample.conv.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.2.downsample.conv.weight", "F32", {256, 256, 3, 3, 3}, 5},
+    {"encoder.down.3.block.0.conv1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.0.conv1.weight", "F32", {512, 256, 3, 3, 3}, 5},
+    {"encoder.down.3.block.0.conv2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.0.conv2.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.3.block.0.nin_shortcut.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.0.nin_shortcut.weight", "F32", {512, 256, 1, 1, 1}, 5},
+    {"encoder.down.3.block.0.norm1.bias", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.0.norm1.weight", "F32", {256, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.0.norm2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.0.norm2.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.1.conv1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.1.conv1.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.3.block.1.conv2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.1.conv2.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.3.block.1.norm1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.1.norm1.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.1.norm2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.block.1.norm2.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.downsample.conv.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.3.downsample.conv.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.4.block.0.conv1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.0.conv1.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.4.block.0.conv2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.0.conv2.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.4.block.0.norm1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.0.norm1.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.0.norm2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.0.norm2.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.1.conv1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.1.conv1.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.4.block.1.conv2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.1.conv2.weight", "F32", {512, 512, 3, 3, 3}, 5},
+    {"encoder.down.4.block.1.norm1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.1.norm1.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.1.norm2.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.4.block.1.norm2.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.0.conv1.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.0.conv1.weight", "F32", {1024, 512, 3, 3, 3}, 5},
+    {"encoder.down.5.block.0.conv2.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.0.conv2.weight", "F32", {1024, 1024, 3, 3, 3}, 5},
+    {"encoder.down.5.block.0.nin_shortcut.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.0.nin_shortcut.weight", "F32", {1024, 512, 1, 1, 1}, 5},
+    {"encoder.down.5.block.0.norm1.bias", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.0.norm1.weight", "F32", {512, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.0.norm2.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.0.norm2.weight", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.1.conv1.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.1.conv1.weight", "F32", {1024, 1024, 3, 3, 3}, 5},
+    {"encoder.down.5.block.1.conv2.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.1.conv2.weight", "F32", {1024, 1024, 3, 3, 3}, 5},
+    {"encoder.down.5.block.1.norm1.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.1.norm1.weight", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.1.norm2.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.down.5.block.1.norm2.weight", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.norm_out.bias", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"encoder.norm_out.weight", "F32", {1024, 0, 0, 0, 0}, 1},
+    {"post_quant_conv.bias", "F32", {24, 0, 0, 0, 0}, 1},
+    {"post_quant_conv.weight", "F32", {24, 24, 1, 1, 1}, 5},
+    {"quant_conv.bias", "F32", {48, 0, 0, 0, 0}, 1},
+    {"quant_conv.weight", "F32", {48, 48, 1, 1, 1}, 5},
+};
+
+}  // namespace vllm_test
diff --git a/tests/vllm/models/test_minimax_h3.cpp b/tests/vllm/models/test_minimax_h3.cpp
new file mode 100644
index 000000000..3bafa6b58
--- /dev/null
+++ b/tests/vllm/models/test_minimax_h3.cpp
@@ -0,0 +1,5538 @@
+// MiniMax-H3 parity gate. Every assertion here compares our port against the
+// UPSTREAM vLLM-Omni implementation (vllm-project/vllm-omni,
+// vllm_omni/diffusion/models/minimax_h3/), executed at reduced dimensions by
+// scripts/gen-minimax-h3-goldens.py and frozen into minimax_h3_goldens.inc.
+//
+// WHY A REDUCED-DIMENSION GATE. The shipped H3 checkpoint is ~354 GB and its
+// validated serving config is 4x NVIDIA B300 (~133 GB peak per rank); it does not
+// fit this project's hardware, so nothing here claims an end-to-end video result.
+// What it does claim is exact: the packed layout (including the FP64 position grid
+// that feeds RoPE), the flow-matching scheduler, the latent<->token packing, and
+// the full DiT forward all reproduce upstream's numbers. See
+// .agents/specs/minimax-h3.md sections 0 and 4.
+#include "vllm/model_executor/models/minimax_h3.h"
+
+#include <doctest/doctest.h>
+
+#include <nlohmann/json.hpp>
+
+#include <cmath>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <set>
+#include <array>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "minimax_h3_goldens.inc"
+#include "minimax_h3_gguf_manifest.inc"
+#include "minimax_h3_audio_vae_goldens.inc"
+#include "minimax_h3_audio_vae_encoder_goldens.inc"
+#include "minimax_h3_audio_vae_manifest.inc"
+#include "minimax_h3_vae_configs.inc"
+#include "minimax_h3_nvfp4_manifest.inc"
+#include "minimax_h3_video_vae_manifest.inc"
+#include "minimax_h3_video_vae_goldens.inc"
+#include "minimax_h3_encoder_goldens.inc"
+
+#include "vllm/model_executor/model_loader/gguf_dequant.h"
+#include "vllm/model_executor/model_loader/gguf_reader.h"
+#include "vllm/model_executor/model_loader/safetensors_reader.h"
+#include "vllm/multimodal/qwen3vl_processor.h"
+#include "../gguf_builder.h"
+
+#include "vt/backend.h"
+#include "vt/quant.h"
+#include "vt/device.h"
+#include "vt/tensor.h"
+
+using vllm::BuildMiniMaxH3PackedSequence;
+using vllm::BuildMiniMaxH3PackedSequenceRef2va;
+using vllm::EnumerateMiniMaxH3DitTensors;
+using vllm::MiniMaxH3DitDeviceWeights;
+using vllm::MiniMaxH3DitForward;
+using vllm::MiniMaxH3DitForwardDevice;
+using vllm::StageMiniMaxH3DitWeights;
+using vllm::MiniMaxH3DitInputs;
+using vllm::MiniMaxH3DitOutputs;
+using vllm::MiniMaxH3DitParams;
+using vllm::MiniMaxH3DitWeights;
+using vllm::MiniMaxH3EulerEta0Step;
+using vllm::MiniMaxH3PackAudioLatent;
+using vllm::MiniMaxH3PackedSequence;
+using vllm::MiniMaxH3PatchifyVideoLatent;
+using vllm::MiniMaxH3RefBlock;
+using vllm::MiniMaxH3ReorderGroupedQkv;
+using vllm::MiniMaxH3RfVToX0;
+using vllm::MiniMaxH3UnpackAudioTokens;
+using vllm::MiniMaxH3UnpatchifyVideoTokens;
+using vllm::ParseMiniMaxH3DitParams;
+
+namespace {
+
+// ---------------------------------------------------------------------------
+// H3Rand — the exact mirror of the generator's deterministic stream
+// (scripts/gen-minimax-h3-goldens.py :: h3_rand). A per-tensor FNV-1a seed plus a
+// splitmix64 counter, so both sides build identical tensors without shipping a
+// single weight byte.
+// ---------------------------------------------------------------------------
+
+uint64_t Fnv1a64(const std::string& name) {
+  uint64_t h = 0xCBF29CE484222325ULL;
+  for (unsigned char byte : name) {
+    h ^= static_cast<uint64_t>(byte);
+    h *= 0x100000001B3ULL;
+  }
+  return h;
+}
+
+uint64_t Splitmix64(uint64_t x) {
+  x += 0x9E3779B97F4A7C15ULL;
+  uint64_t z = x;
+  z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+  z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+  return z ^ (z >> 31);
+}
+
+std::vector<double> H3Rand(const std::string& name, int64_t count) {
+  const uint64_t seed = Fnv1a64(name);
+  std::vector<double> out(static_cast<size_t>(count));
+  for (int64_t i = 0; i < count; ++i) {
+    const uint64_t u = Splitmix64(seed + static_cast<uint64_t>(i));
+    const double unit = static_cast<double>(u >> 11) * 0x1p-53;
+    out[static_cast<size_t>(i)] = unit * 2.0 - 1.0;
+  }
+  return out;
+}
+
+// make_param: h3_rand * scale + offset, rounded to f32 (the generator's astype).
+std::vector<float> MakeParam(const std::string& name, int64_t count, double scale,
+                             double offset = 0.0) {
+  const std::vector<double> raw = H3Rand(name, count);
+  std::vector<float> out(static_cast<size_t>(count));
+  for (int64_t i = 0; i < count; ++i) {
+    out[static_cast<size_t>(i)] = static_cast<float>(raw[static_cast<size_t>(i)] * scale + offset);
+  }
+  return out;
+}
+
+vt::Device Cpu() { return vt::Device{}; }
+
+vt::Tensor View1D(std::vector<float>& buffer) {
+  return vt::Tensor::Contiguous(buffer.data(), vt::DType::kF32, Cpu(),
+                                {static_cast<int64_t>(buffer.size())});
+}
+
+vt::Tensor View2D(std::vector<float>& buffer, int64_t rows, int64_t cols) {
+  REQUIRE(static_cast<int64_t>(buffer.size()) == rows * cols);
+  return vt::Tensor::Contiguous(buffer.data(), vt::DType::kF32, Cpu(), {rows, cols});
+}
+
+// Max absolute difference against a golden array.
+double MaxAbsDiff(const std::vector<float>& got, const float* want, size_t count) {
+  REQUIRE(got.size() == count);
+  double worst = 0.0;
+  for (size_t i = 0; i < count; ++i) {
+    worst = std::max(worst, std::abs(static_cast<double>(got[i]) - static_cast<double>(want[i])));
+  }
+  return worst;
+}
+
+template <typename T>
+void CheckI64(const std::vector<T>& got, const int64_t* want, size_t count) {
+  REQUIRE(got.size() == count);
+  for (size_t i = 0; i < count; ++i) CHECK(static_cast<int64_t>(got[i]) == want[i]);
+}
+
+// The reduced-dimension arch the generator used (section 5 scalars).
+MiniMaxH3DitParams GoldenParams() {
+  MiniMaxH3DitParams p;
+  p.num_layers = vllm_test::kH3Dit_num_layers;
+  p.token_refiner_num_layers = vllm_test::kH3Dit_token_refiner_num_layers;
+  p.hidden_size = vllm_test::kH3Dit_hidden_size;
+  p.num_attention_heads = vllm_test::kH3Dit_num_attention_heads;
+  p.attention_head_dim = vllm_test::kH3Dit_attention_head_dim;
+  p.ffn_hidden_size = vllm_test::kH3Dit_ffn_hidden_size;
+  p.latents_dim = vllm_test::kH3Dit_latents_dim;
+  p.audio_latents_dim = vllm_test::kH3Dit_audio_latents_dim;
+  p.patch_size_t = 1;
+  p.patch_size_h = 2;
+  p.patch_size_w = 2;
+  p.text_dim = vllm_test::kH3Dit_text_dim;
+  p.timestep_input_dim = vllm_test::kH3Dit_timestep_input_dim;
+  p.time_embed_hidden_size = vllm_test::kH3Dit_time_embed_hidden_size;
+  p.time_embed_dim = vllm_test::kH3Dit_time_embed_dim;
+  p.adaln_out_features = 18 * p.hidden_size;
+  p.final_adaln_out_features = 2 * p.hidden_size;
+  p.rope_inv_freq_len = vllm_test::kH3Dit_rope_inv_freq_len;
+  return p;
+}
+
+// Owns every reduced-dimension parameter so the vt::Tensor views stay valid.
+struct GoldenWeights {
+  MiniMaxH3DitParams params;
+  std::vector<std::vector<float>> storage;
+  MiniMaxH3DitWeights views;
+
+  std::vector<float>& Add(const std::string& name, int64_t count, double scale,
+                          double offset = 0.0) {
+    storage.push_back(MakeParam(name, count, scale, offset));
+    return storage.back();
+  }
+};
+
+// Mirrors RefDiT.__init__ in the generator: same names, same scales, same shapes.
+// storage is reserved up front because the vt::Tensor views are non-owning.
+void BuildBlock(GoldenWeights& w, const std::string& prefix, bool with_adaln) {
+  const MiniMaxH3DitParams& p = w.params;
+  const int64_t h = p.hidden_size;
+  const int64_t inner = p.num_attention_heads * p.attention_head_dim;
+  vllm::MiniMaxH3DitBlockWeights block;
+  block.norm1 = View1D(w.Add(prefix + ".norm1.weight", h, 0.1, 1.0));
+  block.norm2 = View1D(w.Add(prefix + ".norm2.weight", h, 0.1, 1.0));
+  block.qkv_proj =
+      View2D(w.Add(prefix + ".attn.qkv_proj.weight", 3 * inner * h, 0.05), 3 * inner, h);
+  block.q_norm = View1D(w.Add(prefix + ".attn.q_norm.weight", p.attention_head_dim, 0.1, 1.0));
+  block.k_norm = View1D(w.Add(prefix + ".attn.k_norm.weight", p.attention_head_dim, 0.1, 1.0));
+  block.out_proj = View2D(w.Add(prefix + ".attn.out_proj.weight", h * inner, 0.05), h, inner);
+  block.fc1 = View2D(w.Add(prefix + ".mlp.fc1.weight", 2 * p.ffn_hidden_size * h, 0.05),
+                     2 * p.ffn_hidden_size, h);
+  block.fc2 = View2D(w.Add(prefix + ".mlp.fc2.weight", h * p.ffn_hidden_size, 0.05), h,
+                     p.ffn_hidden_size);
+  if (with_adaln) {
+    block.adaln_w = View2D(
+        w.Add(prefix + ".adaln_proj.linear.weight", p.adaln_out_features * p.time_embed_dim, 0.05),
+        p.adaln_out_features, p.time_embed_dim);
+    block.adaln_b = View1D(w.Add(prefix + ".adaln_proj.linear.bias", p.adaln_out_features, 0.02));
+    w.views.blocks.push_back(block);
+  } else {
+    w.views.refiner.push_back(block);
+  }
+}
+
+std::unique_ptr<GoldenWeights> BuildGoldenWeights() {
+  auto w = std::make_unique<GoldenWeights>();
+  w->params = GoldenParams();
+  const MiniMaxH3DitParams& p = w->params;
+  const int64_t h = p.hidden_size;
+  const int64_t video_width = p.video_row_width();
+  // Reserve so no reallocation invalidates a previously taken view.
+  w->storage.reserve(512);
+
+  w->views.video_patch_proj_w =
+      View2D(w->Add("video_patch_proj.weight", h * video_width, 0.05), h, video_width);
+  w->views.video_patch_proj_b = View1D(w->Add("video_patch_proj.bias", h, 0.02));
+  w->views.audio_patch_proj_w =
+      View2D(w->Add("audio_patch_proj.weight", h * p.audio_latents_dim, 0.05), h, p.audio_latents_dim);
+  w->views.audio_patch_proj_b = View1D(w->Add("audio_patch_proj.bias", h, 0.02));
+  w->views.condition_proj_w =
+      View2D(w->Add("condition_proj.weight", h * p.text_dim, 0.05), h, p.text_dim);
+  w->views.condition_proj_b = View1D(w->Add("condition_proj.bias", h, 0.02));
+  w->views.time_proj_in_w =
+      View2D(w->Add("time_embedder.proj_in.weight", p.time_embed_hidden_size * p.timestep_input_dim,
+                    0.05),
+             p.time_embed_hidden_size, p.timestep_input_dim);
+  w->views.time_proj_in_b =
+      View1D(w->Add("time_embedder.proj_in.bias", p.time_embed_hidden_size, 0.02));
+  w->views.time_proj_out_w = View2D(
+      w->Add("time_embedder.proj_out.weight", p.time_embed_dim * p.time_embed_hidden_size, 0.05),
+      p.time_embed_dim, p.time_embed_hidden_size);
+  w->views.time_proj_out_b = View1D(w->Add("time_embedder.proj_out.bias", p.time_embed_dim, 0.02));
+
+  // inv_freq = 10000^(-2i / 2L), computed (not random) on both sides.
+  {
+    std::vector<float> inv(static_cast<size_t>(p.rope_inv_freq_len));
+    for (int64_t i = 0; i < p.rope_inv_freq_len; ++i) {
+      inv[static_cast<size_t>(i)] = static_cast<float>(
+          std::pow(10000.0, -(2.0 * static_cast<double>(i)) / (2.0 * static_cast<double>(p.rope_inv_freq_len))));
+    }
+    w->storage.push_back(std::move(inv));
+    w->views.rope_inv_freq = View1D(w->storage.back());
+  }
+
+  for (int64_t i = 0; i < p.token_refiner_num_layers; ++i) {
+    BuildBlock(*w, "token_refiner.blocks." + std::to_string(i), /*with_adaln=*/false);
+  }
+  w->views.refiner_final_norm = View1D(w->Add("token_refiner.final_norm.weight", h, 0.1, 1.0));
+  for (int64_t i = 0; i < p.num_layers; ++i) {
+    BuildBlock(*w, "blocks." + std::to_string(i), /*with_adaln=*/true);
+  }
+  w->views.final_norm = View1D(w->Add("final_layer.norm.weight", h, 0.1, 1.0));
+  w->views.final_adaln_w =
+      View2D(w->Add("final_layer.adaln_proj.linear.weight", p.final_adaln_out_features * p.time_embed_dim,
+                    0.05),
+             p.final_adaln_out_features, p.time_embed_dim);
+  w->views.final_adaln_b =
+      View1D(w->Add("final_layer.adaln_proj.linear.bias", p.final_adaln_out_features, 0.02));
+  w->views.video_out_w =
+      View2D(w->Add("final_layer.video_out.weight", video_width * h, 0.05), video_width, h);
+  w->views.video_out_b = View1D(w->Add("final_layer.video_out.bias", video_width, 0.02));
+  w->views.audio_out_w =
+      View2D(w->Add("final_layer.audio_out.weight", p.audio_latents_dim * h, 0.05),
+             p.audio_latents_dim, h);
+  w->views.audio_out_b = View1D(w->Add("final_layer.audio_out.bias", p.audio_latents_dim, 0.02));
+  return w;
+}
+
+// The fl2va DiT forward case: the packed sequence, the scattered video/audio rows
+// and the prompt embeddings the generator used. Owns every buffer the returned
+// MiniMaxH3DitInputs points at, so both the CPU forward and the DEVICE forward can
+// be driven from exactly the same bytes.
+struct DitForwardCase {
+  MiniMaxH3PackedSequence packed;
+  std::vector<float> x, audio_x, prompt_embeds;
+  std::vector<float> unique_timesteps;
+  std::vector<int64_t> inverse;
+  std::vector<int32_t> refiner_cu;
+  int64_t seq_len = 0, num_img = 0, num_audio = 0, num_text = 0, video_width = 0;
+  MiniMaxH3DitInputs in;
+};
+
+std::unique_ptr<DitForwardCase> BuildDitForwardCase(const MiniMaxH3DitParams& p) {
+  auto c = std::make_unique<DitForwardCase>();
+  c->packed = BuildMiniMaxH3PackedSequence(
+      vllm_test::kH3Fl2va_text_len, vllm_test::kH3Fl2va_latent_t, vllm_test::kH3Fl2va_latent_h,
+      vllm_test::kH3Fl2va_latent_w, vllm_test::kH3Fl2va_audio_t, vllm_test::kH3Fl2va_audio_channel,
+      /*include_keyframe_cond=*/true, {0}, vllm_test::kH3Fl2va_frame_count);
+
+  c->seq_len = c->packed.seq_len;
+  c->video_width = p.video_row_width();
+  c->num_img = static_cast<int64_t>(c->packed.img_pos.size());
+  c->num_audio = static_cast<int64_t>(c->packed.audio_pos.size());
+  c->num_text = static_cast<int64_t>(c->packed.text_pos.size());
+
+  // Scatter the same rows the generator scattered.
+  c->x.assign(static_cast<size_t>(c->seq_len * c->video_width), 0.0f);
+  const std::vector<float> video_rows =
+      MakeParam("dit.video_rows", c->num_img * c->video_width, 1.0);
+  for (int64_t r = 0; r < c->num_img; ++r) {
+    std::memcpy(c->x.data() + c->packed.img_pos[static_cast<size_t>(r)] * c->video_width,
+                video_rows.data() + r * c->video_width,
+                static_cast<size_t>(c->video_width) * sizeof(float));
+  }
+  c->audio_x.assign(static_cast<size_t>(c->seq_len * p.audio_latents_dim), 0.0f);
+  const std::vector<float> audio_rows =
+      MakeParam("dit.audio_rows", c->num_audio * p.audio_latents_dim, 1.0);
+  for (int64_t r = 0; r < c->num_audio; ++r) {
+    std::memcpy(
+        c->audio_x.data() + c->packed.audio_pos[static_cast<size_t>(r)] * p.audio_latents_dim,
+        audio_rows.data() + r * p.audio_latents_dim,
+        static_cast<size_t>(p.audio_latents_dim) * sizeof(float));
+  }
+  c->prompt_embeds = MakeParam("dit.prompt_embeds", c->num_text * p.text_dim, 1.0);
+
+  c->unique_timesteps.assign(
+      vllm_test::kH3DitUniqueTimesteps,
+      vllm_test::kH3DitUniqueTimesteps + vllm_test::kH3Dit_unique_timesteps);
+  c->inverse.assign(vllm_test::kH3DitInverseIndices,
+                    vllm_test::kH3DitInverseIndices + c->seq_len);
+  c->refiner_cu = {0, static_cast<int32_t>(c->num_text), static_cast<int32_t>(c->num_text)};
+
+  MiniMaxH3DitInputs& in = c->in;
+  in.seq_len = c->seq_len;
+  in.x = c->x.data();
+  in.audio_x = c->audio_x.data();
+  in.img_position_ids = c->packed.img_position_ids.data();
+  in.unique_timesteps = c->unique_timesteps.data();
+  in.num_unique_timesteps = static_cast<int64_t>(c->unique_timesteps.size());
+  in.inverse_indices = c->inverse.data();
+  in.token_tags = c->packed.token_tags.data();
+  in.prompt_embeds = c->prompt_embeds.data();
+  in.img_pos = c->packed.img_pos.data();
+  in.num_img_pos = c->num_img;
+  in.audio_pos = c->packed.audio_pos.data();
+  in.num_audio_pos = c->num_audio;
+  in.text_pos = c->packed.text_pos.data();
+  in.num_text_pos = c->num_text;
+  in.infer_out_pos = c->packed.img_pos.data();
+  in.num_infer_out_pos = c->num_img;
+  in.update_mask = c->packed.update_mask.data();
+  in.cu_seqlens = c->packed.cu_seqlens.data();
+  in.num_cu_seqlens = static_cast<int64_t>(c->packed.cu_seqlens.size());
+  in.refiner_cu_seqlens = c->refiner_cu.data();
+  in.num_refiner_cu_seqlens = static_cast<int64_t>(c->refiner_cu.size());
+  return c;
+}
+
+}  // namespace
+
+TEST_CASE("minimax_h3: the deterministic weight stream matches the generator") {
+  // If this fails, nothing else in this file is meaningful — the two sides would
+  // be comparing different tensors, not different implementations.
+  // Bit-exact on purpose: the two streams must agree exactly, not approximately.
+  const std::vector<double> probe = H3Rand("h3.probe", 8);
+  REQUIRE(probe.size() == std::size(vllm_test::kH3RandProbe));
+  for (size_t i = 0; i < probe.size(); ++i) {
+    CHECK(probe[i] == vllm_test::kH3RandProbe[i]);
+  }
+}
+
+TEST_CASE("minimax_h3: fl2va packed sequence matches upstream") {
+  const MiniMaxH3PackedSequence packed = BuildMiniMaxH3PackedSequence(
+      vllm_test::kH3Fl2va_text_len, vllm_test::kH3Fl2va_latent_t, vllm_test::kH3Fl2va_latent_h,
+      vllm_test::kH3Fl2va_latent_w, vllm_test::kH3Fl2va_audio_t, vllm_test::kH3Fl2va_audio_channel,
+      /*include_keyframe_cond=*/true, {0}, vllm_test::kH3Fl2va_frame_count);
+
+  CHECK(packed.seq_len == vllm_test::kH3Fl2va_seq_len);
+  CheckI64(packed.input_ids, vllm_test::kH3Fl2vaInputIds,
+           std::size(vllm_test::kH3Fl2vaInputIds));
+  CheckI64(packed.token_tags, vllm_test::kH3Fl2vaTokenTags,
+           std::size(vllm_test::kH3Fl2vaTokenTags));
+  CheckI64(packed.img_pos, vllm_test::kH3Fl2vaImgPos, std::size(vllm_test::kH3Fl2vaImgPos));
+  CheckI64(packed.audio_pos, vllm_test::kH3Fl2vaAudioPos, std::size(vllm_test::kH3Fl2vaAudioPos));
+  CheckI64(packed.text_pos, vllm_test::kH3Fl2vaTextPos, std::size(vllm_test::kH3Fl2vaTextPos));
+  CheckI64(packed.update_mask, vllm_test::kH3Fl2vaUpdateMask,
+           std::size(vllm_test::kH3Fl2vaUpdateMask));
+  CheckI64(packed.cu_seqlens, vllm_test::kH3Fl2vaCuSeqlens,
+           std::size(vllm_test::kH3Fl2vaCuSeqlens));
+  CheckI64(packed.document_id, vllm_test::kH3Fl2vaDocumentId,
+           std::size(vllm_test::kH3Fl2vaDocumentId));
+
+  // The FP64 position grid feeds RoPE directly and is gated BIT-EXACT: a last-ulp
+  // drift here would silently rotate every video token.
+  REQUIRE(packed.img_position_ids.size() == std::size(vllm_test::kH3Fl2vaImgPositionIds));
+  for (size_t i = 0; i < packed.img_position_ids.size(); ++i) {
+    CHECK(packed.img_position_ids[i] == vllm_test::kH3Fl2vaImgPositionIds[i]);
+  }
+}
+
+TEST_CASE("minimax_h3: ref2va block packed sequence matches upstream") {
+  std::vector<MiniMaxH3RefBlock> blocks(2);
+  blocks[0].kind = MiniMaxH3RefBlock::Kind::kImage;
+  blocks[0].latent_h = 4;
+  blocks[0].latent_w = 4;
+  blocks[1].kind = MiniMaxH3RefBlock::Kind::kVideoAudio;
+  blocks[1].ref_audio_t = 2;
+  blocks[1].latent_t = 2;
+  blocks[1].latent_h = 4;
+  blocks[1].latent_w = 4;
+
+  const MiniMaxH3PackedSequence packed = BuildMiniMaxH3PackedSequenceRef2va(
+      vllm_test::kH3Ref2va_text_len, vllm_test::kH3Ref2va_latent_t, vllm_test::kH3Ref2va_latent_h,
+      vllm_test::kH3Ref2va_latent_w, vllm_test::kH3Ref2va_audio_t, blocks,
+      vllm_test::kH3Ref2va_audio_channel);
+
+  CHECK(packed.seq_len == vllm_test::kH3Ref2va_seq_len);
+  CheckI64(packed.input_ids, vllm_test::kH3Ref2vaInputIds,
+           std::size(vllm_test::kH3Ref2vaInputIds));
+  CheckI64(packed.token_tags, vllm_test::kH3Ref2vaTokenTags,
+           std::size(vllm_test::kH3Ref2vaTokenTags));
+  CheckI64(packed.img_pos, vllm_test::kH3Ref2vaImgPos, std::size(vllm_test::kH3Ref2vaImgPos));
+  CheckI64(packed.audio_pos, vllm_test::kH3Ref2vaAudioPos, std::size(vllm_test::kH3Ref2vaAudioPos));
+  CheckI64(packed.update_mask, vllm_test::kH3Ref2vaUpdateMask,
+           std::size(vllm_test::kH3Ref2vaUpdateMask));
+  CheckI64(packed.audio_update_mask, vllm_test::kH3Ref2vaAudioUpdateMask,
+           std::size(vllm_test::kH3Ref2vaAudioUpdateMask));
+  CheckI64(packed.cu_seqlens, vllm_test::kH3Ref2vaCuSeqlens,
+           std::size(vllm_test::kH3Ref2vaCuSeqlens));
+  REQUIRE(packed.img_position_ids.size() == std::size(vllm_test::kH3Ref2vaImgPositionIds));
+  for (size_t i = 0; i < packed.img_position_ids.size(); ++i) {
+    CHECK(packed.img_position_ids[i] == vllm_test::kH3Ref2vaImgPositionIds[i]);
+  }
+}
+
+TEST_CASE("minimax_h3: video patchify and audio pack match upstream, and round-trip") {
+  const int64_t c = vllm_test::kH3PatchifyC, t = vllm_test::kH3PatchifyT;
+  const int64_t h = vllm_test::kH3PatchifyH, w = vllm_test::kH3PatchifyW;
+  const std::vector<float> latent = MakeParam("packing.video_latent", c * t * h * w, 1.0);
+  const std::vector<float> rows =
+      MiniMaxH3PatchifyVideoLatent(latent, 1, c, t, h, w, 1, 2, 2);
+  CHECK(static_cast<int64_t>(rows.size()) ==
+        vllm_test::kH3PatchifyRows * vllm_test::kH3PatchifyRowWidth);
+  CHECK(MaxAbsDiff(rows, vllm_test::kH3PatchifyRowsGolden, rows.size()) == 0.0);
+
+  const std::vector<float> back =
+      MiniMaxH3UnpatchifyVideoTokens(rows, t, h / 2, w / 2, c, 1, 2, 2);
+  REQUIRE(back.size() == latent.size());
+  for (size_t i = 0; i < back.size(); ++i) CHECK(back[i] == latent[i]);
+
+  const int64_t ac = vllm_test::kH3AudioPackChannels, ad = vllm_test::kH3AudioPackDim;
+  const int64_t at = vllm_test::kH3AudioPackT;
+  const std::vector<float> audio = MakeParam("packing.audio_latent", ac * ad * at, 1.0);
+  const std::vector<float> audio_rows = MiniMaxH3PackAudioLatent(audio, ac, ad, at);
+  CHECK(MaxAbsDiff(audio_rows, vllm_test::kH3AudioPackRowsGolden, audio_rows.size()) == 0.0);
+  const std::vector<float> audio_back = MiniMaxH3UnpackAudioTokens(audio_rows, ac * at, ac, ad);
+  REQUIRE(audio_back.size() == audio.size());
+  for (size_t i = 0; i < audio_back.size(); ++i) CHECK(audio_back[i] == audio[i]);
+}
+
+TEST_CASE("minimax_h3: flow-matching scheduler matches upstream") {
+  const int64_t n = vllm_test::kH3SchedN;
+  const std::vector<float> xt = MakeParam("sched.xt", n, 1.0);
+  const std::vector<float> v = MakeParam("sched.v", n, 1.0);
+  for (int64_t s = 0; s < vllm_test::kH3SchedSteps; ++s) {
+    const double t = vllm_test::kH3SchedTimesteps[s];
+    const std::vector<float> x0 = MiniMaxH3RfVToX0(xt, v, t);
+    CHECK(MaxAbsDiff(x0, vllm_test::kH3SchedX0Golden + s * n, static_cast<size_t>(n)) == 0.0);
+    const double sigma_curr = 1.0 - t;
+    const std::vector<float> stepped =
+        MiniMaxH3EulerEta0Step(xt, x0, sigma_curr, sigma_curr * 0.5);
+    CHECK(MaxAbsDiff(stepped, vllm_test::kH3SchedStepGolden + s * n, static_cast<size_t>(n)) <=
+          1e-6);
+  }
+  // The terminal step is a documented identity (scheduling:89-92).
+  const std::vector<float> terminal = MiniMaxH3EulerEta0Step(xt, v, 0.0, 0.0);
+  for (size_t i = 0; i < terminal.size(); ++i) CHECK(terminal[i] == xt[i]);
+}
+
+TEST_CASE("minimax_h3: DiT forward matches upstream at reduced dimensions") {
+  const std::unique_ptr<GoldenWeights> weights = BuildGoldenWeights();
+  const MiniMaxH3DitParams& p = weights->params;
+  const std::unique_ptr<DitForwardCase> c = BuildDitForwardCase(p);
+  REQUIRE(c->video_width == vllm_test::kH3Dit_video_row_width);
+
+  const MiniMaxH3DitOutputs got =
+      MiniMaxH3DitForward(Cpu(), p, weights->views, c->in, vt::DType::kF32);
+
+  // f32 throughout on both sides, so the only slack is summation order inside the
+  // GEMM and the softmax; 2e-5 absolute is far below any structural error.
+  const double video_err =
+      MaxAbsDiff(got.video_logits, vllm_test::kH3DitVideoLogitsGolden, got.video_logits.size());
+  const double audio_err =
+      MaxAbsDiff(got.audio_logits, vllm_test::kH3DitAudioLogitsGolden, got.audio_logits.size());
+  INFO("video max|diff| = " << video_err << ", audio max|diff| = " << audio_err);
+  CHECK(video_err <= 2e-5);
+  CHECK(audio_err <= 2e-5);
+
+  // The pinned keyframe rows must be zeroed by the update mask.
+  for (int64_t r = 0; r < c->num_img; ++r) {
+    if (c->packed.update_mask[static_cast<size_t>(r)]) continue;
+    for (int64_t i = 0; i < c->video_width; ++i) {
+      CHECK(got.video_logits[static_cast<size_t>(r * c->video_width + i)] == 0.0f);
+    }
+  }
+}
+
+// Brick H3-2b. The DEVICE-RESIDENT forward runs the same graph with every
+// activation in device memory. It is NOT bit-identical to the CPU reference and
+// does not claim to be -- it reuses the tuned SHARED vt:: ops (vt::RmsNorm reduces
+// in f32 where RmsNormRows accumulates in double), so it is held to the SAME
+// upstream goldens at the SAME tolerance instead.
+//
+// Runs on the CPU backend here, which is the point: the device forward's STRUCTURE
+// (staging, index plumbing, the strided AdaLN chunk views, on-device row selection)
+// is gated without a GPU. The CUDA case below covers the kernels themselves.
+static void CheckDeviceForward(vt::Queue& q, const char* label) {
+  const std::unique_ptr<GoldenWeights> weights = BuildGoldenWeights();
+  const MiniMaxH3DitParams& p = weights->params;
+  const std::unique_ptr<DitForwardCase> c = BuildDitForwardCase(p);
+
+  const MiniMaxH3DitDeviceWeights staged =
+      StageMiniMaxH3DitWeights(q, p, weights->views);
+  const MiniMaxH3DitOutputs got =
+      MiniMaxH3DitForwardDevice(q, p, staged.weights, c->in, vt::DType::kF32);
+
+  REQUIRE(got.video_logits.size() ==
+          static_cast<size_t>(c->num_img * c->video_width));
+  REQUIRE(got.audio_logits.size() ==
+          static_cast<size_t>(c->num_audio * p.audio_latents_dim));
+
+  const double video_err =
+      MaxAbsDiff(got.video_logits, vllm_test::kH3DitVideoLogitsGolden, got.video_logits.size());
+  const double audio_err =
+      MaxAbsDiff(got.audio_logits, vllm_test::kH3DitAudioLogitsGolden, got.audio_logits.size());
+  INFO(label << ": video max|diff| = " << video_err << ", audio max|diff| = " << audio_err);
+  CHECK(video_err <= 2e-5);
+  CHECK(audio_err <= 2e-5);
+
+  // The pinned keyframe rows must still be zeroed.
+  for (int64_t r = 0; r < c->num_img; ++r) {
+    if (c->packed.update_mask[static_cast<size_t>(r)]) continue;
+    for (int64_t i = 0; i < c->video_width; ++i) {
+      CHECK(got.video_logits[static_cast<size_t>(r * c->video_width + i)] == 0.0f);
+    }
+  }
+}
+
+// The bf16 sibling of CheckDeviceForward: gates the PRODUCTION dtype policy on the
+// device path. Same code, different rounding points -- the device forward rounds in
+// place at exactly the reference's dt.Apply sites, so what is being compared is the
+// CAST POINTS, not a different algorithm.
+static void CheckDeviceForwardBf16(vt::Queue& q, const char* label) {
+  const std::unique_ptr<GoldenWeights> weights = BuildGoldenWeights();
+  const MiniMaxH3DitParams& p = weights->params;
+  const std::unique_ptr<DitForwardCase> c = BuildDitForwardCase(p);
+
+  // Stage with the bf16 policy too: upstream STORES those modules in bf16 (the
+  // generator's to_bf16_weights), so the weights must be rounded the same way the
+  // golden's were -- staging f32 weights under a bf16 stream would compare a
+  // different model, not a different dtype policy.
+  const MiniMaxH3DitDeviceWeights staged =
+      StageMiniMaxH3DitWeights(q, p, weights->views, vt::DType::kBF16);
+  const MiniMaxH3DitOutputs got =
+      MiniMaxH3DitForwardDevice(q, p, staged.weights, c->in, vt::DType::kBF16);
+
+  const double video_err =
+      MaxAbsDiff(got.video_logits, vllm_test::kH3DitVideoLogitsBf16Golden, got.video_logits.size());
+  const double audio_err =
+      MaxAbsDiff(got.audio_logits, vllm_test::kH3DitAudioLogitsBf16Golden, got.audio_logits.size());
+  INFO(label << ": bf16 video max|diff| = " << video_err << ", audio max|diff| = " << audio_err);
+  CHECK(video_err <= 5e-3);
+  CHECK(audio_err <= 5e-3);
+
+  // And the bf16 stream must actually DIFFER from the f32 stream -- otherwise the
+  // dtype policy is not being applied and this test proves nothing.
+  const double vs_f32 =
+      MaxAbsDiff(got.video_logits, vllm_test::kH3DitVideoLogitsGolden, got.video_logits.size());
+  CHECK(vs_f32 > 1e-5);
+}
+
+TEST_CASE("minimax_h3: the DEVICE-resident bf16 stream matches upstream (CPU backend)") {
+  vt::Queue q{Cpu(), nullptr};
+  CheckDeviceForwardBf16(q, "cpu-device-forward-bf16");
+}
+
+TEST_CASE("minimax_h3: the DEVICE-resident bf16 stream matches upstream on CUDA") {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(vt::DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  vt::Queue q = cuda->CreateQueue();
+  CheckDeviceForwardBf16(q, "cuda-device-forward-bf16");
+}
+
+TEST_CASE("minimax_h3: the DEVICE-resident DiT forward matches upstream (CPU backend)") {
+  vt::Queue q{Cpu(), nullptr};
+  CheckDeviceForward(q, "cpu-device-forward");
+}
+
+TEST_CASE("minimax_h3: the DEVICE-resident DiT forward matches upstream on CUDA") {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(vt::DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  vt::Queue q = cuda->CreateQueue();
+  CheckDeviceForward(q, "cuda-device-forward");
+}
+
+TEST_CASE("minimax_h3: the bf16 production stream matches upstream's dtype policy") {
+  // The f32 case above gates the ALGORITHM. This one gates the PRODUCTION dtype
+  // policy: upstream's stream is bf16 with fp32 islands (both patch projections,
+  // the time embedder, both output heads — minimax_h3_transformer.py:85-101), and
+  // the explicit `dtype=_BF16_DTYPE` casts inside `_modulate_scale_shift` /
+  // `_modulate_gate`. Same code path, different rounding points.
+  const std::unique_ptr<GoldenWeights> weights = BuildGoldenWeights();
+  const MiniMaxH3DitParams& p = weights->params;
+
+  const MiniMaxH3PackedSequence packed = BuildMiniMaxH3PackedSequence(
+      vllm_test::kH3Fl2va_text_len, vllm_test::kH3Fl2va_latent_t, vllm_test::kH3Fl2va_latent_h,
+      vllm_test::kH3Fl2va_latent_w, vllm_test::kH3Fl2va_audio_t, vllm_test::kH3Fl2va_audio_channel,
+      /*include_keyframe_cond=*/true, {0}, vllm_test::kH3Fl2va_frame_count);
+
+  const int64_t seq_len = packed.seq_len;
+  const int64_t video_width = p.video_row_width();
+  const int64_t num_img = static_cast<int64_t>(packed.img_pos.size());
+  const int64_t num_audio = static_cast<int64_t>(packed.audio_pos.size());
+  const int64_t num_text = static_cast<int64_t>(packed.text_pos.size());
+
+  std::vector<float> x(static_cast<size_t>(seq_len * video_width), 0.0f);
+  const std::vector<float> video_rows = MakeParam("dit.video_rows", num_img * video_width, 1.0);
+  for (int64_t r = 0; r < num_img; ++r) {
+    std::memcpy(x.data() + packed.img_pos[static_cast<size_t>(r)] * video_width,
+                video_rows.data() + r * video_width,
+                static_cast<size_t>(video_width) * sizeof(float));
+  }
+  std::vector<float> audio_x(static_cast<size_t>(seq_len * p.audio_latents_dim), 0.0f);
+  const std::vector<float> audio_rows =
+      MakeParam("dit.audio_rows", num_audio * p.audio_latents_dim, 1.0);
+  for (int64_t r = 0; r < num_audio; ++r) {
+    std::memcpy(audio_x.data() + packed.audio_pos[static_cast<size_t>(r)] * p.audio_latents_dim,
+                audio_rows.data() + r * p.audio_latents_dim,
+                static_cast<size_t>(p.audio_latents_dim) * sizeof(float));
+  }
+  const std::vector<float> prompt_embeds =
+      MakeParam("dit.prompt_embeds", num_text * p.text_dim, 1.0);
+  const std::vector<float> unique_timesteps(
+      vllm_test::kH3DitUniqueTimesteps,
+      vllm_test::kH3DitUniqueTimesteps + vllm_test::kH3Dit_unique_timesteps);
+  const std::vector<int64_t> inverse(vllm_test::kH3DitInverseIndices,
+                                     vllm_test::kH3DitInverseIndices + seq_len);
+  const std::vector<int32_t> refiner_cu = {0, static_cast<int32_t>(num_text),
+                                           static_cast<int32_t>(num_text)};
+
+  MiniMaxH3DitInputs in;
+  in.seq_len = seq_len;
+  in.x = x.data();
+  in.audio_x = audio_x.data();
+  in.img_position_ids = packed.img_position_ids.data();
+  in.unique_timesteps = unique_timesteps.data();
+  in.num_unique_timesteps = static_cast<int64_t>(unique_timesteps.size());
+  in.inverse_indices = inverse.data();
+  in.token_tags = packed.token_tags.data();
+  in.prompt_embeds = prompt_embeds.data();
+  in.img_pos = packed.img_pos.data();
+  in.num_img_pos = num_img;
+  in.audio_pos = packed.audio_pos.data();
+  in.num_audio_pos = num_audio;
+  in.text_pos = packed.text_pos.data();
+  in.num_text_pos = num_text;
+  in.infer_out_pos = packed.img_pos.data();
+  in.num_infer_out_pos = num_img;
+  in.update_mask = packed.update_mask.data();
+  in.cu_seqlens = packed.cu_seqlens.data();
+  in.num_cu_seqlens = static_cast<int64_t>(packed.cu_seqlens.size());
+  in.refiner_cu_seqlens = refiner_cu.data();
+  in.num_refiner_cu_seqlens = static_cast<int64_t>(refiner_cu.size());
+
+  const MiniMaxH3DitOutputs got =
+      MiniMaxH3DitForward(Cpu(), p, weights->views, in, vt::DType::kBF16);
+
+  // Tolerance is bf16-scale on purpose: both sides round at the same points, but
+  // the GEMM accumulation order still differs (ours is the vt CPU kernel, the
+  // reference is torch). The gate is that the CAST POINTS agree — a misplaced or
+  // missing cast moves the result far more than accumulation order does.
+  const double video_err =
+      MaxAbsDiff(got.video_logits, vllm_test::kH3DitVideoLogitsBf16Golden, got.video_logits.size());
+  const double audio_err =
+      MaxAbsDiff(got.audio_logits, vllm_test::kH3DitAudioLogitsBf16Golden, got.audio_logits.size());
+  INFO("bf16 video max|diff| = " << video_err << ", audio max|diff| = " << audio_err);
+  CHECK(video_err <= 5e-3);
+  CHECK(audio_err <= 5e-3);
+
+  // And the bf16 stream must differ from the f32 stream — otherwise the dtype
+  // policy is not actually being applied and this test proves nothing.
+  const double vs_f32 =
+      MaxAbsDiff(got.video_logits, vllm_test::kH3DitVideoLogitsGolden, got.video_logits.size());
+  CHECK(vs_f32 > 1e-5);
+}
+
+TEST_CASE("minimax_h3: request planning matches upstream") {
+  // time_request.py executed verbatim by the generator; the three shape helpers
+  // are restated there from pipeline_minimax_h3.py:121-122, 207-222, 393-434.
+  for (int64_t i = 0; i < vllm_test::kH3PlanFrameCases; ++i) {
+    const int64_t input = vllm_test::kH3PlanFrameInputs[i];
+    const int64_t aligned = vllm::MiniMaxH3AlignFrameCount(input);
+    CHECK(aligned == vllm_test::kH3PlanFrameAligned[i]);
+    const int64_t latent_t = vllm::MiniMaxH3VideoLatentT(aligned);
+    CHECK(latent_t == vllm_test::kH3PlanVideoLatentT[i]);
+    CHECK(vllm::MiniMaxH3FrameCountFromVideoLatentT(latent_t) ==
+          vllm_test::kH3PlanFrameFromLatentT[i]);
+    CHECK(vllm::MiniMaxH3AudioLatentT(static_cast<double>(aligned) / 24.0) ==
+          vllm_test::kH3PlanAudioLatentT[i]);
+  }
+  // A latent T that is neither 1 nor 5n+2 is rejected, not silently rounded.
+  CHECK_THROWS(vllm::MiniMaxH3FrameCountFromVideoLatentT(4));
+
+  int64_t offset = 0;
+  for (int64_t c = 0; c < vllm_test::kH3PlanSigmaCases; ++c) {
+    const std::vector<double> sigmas = vllm::MiniMaxH3TimeShiftSigmas(
+        vllm_test::kH3PlanSigmaSteps[c], vllm_test::kH3PlanSigmaShifts[c]);
+    REQUIRE(static_cast<int64_t>(sigmas.size()) == vllm_test::kH3PlanSigmaLengths[c]);
+    for (size_t i = 0; i < sigmas.size(); ++i) {
+      CHECK(static_cast<float>(sigmas[i]) ==
+            doctest::Approx(vllm_test::kH3PlanSigmasGolden[offset + i]).epsilon(1e-6));
+    }
+    // Multi-step schedules must terminate at sigma 0 so the last Euler step is
+    // the identity (scheduling:89-92).
+    if (vllm_test::kH3PlanSigmaSteps[c] > 1) CHECK(sigmas.back() == 0.0);
+    offset += static_cast<int64_t>(sigmas.size());
+  }
+  CHECK_THROWS(vllm::MiniMaxH3TimeShiftSigmas(50, 0.0));
+  CHECK_THROWS(vllm::MiniMaxH3TimeShiftSigmas(0, 6.0));
+
+  for (int64_t c = 0; c < vllm_test::kH3PlanRefImageCases; ++c) {
+    const std::pair<int64_t, int64_t> shape = vllm::MiniMaxH3ReferenceImageShape(
+        vllm_test::kH3PlanRefImageInputs[c * 2], vllm_test::kH3PlanRefImageInputs[c * 2 + 1]);
+    CHECK(shape.first == vllm_test::kH3PlanRefImageGolden[c * 2]);
+    CHECK(shape.second == vllm_test::kH3PlanRefImageGolden[c * 2 + 1]);
+  }
+  CHECK_THROWS(vllm::MiniMaxH3ReferenceImageShape(5000, 100));  // aspect out of [1:4, 4:1]
+
+  const char* tasks[] = {"t2va", "ref2va", "t2va", "t2va", "fl2va", "fl2va", "t2va"};
+  for (int64_t c = 0; c < vllm_test::kH3PlanShapeCases; ++c) {
+    const vllm::MiniMaxH3ShapePlan plan = vllm::MiniMaxH3ResolveShape(
+        tasks[c], vllm_test::kH3PlanShapeDurations[c], vllm_test::kH3PlanShapeNumFrames[c],
+        vllm_test::kH3PlanShapeHeights[c], vllm_test::kH3PlanShapeWidths[c],
+        vllm_test::kH3PlanShapeImageW[c], vllm_test::kH3PlanShapeImageH[c]);
+    INFO("shape case " << c << " task=" << tasks[c]);
+    CHECK(plan.height == vllm_test::kH3PlanShapeGolden[c * 5 + 0]);
+    CHECK(plan.width == vllm_test::kH3PlanShapeGolden[c * 5 + 1]);
+    CHECK(plan.num_frames == vllm_test::kH3PlanShapeGolden[c * 5 + 2]);
+    CHECK(plan.latent_t == vllm_test::kH3PlanShapeGolden[c * 5 + 3]);
+    CHECK(plan.audio_t == vllm_test::kH3PlanShapeGolden[c * 5 + 4]);
+  }
+
+  // Task dispatch (pipeline_minimax_h3.py:374-391).
+  const std::vector<std::string> fl2va_partition = {"t2va", "fl2va"};
+  const std::vector<std::string> ref2va_partition = {"ref2va"};
+  CHECK(vllm::MiniMaxH3ResolveTask("", "FL2VA", /*has_image=*/false, fl2va_partition) == "t2va");
+  CHECK(vllm::MiniMaxH3ResolveTask("", "FL2VA", /*has_image=*/true, fl2va_partition) == "fl2va");
+  CHECK(vllm::MiniMaxH3ResolveTask("", "ref2va", /*has_image=*/false, ref2va_partition) == "ref2va");
+  CHECK(vllm::MiniMaxH3ResolveTask("T2VA", "FL2VA", false, fl2va_partition) == "t2va");
+  // A partition must refuse a task it does not carry, rather than guessing.
+  CHECK_THROWS(vllm::MiniMaxH3ResolveTask("ref2va", "FL2VA", false, fl2va_partition));
+}
+
+TEST_CASE("minimax_h3: the denoise loop advances targets and pins condition rows") {
+  // The loop itself has no upstream golden (upstream's own loop test needs the
+  // checkpoint), so this gates its INVARIANTS, which are what the CFG-distilled
+  // schedule actually guarantees (denoise_loop.py:191-238): pinned keyframe rows
+  // are reset to their anchor after EVERY step, target rows move, audio advances
+  // on its own sigma schedule, and nothing goes non-finite.
+  const std::unique_ptr<GoldenWeights> weights = BuildGoldenWeights();
+  const MiniMaxH3DitParams& p = weights->params;
+
+  vllm::MiniMaxH3DenoiseBranch branch;
+  branch.packed = BuildMiniMaxH3PackedSequence(
+      vllm_test::kH3Fl2va_text_len, vllm_test::kH3Fl2va_latent_t, vllm_test::kH3Fl2va_latent_h,
+      vllm_test::kH3Fl2va_latent_w, vllm_test::kH3Fl2va_audio_t, vllm_test::kH3Fl2va_audio_channel,
+      /*include_keyframe_cond=*/true, {0}, vllm_test::kH3Fl2va_frame_count);
+  branch.token_tags = branch.packed.token_tags;
+
+  const int64_t num_img = static_cast<int64_t>(branch.packed.img_pos.size());
+  const int64_t num_audio = static_cast<int64_t>(branch.packed.audio_pos.size());
+  const int64_t num_text = static_cast<int64_t>(branch.packed.text_pos.size());
+  const int64_t video_width = p.video_row_width();
+  branch.text_embeddings = MakeParam("loop.prompt_embeds", num_text * p.text_dim, 1.0);
+
+  const std::vector<float> initial_video = MakeParam("loop.video", num_img * video_width, 1.0);
+  const std::vector<float> initial_audio =
+      MakeParam("loop.audio", num_audio * p.audio_latents_dim, 1.0);
+  int64_t cond_rows = 0;
+  for (uint8_t flag : branch.packed.update_mask) cond_rows += flag ? 0 : 1;
+  REQUIRE(cond_rows > 0);
+  const std::vector<float> keyframe = MakeParam("loop.keyframe", cond_rows * video_width, 1.0);
+
+  // A 2-step schedule: enough to exercise the chaining and the per-step reset.
+  const std::vector<double> sigmas_video = {0.6, 0.3, 0.0};
+  const std::vector<double> sigmas_audio = {0.5, 0.25, 0.0};
+
+  const vllm::MiniMaxH3DenoiseResult result = vllm::MiniMaxH3DenoiseLoop(
+      Cpu(), p, weights->views, branch, initial_video, initial_audio, keyframe, {}, sigmas_video,
+      sigmas_audio, vt::DType::kF32);
+
+  REQUIRE(result.video_rows.size() == initial_video.size());
+  REQUIRE(result.audio_rows.size() == initial_audio.size());
+  for (float value : result.video_rows) REQUIRE(std::isfinite(value));
+  for (float value : result.audio_rows) REQUIRE(std::isfinite(value));
+
+  // Pinned rows must equal their anchors exactly; target rows must have moved.
+  int64_t cond_index = 0, moved = 0;
+  for (int64_t r = 0; r < num_img; ++r) {
+    if (branch.packed.update_mask[static_cast<size_t>(r)]) {
+      for (int64_t i = 0; i < video_width; ++i) {
+        if (result.video_rows[static_cast<size_t>(r * video_width + i)] !=
+            initial_video[static_cast<size_t>(r * video_width + i)]) {
+          ++moved;
+          break;
+        }
+      }
+      continue;
+    }
+    for (int64_t i = 0; i < video_width; ++i) {
+      CHECK(result.video_rows[static_cast<size_t>(r * video_width + i)] ==
+            keyframe[static_cast<size_t>(cond_index * video_width + i)]);
+    }
+    ++cond_index;
+  }
+  CHECK(cond_index == cond_rows);
+  CHECK(moved == num_img - cond_rows);  // every target row advanced
+
+  // The terminal sigma is 0, so the last step is the identity on the state and the
+  // schedule must land somewhere finite and different from where it started.
+  bool audio_moved = false;
+  for (size_t i = 0; i < result.audio_rows.size(); ++i) {
+    if (result.audio_rows[i] != initial_audio[i]) audio_moved = true;
+  }
+  CHECK(audio_moved);
+}
+
+TEST_CASE("minimax_h3: the audio VAE decoder matches the checkpoint's own remote code") {
+  // H3's VAEs are checkpoint REMOTE CODE (loaded via trust_remote_code), so a
+  // no-Python engine must REIMPLEMENT them. This gates our reimplementation
+  // against the checkpoint's OWN modules, executed at reduced dimensions by
+  // scripts/gen-minimax-h3-audio-vae-goldens.py. The remote code is not vendored
+  // here; the generator takes a path to a local copy.
+  vllm::MiniMaxH3AudioVaeConfig config;
+  config.num_mels = vllm_test::kH3AudioVaeNumMels;
+  config.upsample_initial_channel = vllm_test::kH3AudioVaeInitialChannel;
+  config.upsample_rates = {2, 2};
+  config.upsample_kernel_sizes = {4, 4};
+  config.resblock_kernel_sizes = {3, 7, 11};
+  config.resblock_dilation_sizes = {{1, 3, 5}, {1, 3, 5}, {1, 3, 5}};
+  config.use_tanh_at_final = false;
+  config.use_bias_at_final = false;
+  config.snake_logscale = true;
+
+  // The kaiser-sinc filter is COMPUTED, not loaded. Prove it first: if the filter
+  // is wrong, every anti-aliased activation is wrong and the decoder mismatch
+  // would be impossible to localize.
+  const std::vector<float> filter = vllm::MiniMaxH3KaiserSincFilter1d(0.5 / 2, 0.6 / 2, 12);
+  REQUIRE(filter.size() == std::size(vllm_test::kH3AudioVaeUpFilterGolden));
+  double filter_err = 0.0;
+  double filter_sum = 0.0;
+  for (size_t i = 0; i < filter.size(); ++i) {
+    filter_err = std::max(filter_err, std::abs(static_cast<double>(filter[i]) -
+                                               vllm_test::kH3AudioVaeUpFilterGolden[i]));
+    filter_sum += filter[i];
+  }
+  INFO("kaiser-sinc filter max|diff| = " << filter_err);
+  CHECK(filter_err <= 1e-6);
+  CHECK(filter_sum == doctest::Approx(1.0).epsilon(1e-6));  // normalized to sum 1
+
+  // Rebuild every parameter from the shared stream, using the checkpoint's own
+  // state_dict names and the generator's per-role scales.
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& name, int64_t count, double scale, double offset) {
+    weights.tensors[name] = MakeParam(name, count, scale, offset);
+  };
+  auto put_conv = [&](const std::string& prefix, int64_t out_channels, int64_t in_channels,
+                      int64_t kernel, bool bias) {
+    put(prefix + ".parametrizations.weight.original0", out_channels, 0.03, 0.15);
+    put(prefix + ".parametrizations.weight.original1", out_channels * in_channels * kernel, 0.08, 0.0);
+    if (bias) put(prefix + ".bias", out_channels, 0.05, 0.0);
+  };
+  auto put_act = [&](const std::string& prefix, int64_t channels) {
+    put(prefix + ".act.alpha", channels, 0.2, 0.0);
+    put(prefix + ".act.beta", channels, 0.2, 0.0);
+  };
+
+  const int64_t initial = config.upsample_initial_channel;
+  put_conv("conv_pre", initial, config.num_mels, 7, /*bias=*/true);
+  int64_t channels = initial;
+  for (size_t i = 0; i < config.upsample_rates.size(); ++i) {
+    const int64_t out_channels = initial / (int64_t{1} << (i + 1));
+    // ConvTranspose1d weight is [in, out, k]; weight-norm dim 0 is IN.
+    const std::string prefix = "ups." + std::to_string(i) + ".0";
+    put(prefix + ".parametrizations.weight.original0", channels, 0.03, 0.15);
+    put(prefix + ".parametrizations.weight.original1",
+        channels * out_channels * config.upsample_kernel_sizes[i], 0.08, 0.0);
+    put(prefix + ".bias", out_channels, 0.05, 0.0);
+    channels = out_channels;
+    for (size_t j = 0; j < config.resblock_kernel_sizes.size(); ++j) {
+      const std::string block =
+          "resblocks." + std::to_string(i * config.resblock_kernel_sizes.size() + j);
+      const int64_t kernel = config.resblock_kernel_sizes[j];
+      for (size_t d = 0; d < config.resblock_dilation_sizes[j].size(); ++d) {
+        put_conv(block + ".convs1." + std::to_string(d), channels, channels, kernel, true);
+        put_conv(block + ".convs2." + std::to_string(d), channels, channels, kernel, true);
+        put_act(block + ".activations." + std::to_string(2 * d), channels);
+        put_act(block + ".activations." + std::to_string(2 * d + 1), channels);
+      }
+    }
+  }
+  put_act("activation_post", channels);
+  put_conv("conv_post", 1, channels, 7, /*bias=*/false);
+
+  const std::vector<float> latent =
+      MakeParam("audiovae.input", config.num_mels * vllm_test::kH3AudioVaeFrames, 1.0);
+  int64_t out_samples = 0;
+  const std::vector<float> waveform = vllm::MiniMaxH3AudioVaeDecode(
+      config, weights, latent, vllm_test::kH3AudioVaeFrames, &out_samples);
+
+  CHECK(out_samples == vllm_test::kH3AudioVaeOutSamples);
+  REQUIRE(waveform.size() == std::size(vllm_test::kH3AudioVaeWaveformGolden));
+  const double err =
+      MaxAbsDiff(waveform, vllm_test::kH3AudioVaeWaveformGolden, waveform.size());
+  INFO("audio VAE waveform max|diff| = " << err);
+  CHECK(err <= 1e-5);
+  // The golden is deliberately unsaturated: a clamped golden would hide errors.
+  for (float value : waveform) {
+    CHECK(value > -1.0f);
+    CHECK(value < 1.0f);
+  }
+
+  // Weight-norm materialization: ||w_c|| must equal g_c exactly.
+  const std::vector<float> g = {2.0f, 0.5f};
+  const std::vector<float> v = {3.0f, 4.0f, 0.0f, 1.0f};  // rows [3,4] and [0,1]
+  const std::vector<float> w = vllm::MiniMaxH3MaterializeWeightNorm(g, v, 2);
+  REQUIRE(w.size() == 4);
+  CHECK(w[0] == doctest::Approx(2.0f * 3.0f / 5.0f));
+  CHECK(w[1] == doctest::Approx(2.0f * 4.0f / 5.0f));
+  CHECK(w[2] == doctest::Approx(0.0f));
+  CHECK(w[3] == doctest::Approx(0.5f));
+}
+
+namespace {
+
+// The reduced audio-VAE ENCODER configuration the generator ran upstream at.
+vllm::MiniMaxH3AudioVaeEncoderConfig ReducedAudioEncoderConfig() {
+  vllm::MiniMaxH3AudioVaeEncoderConfig cfg;
+  cfg.encoder_dim = vllm_test::kH3AudioEncDim;
+  cfg.encoder_rates.assign(std::begin(vllm_test::kH3AudioEncRates),
+                           std::end(vllm_test::kH3AudioEncRates));
+  cfg.latent_dim = vllm_test::kH3AudioEncLatentDim;
+  cfg.vae_latent_channels = vllm_test::kH3AudioEncVaeChannels;
+  cfg.attn_proj = true;
+  cfg.attn_proj_heads = vllm_test::kH3AudioEncHeads;
+  return cfg;
+}
+
+// Rebuild every encoder parameter from the shared stream, keyed by the CHECKPOINT's
+// own state_dict name, applying exactly the per-role scales
+// gen-minimax-h3-audio-vae-encoder-goldens.py :: fill_from_stream applies. The rule
+// is expressed once, here, for the same reason it is expressed once there: a scale
+// that drifts on one side turns the golden into noise.
+void PutEncoderParam(vllm::MiniMaxH3AudioVaeWeights& w, const std::string& full, int64_t count,
+                     const std::string& stream_prefix, bool one_d_norm = false) {
+  auto ends = [&](const std::string& suffix) {
+    return full.size() >= suffix.size() &&
+           full.compare(full.size() - suffix.size(), suffix.size(), suffix) == 0;
+  };
+  // The loader strips `encoder.`; the STREAM is keyed by the unstripped name.
+  std::string key = full;
+  if (key.rfind("encoder.", 0) == 0) key = key.substr(std::strlen("encoder."));
+
+  if (ends("zero_k_bias")) {  // a registered buffer that stays zero
+    w.tensors[key] = std::vector<float>(static_cast<size_t>(count), 0.0f);
+    return;
+  }
+  double scale = 0.1, offset = 0.0;
+  if (ends("original0")) {
+    scale = 0.03;
+    offset = 0.15;
+  } else if (ends("original1")) {
+    scale = 0.08;
+  } else if (ends(".alpha")) {
+    scale = 0.2;
+    offset = 1.0;  // Snake1d divides by (alpha + 1e-9); upstream inits it to ones
+  } else if (ends("bias")) {
+    scale = 0.05;
+  } else if (one_d_norm && full.find("norm") != std::string::npos && ends(".weight")) {
+    scale = 0.1;
+    offset = 1.0;
+  }
+  w.tensors[key] = MakeParam(stream_prefix + full, count, scale, offset);
+}
+
+// Every tensor the reduced encoder + pre_block + mean_proj needs, named exactly as
+// the checkpoint names them.
+vllm::MiniMaxH3AudioVaeWeights BuildAudioEncoderWeights(
+    const vllm::MiniMaxH3AudioVaeEncoderConfig& cfg, const std::string& stream_prefix) {
+  vllm::MiniMaxH3AudioVaeWeights w;
+  auto conv = [&](const std::string& prefix, int64_t out_ch, int64_t in_ch, int64_t k) {
+    PutEncoderParam(w, prefix + ".parametrizations.weight.original0", out_ch, stream_prefix);
+    PutEncoderParam(w, prefix + ".parametrizations.weight.original1", out_ch * in_ch * k,
+                    stream_prefix);
+    PutEncoderParam(w, prefix + ".bias", out_ch, stream_prefix);
+  };
+
+  // block.0: WNConv1d(1, encoder_dim, k=7).
+  conv("encoder.block.0", cfg.encoder_dim, 1, 7);
+  int64_t channels = cfg.encoder_dim;
+  for (size_t i = 0; i < cfg.encoder_rates.size(); ++i) {
+    channels *= 2;
+    const int64_t half = channels / 2;
+    const std::string blk = "encoder.block." + std::to_string(i + 1);
+    for (int64_t u = 0; u < 3; ++u) {  // three dilated ResidualUnits at dim/2
+      const std::string ru = blk + ".block." + std::to_string(u);
+      PutEncoderParam(w, ru + ".block.0.alpha", half, stream_prefix);
+      conv(ru + ".block.1", half, half, 7);
+      PutEncoderParam(w, ru + ".block.2.alpha", half, stream_prefix);
+      conv(ru + ".block.3", half, half, 1);
+    }
+    PutEncoderParam(w, blk + ".block.3.alpha", half, stream_prefix);
+    conv(blk + ".block.4", channels, half, 2 * cfg.encoder_rates[i]);
+  }
+  const size_t rates = cfg.encoder_rates.size();
+  PutEncoderParam(w, "encoder.block." + std::to_string(rates + 1) + ".alpha", channels,
+                  stream_prefix);
+  conv("encoder.block." + std::to_string(rates + 2), cfg.latent_dim, channels, 3);
+
+  // pre_block: AttnProjection(latent_dim -> attn_proj_dim).
+  const int64_t in_dim = cfg.latent_dim, out_dim = cfg.attn_proj_dim();
+  auto norm = [&](const std::string& prefix, int64_t width) {
+    PutEncoderParam(w, prefix + ".weight", width, stream_prefix, /*one_d_norm=*/true);
+    PutEncoderParam(w, prefix + ".bias", width, stream_prefix);
+  };
+  norm("pre_block.norm1", in_dim);
+  norm("pre_block.norm3", in_dim);
+  norm("pre_block.norm2", out_dim);
+  PutEncoderParam(w, "pre_block.attn.q_bias", in_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.attn.v_bias", in_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.attn.zero_k_bias", in_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.attn.qkv.weight", 3 * in_dim * in_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.attn.proj.weight", out_dim * out_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.attn.proj.bias", out_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.proj.weight", out_dim * in_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.proj.bias", out_dim, stream_prefix);
+  norm("pre_block.mlp.norm", out_dim);
+  const int64_t hidden = 2 * out_dim;  // AttnProjection's mlp_ratio is 2
+  PutEncoderParam(w, "pre_block.mlp.w0.weight", hidden * out_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.mlp.w0.bias", hidden, stream_prefix);
+  PutEncoderParam(w, "pre_block.mlp.w1.weight", hidden * out_dim, stream_prefix);
+  PutEncoderParam(w, "pre_block.mlp.w1.bias", hidden, stream_prefix);
+  PutEncoderParam(w, "pre_block.mlp.w2.weight", out_dim * hidden, stream_prefix);
+  PutEncoderParam(w, "pre_block.mlp.w2.bias", out_dim, stream_prefix);
+
+  // mean_proj: a PLAIN Conv1d(attn_proj_dim -> vae_latent_channels, k=1).
+  PutEncoderParam(w, "mean_proj.weight", cfg.vae_latent_channels * out_dim, stream_prefix);
+  PutEncoderParam(w, "mean_proj.bias", cfg.vae_latent_channels, stream_prefix);
+  return w;
+}
+
+}  // namespace
+
+TEST_CASE("minimax_h3: the audio VAE ENCODER matches the checkpoint's own remote code") {
+  // The ANALYSIS half, gated the same way the decoder is: against the CHECKPOINT'S
+  // OWN modules (FL2VA/audio_vae/dac_audio_vae.py + dac_attn_proj.py) executed at
+  // reduced dimensions by scripts/gen-minimax-h3-audio-vae-encoder-goldens.py, in
+  // the exact sequence vLLM-Omni's reference-audio path runs (vae.py:317-325).
+  //
+  // Three STAGES are checked, not just the end: Encoder, then pre_block, then
+  // mean_proj. A single end-to-end number would tell us something is wrong without
+  // telling us which of three quite different subsystems it is.
+  const vllm::MiniMaxH3AudioVaeEncoderConfig cfg = ReducedAudioEncoderConfig();
+  const vllm::MiniMaxH3AudioVaeWeights w = BuildAudioEncoderWeights(cfg, "");
+
+  CHECK(cfg.hop_length() == 4);           // prod(encoder_rates)
+  CHECK(cfg.attn_proj_dim() == vllm_test::kH3AudioEncVaeChannels);
+
+  // The input the oracle ran, drawn from the same stream. If this drifts, nothing
+  // downstream means anything.
+  const std::vector<float> input =
+      MakeParam("audiovae.encoder.input", vllm_test::kH3AudioEncSamples, 1.0);
+  REQUIRE(input.size() == std::size(vllm_test::kH3AudioEncInputGolden));
+  CHECK(MaxAbsDiff(input, vllm_test::kH3AudioEncInputGolden, input.size()) == 0.0);
+
+  // --- stage 1: preprocess + Encoder. The sample count (25) is deliberately NOT a
+  // multiple of hop_length (4): a port that skipped `preprocess` would return 6
+  // frames instead of 7 and fail here.
+  int64_t frames = 0;
+  const std::vector<float> enc = vllm::MiniMaxH3AudioVaeEncoderForward(
+      cfg, w, input, vllm_test::kH3AudioEncSamples, &frames);
+  CHECK(frames == vllm_test::kH3AudioEncFrames);
+  CHECK(frames * cfg.hop_length() > vllm_test::kH3AudioEncSamples);  // the pad really happened
+  REQUIRE(enc.size() == std::size(vllm_test::kH3AudioEncBlockGolden));
+  const double enc_err = MaxAbsDiff(enc, vllm_test::kH3AudioEncBlockGolden, enc.size());
+  INFO("audio VAE encoder (conv stack) max|diff| = " << enc_err);
+  CHECK(enc_err <= 1e-5);
+
+  // --- stage 2: pre_block (AttnProjection). Our forward takes [frames, latent_dim]
+  // rows; the golden is the upstream [1, attn_proj_dim, frames] tensor, so the
+  // comparison transposes.
+  const int64_t in_dim = cfg.latent_dim, out_dim = cfg.attn_proj_dim();
+  std::vector<float> tokens(static_cast<size_t>(frames * in_dim));
+  for (int64_t c = 0; c < in_dim; ++c) {
+    for (int64_t t = 0; t < frames; ++t) {
+      tokens[static_cast<size_t>(t * in_dim + c)] = enc[static_cast<size_t>(c * frames + t)];
+    }
+  }
+  const std::vector<float> proj = vllm::MiniMaxH3AudioVaeAttnProjection(cfg, w, tokens, frames);
+  REQUIRE(proj.size() == std::size(vllm_test::kH3AudioEncAttnProjGolden));
+  double proj_err = 0.0;
+  for (int64_t c = 0; c < out_dim; ++c) {
+    for (int64_t t = 0; t < frames; ++t) {
+      proj_err = std::max(proj_err,
+                          std::abs(static_cast<double>(proj[static_cast<size_t>(t * out_dim + c)]) -
+                                   vllm_test::kH3AudioEncAttnProjGolden[c * frames + t]));
+    }
+  }
+  INFO("audio VAE encoder (AttnProjection) max|diff| = " << proj_err);
+  CHECK(proj_err <= 1e-5);
+
+  // --- stage 3: the whole encode, ending at mean_proj (the distribution MEAN).
+  int64_t latent_frames = 0;
+  const std::vector<float> latent = vllm::MiniMaxH3AudioVaeEncodeToLatent(
+      cfg, w, input, vllm_test::kH3AudioEncSamples, &latent_frames);
+  CHECK(latent_frames == frames);
+  REQUIRE(latent.size() == std::size(vllm_test::kH3AudioEncMeanGolden));
+  const double mean_err = MaxAbsDiff(latent, vllm_test::kH3AudioEncMeanGolden, latent.size());
+  INFO("audio VAE encode-to-latent max|diff| = " << mean_err);
+  CHECK(mean_err <= 1e-5);
+
+  // The MEAN, not a sample: the same reference must encode identically every time,
+  // or a reference would condition differently on every run.
+  int64_t again_frames = 0;
+  const std::vector<float> again = vllm::MiniMaxH3AudioVaeEncodeToLatent(
+      cfg, w, input, vllm_test::kH3AudioEncSamples, &again_frames);
+  CHECK(MaxAbsDiff(again, latent.data(), again.size()) == 0.0);
+  // `logs_proj` must play no part -- the loader never even loads it.
+  CHECK_FALSE(w.Has("logs_proj.weight"));
+}
+
+TEST_CASE("minimax_h3: audio-VAE encode produces the packed rows a reference block claims") {
+  // The row layout is the contract between the encoder and the packed sequence: a
+  // block claiming `ref_audio_t * audio_channel` rows must get exactly those rows,
+  // CHANNEL-MAJOR, in the DiT's normalized latent space (vae.py:327-341).
+  const vllm::MiniMaxH3AudioVaeEncoderConfig cfg = ReducedAudioEncoderConfig();
+  const vllm::MiniMaxH3AudioVaeWeights w = BuildAudioEncoderWeights(cfg, "");
+  const int64_t width = cfg.vae_latent_channels;
+  const int64_t samples = vllm_test::kH3AudioEncSamples;
+
+  // Two channels: the SAME waveform in both, so the two halves must be identical.
+  std::vector<float> stereo;
+  const std::vector<float> mono = MakeParam("audiovae.encoder.input", samples, 1.0);
+  stereo.insert(stereo.end(), mono.begin(), mono.end());
+  stereo.insert(stereo.end(), mono.begin(), mono.end());
+
+  int64_t audio_t = 0;
+  const std::vector<float> rows =
+      vllm::MiniMaxH3AudioVaeEncodeToRows(cfg, w, stereo, 2, samples, {}, {}, &audio_t);
+  CHECK(audio_t == vllm_test::kH3AudioEncFrames);
+  REQUIRE(rows.size() == static_cast<size_t>(2 * audio_t * width));
+  // Channel-major: rows [0, audio_t) are channel 0, [audio_t, 2*audio_t) channel 1.
+  double channel_diff = 0.0;
+  for (int64_t i = 0; i < audio_t * width; ++i) {
+    channel_diff = std::max(channel_diff, std::abs(static_cast<double>(rows[i]) -
+                                                   rows[audio_t * width + i]));
+  }
+  CHECK(channel_diff == 0.0);
+  // And row r of channel 0 is the mean_proj latent's frame r, transposed.
+  int64_t lf = 0;
+  const std::vector<float> latent = vllm::MiniMaxH3AudioVaeEncodeToLatent(cfg, w, mono, samples, &lf);
+  for (int64_t t = 0; t < audio_t; ++t) {
+    for (int64_t d = 0; d < width; ++d) {
+      CHECK(rows[static_cast<size_t>(t * width + d)] ==
+            doctest::Approx(latent[static_cast<size_t>(d * audio_t + t)]));
+    }
+  }
+
+  // With statistics the rows move into the DiT's normalized space: (x - mean) / std.
+  std::vector<float> mean(static_cast<size_t>(width)), stdev(static_cast<size_t>(width));
+  for (int64_t d = 0; d < width; ++d) {
+    mean[static_cast<size_t>(d)] = 0.25f * static_cast<float>(d + 1);
+    stdev[static_cast<size_t>(d)] = 1.5f + 0.5f * static_cast<float>(d);
+  }
+  int64_t nt = 0;
+  const std::vector<float> normalized =
+      vllm::MiniMaxH3AudioVaeEncodeToRows(cfg, w, stereo, 2, samples, mean, stdev, &nt);
+  CHECK(nt == audio_t);
+  for (int64_t t = 0; t < audio_t; ++t) {
+    for (int64_t d = 0; d < width; ++d) {
+      const double raw = rows[static_cast<size_t>(t * width + d)];
+      CHECK(normalized[static_cast<size_t>(t * width + d)] ==
+            doctest::Approx((raw - mean[static_cast<size_t>(d)]) / stdev[static_cast<size_t>(d)])
+                .epsilon(1e-5));
+    }
+  }
+}
+
+TEST_CASE("minimax_h3: reference-audio rows take the SHIPPED 32-wide path, noise aug included") {
+  // The golden config narrows 16 -> 4 through the adaptive average pool. The
+  // SHIPPED one does not pool at all in the same way, and its row width is the 32
+  // that MiniMaxH3AudioCondNoiseAug hard-codes (as upstream does), so both the
+  // no-pool branch and the noise-aug delegation are only reachable at 32.
+  vllm::MiniMaxH3AudioVaeEncoderConfig cfg;
+  cfg.encoder_dim = 2;
+  cfg.encoder_rates = {2, 2};
+  cfg.latent_dim = 64;
+  cfg.vae_latent_channels = vllm::kMiniMaxH3AudioRowWidth;  // 32
+  cfg.attn_proj = true;
+  cfg.attn_proj_heads = 2;
+  // 64 % 32 == 0, so attn_proj_dim is vae_latent_channels itself, and
+  // head_dim = 64 / 2 = 32 == out_dim: the adaptive pool is a NO-OP here.
+  CHECK(cfg.attn_proj_dim() == vllm::kMiniMaxH3AudioRowWidth);
+  const vllm::MiniMaxH3AudioVaeWeights w = BuildAudioEncoderWeights(cfg, "wide.");
+
+  const int64_t channels = vllm::kMiniMaxH3AudioChannels;
+  const int64_t samples = 20;  // hop 4 -> 5 latent frames
+  const std::vector<float> wave = MakeParam("wide.wave", channels * samples, 0.8);
+
+  vllm::MiniMaxH3RefBlock block{};
+  const std::vector<float> clean = vllm::MiniMaxH3EncodeReferenceAudio(
+      cfg, w, wave, channels, samples, {}, {}, /*noise_aug=*/1.0, {}, &block);
+  CHECK(block.kind == vllm::MiniMaxH3RefBlock::Kind::kAudio);
+  CHECK(block.ref_audio_t == samples / cfg.hop_length());
+  REQUIRE(clean.size() ==
+          static_cast<size_t>(channels * block.ref_audio_t * vllm::kMiniMaxH3AudioRowWidth));
+  for (float v : clean) CHECK(std::isfinite(v));
+
+  // noise_aug < 1 must DELEGATE to the already-gated mix rather than reimplement
+  // it: out = aug*clean + (1-aug)*noise, over the same rows.
+  const std::vector<float> noise = MakeParam("wide.noise", clean.size(), 0.5);
+  const double aug = 0.35;
+  const std::vector<float> mixed = vllm::MiniMaxH3EncodeReferenceAudio(
+      cfg, w, wave, channels, samples, {}, {}, aug, noise, &block);
+  REQUIRE(mixed.size() == clean.size());
+  double mix_err = 0.0;
+  for (size_t i = 0; i < mixed.size(); ++i) {
+    const double want = aug * clean[i] + (1.0 - aug) * noise[i];
+    mix_err = std::max(mix_err, std::abs(static_cast<double>(mixed[i]) - want));
+  }
+  INFO("reference-audio noise-aug mix max|diff| = " << mix_err);
+  CHECK(mix_err <= 1e-6);
+  // And it really MOVED: a delegation that silently returned `clean` would pass
+  // every shape check above.
+  CHECK(MaxAbsDiff(mixed, clean.data(), clean.size()) > 1e-3);
+
+  // A mono waveform handed in as stereo is refused: the packed layout is
+  // channel-major over kMiniMaxH3AudioChannels, so a one-channel encode would
+  // silently claim half the rows a block declares.
+  CHECK_THROWS(vllm::MiniMaxH3EncodeReferenceAudio(cfg, w, wave, 1, samples, {}, {}, 1.0, {},
+                                                   nullptr));
+}
+
+TEST_CASE("minimax_h3: a REAL ComfyUI GGUF resolves onto our weight contract") {
+  // The whole point of the GGUF arm: the quantized checkpoints are the ones that
+  // FIT this hardware. This gates the loader against the actual 535-tensor
+  // manifest of `MiniMax-H3-FL2VA-Q3_K_M.gguf` (names/dims/types read from the
+  // file's own header by scripts/gen-minimax-h3-gguf-manifest.py) — no weight
+  // bytes, no download.
+  CHECK(std::string(vllm_test::kH3GgufArchitecture) == "wan");  // ComfyUI's arch id
+  CHECK(vllm_test::kH3GgufVersion == 3);
+  REQUIRE(vllm_test::kH3GgufTensorCount == static_cast<int64_t>(std::size(vllm_test::kH3GgufTensors)));
+
+  // Resolve every real tensor to its logical (torch) shape.
+  std::vector<vllm::MiniMaxH3TensorSpec> manifest;
+  manifest.reserve(static_cast<size_t>(vllm_test::kH3GgufTensorCount));
+  for (const vllm_test::H3GgufTensor& t : vllm_test::kH3GgufTensors) {
+    const std::vector<int64_t> dims(t.dims, t.dims + t.n_dims);
+    const std::vector<int64_t> orig(t.orig_shape, t.orig_shape + t.orig_n_dims);
+    vllm::MiniMaxH3TensorSpec spec;
+    spec.name = t.name;
+    spec.shape = vllm::MiniMaxH3GgufLogicalShape(dims, orig);
+    spec.fp32 = t.ggml_type == 0;
+    manifest.push_back(std::move(spec));
+  }
+
+  // The geometry derived from SHAPES ALONE must be the shipped H3 geometry —
+  // a ComfyUI GGUF ships no transformer config, so this is the load path.
+  const MiniMaxH3DitParams p = vllm::ParseMiniMaxH3DitParamsFromGgufManifest(manifest);
+  CHECK(p.num_layers == 50);
+  CHECK(p.token_refiner_num_layers == 2);
+  CHECK(p.hidden_size == 5376);
+  CHECK(p.num_attention_heads == 56);
+  CHECK(p.attention_head_dim == 128);
+  CHECK(p.ffn_hidden_size == 14336);
+  CHECK(p.latents_dim == 24);
+  CHECK(p.audio_latents_dim == 32);
+  CHECK(p.text_dim == 5120);
+  CHECK(p.timestep_input_dim == 256);
+  CHECK(p.time_embed_dim == 2688);
+  CHECK(p.rope_inv_freq_len == 16);
+  CHECK(p.video_row_width() == 96);
+
+  // And the manifest must cover our contract EXACTLY: the ComfyUI GGUF keeps the
+  // checkpoint's own names, so this is an identity map, not a rename table.
+  const std::vector<vllm::MiniMaxH3TensorSpec> expected = EnumerateMiniMaxH3DitTensors(p);
+  CHECK(manifest.size() == expected.size());
+  std::map<std::string, std::vector<int64_t>> got;
+  for (const vllm::MiniMaxH3TensorSpec& spec : manifest) got[spec.name] = spec.shape;
+  for (const vllm::MiniMaxH3TensorSpec& want : expected) {
+    INFO("contract tensor " << want.name);
+    const auto it = got.find(want.name);
+    REQUIRE(it != got.end());
+    CHECK(it->second == want.shape);
+  }
+
+  // The AdaLN projections are the reshaped case: ne is block-aligned nonsense
+  // ([256, 1016064]) and the true shape comes from comfy.gguf.orig_shape.
+  bool saw_reshaped = false;
+  for (const vllm_test::H3GgufTensor& t : vllm_test::kH3GgufTensors) {
+    if (std::string(t.name) != "blocks.0.adaln_proj.linear.weight") continue;
+    saw_reshaped = true;
+    CHECK(t.orig_n_dims == 2);
+    CHECK(t.orig_shape[0] == 96768);  // 18 * 5376
+    CHECK(t.orig_shape[1] == 2688);   // time_embed_dim
+    CHECK(t.dims[0] == 256);          // one Q3_K block along the fastest axis
+    // 2688 is NOT a multiple of the 256-element Q3_K block, which is exactly why
+    // ComfyUI reshaped it and recorded orig_shape.
+    CHECK(2688 % 256 != 0);
+  }
+  CHECK(saw_reshaped);
+
+  // The reversal rule on a NON-reshaped quantized tensor.
+  const std::vector<int64_t> qkv =
+      vllm::MiniMaxH3GgufLogicalShape({5376, 21504}, {});
+  REQUIRE(qkv.size() == 2);
+  CHECK(qkv[0] == 21504);  // 3 * 56 * 128
+  CHECK(qkv[1] == 5376);
+  // 1-D tensors stay 1-D.
+  const std::vector<int64_t> norm = vllm::MiniMaxH3GgufLogicalShape({5376}, {});
+  REQUIRE(norm.size() == 1);
+  CHECK(norm[0] == 5376);
+
+  // The fp32 islands must still be unquantized in the GGUF: quantizing a patch
+  // projection or an output head would silently break the dtype policy.
+  std::map<std::string, uint32_t> types;
+  for (const vllm_test::H3GgufTensor& t : vllm_test::kH3GgufTensors) types[t.name] = t.ggml_type;
+  for (const char* name : {"blocks.0.norm1.weight", "blocks.0.attn.q_norm.weight",
+                           "final_layer.norm.weight", "rope.inv_freq",
+                           "time_embedder.proj_in.weight", "final_layer.video_out.weight",
+                           "final_layer.audio_out.weight", "audio_patch_proj.bias"}) {
+    const auto it = types.find(name);
+    INFO("fp32 island " << name);
+    REQUIRE(it != types.end());
+    CHECK(it->second != 11u);  // not Q3_K
+  }
+}
+
+TEST_CASE("minimax_h3: the REAL NVFP4 checkpoint lands on our existing NVFP4 layout") {
+  // The NVFP4 arm is the SPEED path: sm_121 has native FP4 tensor cores and this
+  // project already ships a tuned NVFP4 stack (cutlass FP4 GEMM, the Laguna arm).
+  // This gates the real `minimax_h3_ref2va_nvfp4_full.safetensors` manifest, read
+  // from the file's own header by range request — no payload downloaded.
+  REQUIRE(vllm_test::kH3Nvfp4TensorCount ==
+          static_cast<int64_t>(std::size(vllm_test::kH3Nvfp4Tensors)));
+
+  std::map<std::string, const vllm_test::H3Nvfp4Tensor*> by_name;
+  for (const vllm_test::H3Nvfp4Tensor& t : vllm_test::kH3Nvfp4Tensors) by_name[t.name] = &t;
+
+  // The compressed-tensors NVFP4 triple, exactly as our loader already expects:
+  //   weight         U8       packed FP4, 2 values per byte
+  //   weight_scale   F8_E4M3  one per group of 16 along K
+  //   weight_scale_2 F32      one global scale (scalar)
+  int64_t packed = 0, block_scales = 0, global_scales = 0;
+  for (const vllm_test::H3Nvfp4Tensor& t : vllm_test::kH3Nvfp4Tensors) {
+    const std::string name = t.name;
+    if (name.size() > 14 && name.compare(name.size() - 14, 14, "weight_scale_2") == 0) {
+      CHECK(std::string(t.dtype) == "F32");
+      CHECK(t.rank == 0);  // scalar
+      ++global_scales;
+    } else if (name.size() > 12 && name.compare(name.size() - 12, 12, "weight_scale") == 0) {
+      CHECK(std::string(t.dtype) == "F8_E4M3");
+      ++block_scales;
+    } else if (std::string(t.dtype) == "U8") {
+      ++packed;
+    }
+  }
+  // Every quantized projection carries all three, so the counts must agree.
+  CHECK(packed == block_scales);
+  CHECK(packed == global_scales);
+  CHECK(packed == 258);
+
+  // Spot-check the geometry on the fused qkv of block 0. Logical [21504, 5376]:
+  // 21504 = 3 * 56 * 128 output rows, 5376 = hidden.
+  const auto qkv = by_name.find("blocks.0.attn.qkv_proj.weight");
+  REQUIRE(qkv != by_name.end());
+  CHECK(std::string(qkv->second->dtype) == "U8");
+  CHECK(qkv->second->rank == 2);
+  CHECK(qkv->second->shape[0] == 21504);
+  CHECK(qkv->second->shape[1] == 2688);  // 5376 FP4 values packed 2-per-byte
+
+  const auto qkv_scale = by_name.find("blocks.0.attn.qkv_proj.weight_scale");
+  REQUIRE(qkv_scale != by_name.end());
+  CHECK(qkv_scale->second->shape[0] == 21504);
+  CHECK(qkv_scale->second->shape[1] == 336);  // 5376 / 16 -> NVFP4 group size 16
+  CHECK(qkv->second->shape[1] * 2 == qkv_scale->second->shape[1] * 16);
+
+  // The fp32/bf16 ISLANDS must stay unquantized here too: quantizing a patch
+  // projection, the time embedder, or an output head would break the dtype policy
+  // the DiT forward depends on.
+  for (const char* name : {"video_patch_proj.weight", "audio_patch_proj.weight",
+                           "time_embedder.proj_in.weight", "time_embedder.proj_out.weight",
+                           "final_layer.video_out.weight", "final_layer.audio_out.weight",
+                           "rope.inv_freq", "blocks.0.norm1.weight",
+                           "blocks.0.attn.q_norm.weight", "condition_proj.weight"}) {
+    const auto it = by_name.find(name);
+    INFO("unquantized island " << name);
+    REQUIRE(it != by_name.end());
+    CHECK(std::string(it->second->dtype) != "U8");
+  }
+
+  // The name map is again the IDENTITY: every non-quantization tensor in the real
+  // checkpoint is a name our contract already knows.
+  MiniMaxH3DitParams p;  // shipped geometry
+  const std::vector<vllm::MiniMaxH3TensorSpec> contract = EnumerateMiniMaxH3DitTensors(p);
+  std::map<std::string, std::vector<int64_t>> expected;
+  for (const vllm::MiniMaxH3TensorSpec& spec : contract) expected[spec.name] = spec.shape;
+  int64_t matched = 0;
+  for (const vllm_test::H3Nvfp4Tensor& t : vllm_test::kH3Nvfp4Tensors) {
+    const std::string name = t.name;
+    if (name.find("weight_scale") != std::string::npos) continue;  // quant sidecars
+    INFO("checkpoint tensor " << name);
+    CHECK(expected.count(name) == 1);
+    ++matched;
+  }
+  CHECK(matched == static_cast<int64_t>(contract.size()));
+}
+
+TEST_CASE("minimax_h3: the video VAE decoder block matches the checkpoint's own remote code") {
+  // The shipped decoder is 36 of these blocks, so this is the repeated unit of the
+  // half of the video VAE that generation actually needs. Gated against the
+  // checkpoint's OWN base_module.TransformerBlock, executed at reduced dimensions
+  // by scripts/gen-minimax-h3-video-vae-goldens.py.
+  vllm::MiniMaxH3VideoVaeBlockConfig config;
+  config.dim = vllm_test::kH3VideoVaeBlockDim;
+  config.heads = vllm_test::kH3VideoVaeBlockHeads;
+  config.dim_head = vllm_test::kH3VideoVaeBlockDimHead;
+  config.ff_inner = vllm_test::kH3VideoVaeBlockFfInner;
+  config.eps = 1e-5;
+
+  const int64_t seq = vllm_test::kH3VideoVaeBlockSeq;
+  const int64_t dim = config.dim;
+  const int64_t inner = config.heads * config.dim_head;
+
+  vllm::MiniMaxH3AudioVaeWeights weights;  // the same name-keyed parameter bag
+  auto put = [&](const std::string& suffix, int64_t count, double scale, double offset) {
+    weights.tensors["block." + suffix] = MakeParam("videovae." + suffix, count, scale, offset);
+  };
+  put("norm1.weight", dim, 0.1, 1.0);
+  put("norm2.weight", dim, 0.1, 1.0);
+  put("scale1", dim, 0.3, 0.0);
+  put("scale2", dim, 0.3, 0.0);
+  put("attn.to_qkv.weight", 3 * inner * dim, 0.1, 0.0);
+  put("attn.to_qkv.bias", 3 * inner, 0.05, 0.0);
+  put("attn.to_out.weight", dim * inner, 0.1, 0.0);
+  put("attn.to_out.bias", dim, 0.05, 0.0);
+  put("ff.w1.weight", 2 * config.ff_inner * dim, 0.1, 0.0);
+  put("ff.w1.bias", 2 * config.ff_inner, 0.05, 0.0);
+  put("ff.w2.weight", dim * config.ff_inner, 0.1, 0.0);
+  put("ff.w2.bias", dim, 0.05, 0.0);
+
+  const std::vector<float> hidden = MakeParam("videovae.input", seq * dim, 1.0);
+  const std::vector<float> got =
+      vllm::MiniMaxH3VideoVaeBlockForward(config, weights, "block", hidden, seq);
+
+  REQUIRE(got.size() == std::size(vllm_test::kH3VideoVaeBlockGolden));
+  const double err = MaxAbsDiff(got, vllm_test::kH3VideoVaeBlockGolden, got.size());
+  INFO("video VAE decoder block max|diff| = " << err);
+  CHECK(err <= 1e-5);
+}
+
+TEST_CASE("minimax_h3: the FULL video-VAE ViT3D decoder matches the checkpoint's remote code") {
+  // The whole generation-critical half of the video VAE: pack -> x_embedder ->
+  // register/cls tokens -> 3D RoPE -> block stack -> norm_out -> proj_out ->
+  // unpatchify. Gated against the checkpoint's OWN ViT3DDecoder.
+  vllm::MiniMaxH3VideoVaeDecoderConfig config;
+  config.block.dim = vllm_test::kH3VideoVaeBlockDim;
+  config.block.heads = vllm_test::kH3VideoVaeBlockHeads;
+  config.block.dim_head = vllm_test::kH3VideoVaeBlockDimHead;
+  config.block.ff_inner = vllm_test::kH3VideoVaeBlockFfInner;
+  config.block.eps = 1e-5;
+  config.num_layers = vllm_test::kH3VideoVaeDecLayers;
+  config.in_channels = vllm_test::kH3VideoVaeDecInCh;
+  config.out_channels = vllm_test::kH3VideoVaeDecOutCh;
+  config.patch_size = vllm_test::kH3VideoVaeDecPatch;
+  config.patch_size_t = vllm_test::kH3VideoVaeDecPatchT;
+  config.num_register_tokens = vllm_test::kH3VideoVaeDecRegisterTokens;
+  // rope_apply_dim = int(dim_head * rope_dim_ratio 0.75); must divide by 2*n_dim.
+  config.rope_apply_dim = static_cast<int64_t>(config.block.dim_head * 0.75);
+  config.rope_theta = 100.0;
+
+  const int64_t dim = config.block.dim;
+  const int64_t inner = config.block.heads * config.block.dim_head;
+  const int64_t lt = vllm_test::kH3VideoVaeDecT, lh = vllm_test::kH3VideoVaeDecH,
+                lw = vllm_test::kH3VideoVaeDecW;
+
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& name, int64_t count, double scale, double offset) {
+    weights.tensors[name] = MakeParam("videovae.dec." + name, count, scale, offset);
+  };
+  put("x_embedder.weight", dim * config.in_channels, 0.1, 0.0);
+  put("x_embedder.bias", dim, 0.05, 0.0);
+  put("register_tokens", config.num_register_tokens * dim, 0.1, 0.0);
+  put("norm_out.weight", dim, 0.1, 1.0);
+  put("norm_out.bias", dim, 0.05, 0.0);
+  const int64_t patch_dim =
+      config.out_channels * config.patch_size_t * config.patch_size * config.patch_size;
+  put("proj_out.weight", patch_dim * dim, 0.1, 0.0);
+  put("proj_out.bias", patch_dim, 0.05, 0.0);
+  for (int64_t l = 0; l < config.num_layers; ++l) {
+    const std::string b = "transformer_blocks." + std::to_string(l) + ".";
+    put(b + "norm1.weight", dim, 0.1, 1.0);
+    put(b + "norm2.weight", dim, 0.1, 1.0);
+    put(b + "scale1", dim, 0.3, 0.0);
+    put(b + "scale2", dim, 0.3, 0.0);
+    put(b + "attn.to_qkv.weight", 3 * inner * dim, 0.1, 0.0);
+    put(b + "attn.to_qkv.bias", 3 * inner, 0.05, 0.0);
+    put(b + "attn.to_out.weight", dim * inner, 0.1, 0.0);
+    put(b + "attn.to_out.bias", dim, 0.05, 0.0);
+    put(b + "ff.w1.weight", 2 * config.block.ff_inner * dim, 0.1, 0.0);
+    put(b + "ff.w1.bias", 2 * config.block.ff_inner, 0.05, 0.0);
+    put(b + "ff.w2.weight", dim * config.block.ff_inner, 0.1, 0.0);
+    put(b + "ff.w2.bias", dim, 0.05, 0.0);
+  }
+
+  const std::vector<float> latent =
+      MakeParam("videovae.dec.input", config.in_channels * lt * lh * lw, 1.0);
+  vllm::MiniMaxH3VideoFrameShape shape;
+  const std::vector<float> frames =
+      vllm::MiniMaxH3VideoVaeDecode(config, weights, latent, lt, lh, lw, &shape);
+
+  CHECK(shape.channels == config.out_channels);
+  CHECK(shape.t == vllm_test::kH3VideoVaeDecFrameT);
+  CHECK(shape.h == vllm_test::kH3VideoVaeDecFrameH);
+  CHECK(shape.w == vllm_test::kH3VideoVaeDecFrameW);
+  REQUIRE(frames.size() == std::size(vllm_test::kH3VideoVaeDecoderGolden));
+  const double err = MaxAbsDiff(frames, vllm_test::kH3VideoVaeDecoderGolden, frames.size());
+  INFO("video VAE ViT3D decoder max|diff| = " << err);
+  CHECK(err <= 1e-4);
+}
+
+// The DEVICE decoder is held to the SAME upstream golden as the portable one --
+// not to the portable one's output. Two independent implementations agreeing on a
+// wrong answer is a failure mode this project has already been bitten by, and
+// gating against the checkpoint's own remote code is what rules it out.
+//
+// This also covers the two load-time weight folds staging performs (the
+// per-head-interleaved to_qkv row permutation, and the per-channel scale fold into
+// the preceding projection). Both are silent-failure shaped: a wrong permutation
+// still produces plausible finite frames.
+static void CheckVideoVaeDecodeDevice(vt::Queue& queue, const char* label) {
+  vllm::MiniMaxH3VideoVaeDecoderConfig config;
+  config.block.dim = vllm_test::kH3VideoVaeBlockDim;
+  config.block.heads = vllm_test::kH3VideoVaeBlockHeads;
+  config.block.dim_head = vllm_test::kH3VideoVaeBlockDimHead;
+  config.block.ff_inner = vllm_test::kH3VideoVaeBlockFfInner;
+  config.block.eps = 1e-5;
+  config.num_layers = vllm_test::kH3VideoVaeDecLayers;
+  config.in_channels = vllm_test::kH3VideoVaeDecInCh;
+  config.out_channels = vllm_test::kH3VideoVaeDecOutCh;
+  config.patch_size = vllm_test::kH3VideoVaeDecPatch;
+  config.patch_size_t = vllm_test::kH3VideoVaeDecPatchT;
+  config.num_register_tokens = vllm_test::kH3VideoVaeDecRegisterTokens;
+  config.rope_apply_dim = static_cast<int64_t>(config.block.dim_head * 0.75);
+  config.rope_theta = 100.0;
+
+  const int64_t dim = config.block.dim;
+  const int64_t inner = config.block.heads * config.block.dim_head;
+  const int64_t lt = vllm_test::kH3VideoVaeDecT, lh = vllm_test::kH3VideoVaeDecH,
+                lw = vllm_test::kH3VideoVaeDecW;
+
+  // The SAME synthetic weights the portable gate above builds, so the only
+  // difference between the two runs is the implementation.
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& name, int64_t count, double scale, double offset) {
+    weights.tensors[name] = MakeParam("videovae.dec." + name, count, scale, offset);
+  };
+  put("x_embedder.weight", dim * config.in_channels, 0.1, 0.0);
+  put("x_embedder.bias", dim, 0.05, 0.0);
+  put("register_tokens", config.num_register_tokens * dim, 0.1, 0.0);
+  put("norm_out.weight", dim, 0.1, 1.0);
+  put("norm_out.bias", dim, 0.05, 0.0);
+  const int64_t patch_dim =
+      config.out_channels * config.patch_size_t * config.patch_size * config.patch_size;
+  put("proj_out.weight", patch_dim * dim, 0.1, 0.0);
+  put("proj_out.bias", patch_dim, 0.05, 0.0);
+  for (int64_t l = 0; l < config.num_layers; ++l) {
+    const std::string b = "transformer_blocks." + std::to_string(l) + ".";
+    put(b + "norm1.weight", dim, 0.1, 1.0);
+    put(b + "norm2.weight", dim, 0.1, 1.0);
+    put(b + "scale1", dim, 0.3, 0.0);
+    put(b + "scale2", dim, 0.3, 0.0);
+    put(b + "attn.to_qkv.weight", 3 * inner * dim, 0.1, 0.0);
+    put(b + "attn.to_qkv.bias", 3 * inner, 0.05, 0.0);
+    put(b + "attn.to_out.weight", dim * inner, 0.1, 0.0);
+    put(b + "attn.to_out.bias", dim, 0.05, 0.0);
+    put(b + "ff.w1.weight", 2 * config.block.ff_inner * dim, 0.1, 0.0);
+    put(b + "ff.w1.bias", 2 * config.block.ff_inner, 0.05, 0.0);
+    put(b + "ff.w2.weight", dim * config.block.ff_inner, 0.1, 0.0);
+    put(b + "ff.w2.bias", dim, 0.05, 0.0);
+  }
+
+  const std::vector<float> latent =
+      MakeParam("videovae.dec.input", config.in_channels * lt * lh * lw, 1.0);
+
+  const vllm::MiniMaxH3VideoVaeDeviceWeights staged =
+      vllm::StageMiniMaxH3VideoVaeWeights(queue, config, weights);
+  vllm::MiniMaxH3VideoFrameShape shape;
+  const std::vector<float> frames = vllm::MiniMaxH3VideoVaeDecodeDevice(
+      queue.device, config, staged, latent, lt, lh, lw, &shape);
+
+  CHECK(shape.channels == config.out_channels);
+  CHECK(shape.t == vllm_test::kH3VideoVaeDecFrameT);
+  CHECK(shape.h == vllm_test::kH3VideoVaeDecFrameH);
+  CHECK(shape.w == vllm_test::kH3VideoVaeDecFrameW);
+  REQUIRE(frames.size() == std::size(vllm_test::kH3VideoVaeDecoderGolden));
+  for (const float v : frames) REQUIRE(std::isfinite(v));
+  const double err = MaxAbsDiff(frames, vllm_test::kH3VideoVaeDecoderGolden, frames.size());
+  INFO("DEVICE video VAE ViT3D decoder (" << label << ") max|diff| = " << err);
+  CHECK(err <= 1e-4);
+}
+
+// Tiling is what the untiled decode got WRONG at real resolutions, and the reason
+// no earlier gate caught it: every reduced-dimension case here is smaller than one
+// tile, where tiled and untiled are the same computation. So this gates BOTH ends.
+//
+// The decisive evidence is empirical (512x512 -- 3 tiles per axis upstream --
+// decoded untiled came out covered in a grid of small squares, while 256x256, the
+// one size where tile_size >= input, came out clean). What is gated HERE is the
+// mechanism: that a single tile is still bit-identical, and that with several tiles
+// each tile's interior equals a direct decode of that tile's own latent slice --
+// which is what pins down the slicing, the placement and the seam arithmetic.
+// The TEMPORAL chunk arithmetic, against upstream's decode_temporal (klvae.py).
+// Pure integer geometry, so it pins the plan down without decoding anything --
+// and the plan is the part that was WRONG (we decoded the whole latent in one
+// pass where upstream never hands the ViT more than 7 temporal tokens).
+TEST_CASE("minimax_h3: the video-VAE temporal chunk plan matches upstream") {
+  vllm::MiniMaxH3VideoVaeDecoderConfig c;  // shipped defaults: 17 / 3 / 4
+  CHECK(c.clip_length == 17);
+  CHECK(c.token_drop == 3);
+  CHECK(c.vae_ratio_t == 4);
+  // tokens_chunk_size = ceil(17/4); frame_pre_padding = (-17) % 4;
+  // token_overlap = (-3) % 5; frame_overlap = max(2*4 - 3, 0).
+  CHECK(c.tokens_chunk_size() == 5);
+  CHECK(c.frame_pre_padding() == 3);
+  CHECK(c.token_overlap() == 2);
+  CHECK(c.frame_overlap() == 5);
+
+  // The modulo must be the PYTHON one: (-clip_length) % ratio is 3 in Python and
+  // -1 in C, and a negative pre-padding would slice from the wrong end.
+  CHECK(c.frame_pre_padding() >= 0);
+  CHECK(c.token_overlap() >= 0);
+
+  // For latent_t 12: pseudo = 12 + 3 = 15, a whole number of 5-token chunks, so
+  // num_chunks = 15/5 - 1 = 2, each covering tokens [0,7) and [5,12).
+  const int64_t latent_t = 12;
+  const int64_t pseudo = latent_t + c.token_drop;
+  CHECK(pseudo % c.tokens_chunk_size() == 0);
+  CHECK(pseudo / c.tokens_chunk_size() - 1 == 2);
+}
+
+TEST_CASE("minimax_h3: the TILED video-VAE decode slices and places tiles correctly") {
+  vt::Queue queue = vt::GetBackend(vt::DeviceType::kCPU).CreateQueue();
+
+  vllm::MiniMaxH3VideoVaeDecoderConfig config;
+  config.block.dim = vllm_test::kH3VideoVaeBlockDim;
+  config.block.heads = vllm_test::kH3VideoVaeBlockHeads;
+  config.block.dim_head = vllm_test::kH3VideoVaeBlockDimHead;
+  config.block.ff_inner = vllm_test::kH3VideoVaeBlockFfInner;
+  config.block.eps = 1e-5;
+  config.num_layers = vllm_test::kH3VideoVaeDecLayers;
+  config.in_channels = vllm_test::kH3VideoVaeDecInCh;
+  config.out_channels = vllm_test::kH3VideoVaeDecOutCh;
+  config.patch_size = vllm_test::kH3VideoVaeDecPatch;
+  config.patch_size_t = vllm_test::kH3VideoVaeDecPatchT;
+  config.num_register_tokens = vllm_test::kH3VideoVaeDecRegisterTokens;
+  config.rope_apply_dim = static_cast<int64_t>(config.block.dim_head * 0.75);
+  config.rope_theta = 100.0;
+
+  const int64_t dim = config.block.dim;
+  const int64_t inner = config.block.heads * config.block.dim_head;
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& name, int64_t count, double scale, double offset) {
+    weights.tensors[name] = MakeParam("videovae.dec." + name, count, scale, offset);
+  };
+  put("x_embedder.weight", dim * config.in_channels, 0.1, 0.0);
+  put("x_embedder.bias", dim, 0.05, 0.0);
+  put("register_tokens", config.num_register_tokens * dim, 0.1, 0.0);
+  put("norm_out.weight", dim, 0.1, 1.0);
+  put("norm_out.bias", dim, 0.05, 0.0);
+  const int64_t patch_dim =
+      config.out_channels * config.patch_size_t * config.patch_size * config.patch_size;
+  put("proj_out.weight", patch_dim * dim, 0.1, 0.0);
+  put("proj_out.bias", patch_dim, 0.05, 0.0);
+  for (int64_t l = 0; l < config.num_layers; ++l) {
+    const std::string b = "transformer_blocks." + std::to_string(l) + ".";
+    put(b + "norm1.weight", dim, 0.1, 1.0);
+    put(b + "norm2.weight", dim, 0.1, 1.0);
+    put(b + "scale1", dim, 0.3, 0.0);
+    put(b + "scale2", dim, 0.3, 0.0);
+    put(b + "attn.to_qkv.weight", 3 * inner * dim, 0.1, 0.0);
+    put(b + "attn.to_qkv.bias", 3 * inner, 0.05, 0.0);
+    put(b + "attn.to_out.weight", dim * inner, 0.1, 0.0);
+    put(b + "attn.to_out.bias", dim, 0.05, 0.0);
+    put(b + "ff.w1.weight", 2 * config.block.ff_inner * dim, 0.1, 0.0);
+    put(b + "ff.w1.bias", 2 * config.block.ff_inner, 0.05, 0.0);
+    put(b + "ff.w2.weight", dim * config.block.ff_inner, 0.1, 0.0);
+    put(b + "ff.w2.bias", dim, 0.05, 0.0);
+  }
+  const vllm::MiniMaxH3VideoVaeDeviceWeights staged =
+      vllm::StageMiniMaxH3VideoVaeWeights(queue, config, weights);
+
+  const int64_t ratio = vllm::kMiniMaxH3VaeRatio;
+  const int64_t ps = config.patch_size;
+  const int64_t lt = vllm_test::kH3VideoVaeDecT;
+
+  SUBCASE("a canvas within one tile is the untiled decode, bit for bit") {
+    const int64_t lh = 2, lw = 3;  // 32x48 canvas px -- far below tile_size 256
+    REQUIRE(vllm::MiniMaxH3SplitTiles(lh * ratio, vllm::kMiniMaxH3VaeTileSize,
+                                      vllm::kMiniMaxH3VaeTileOverlapMin, ratio)
+                .starts.size() == 1u);
+    const std::vector<float> latent =
+        MakeParam("videovae.tile.small", config.in_channels * lt * lh * lw, 1.0);
+    vllm::MiniMaxH3VideoFrameShape sa{}, sb{};
+    const std::vector<float> untiled =
+        vllm::MiniMaxH3VideoVaeDecodeDevice(queue.device, config, staged, latent, lt, lh, lw, &sa);
+    const std::vector<float> tiled = vllm::MiniMaxH3VideoVaeDecodeTiledDevice(
+        queue.device, config, staged, latent, lt, lh, lw, &sb);
+    REQUIRE(tiled.size() == untiled.size());
+    CHECK(sa.h == sb.h);
+    CHECK(sa.w == sb.w);
+    CHECK(MaxAbsDiff(tiled, untiled.data(), tiled.size()) == 0.0);
+  }
+
+  SUBCASE("a multi-tile canvas places each tile where the plan says") {
+    // 20 latent units = 320 canvas px > tile_size 256, so the plan is 2 tiles per
+    // axis (starts 0 and 64 px == latent 0 and 4, overlap 192 px == 12 latent).
+    const int64_t lh = 20, lw = 20;
+    const vllm::MiniMaxH3TilePlan plan = vllm::MiniMaxH3SplitTiles(
+        lh * ratio, vllm::kMiniMaxH3VaeTileSize, vllm::kMiniMaxH3VaeTileOverlapMin, ratio);
+    REQUIRE(plan.starts.size() == 2u);
+    const int64_t tile_lat = plan.lengths[0] / ratio;
+    const int64_t ov_lat = plan.overlaps[0] / ratio;
+
+    const std::vector<float> latent =
+        MakeParam("videovae.tile.big", config.in_channels * lt * lh * lw, 1.0);
+    vllm::MiniMaxH3VideoFrameShape shape{};
+    const std::vector<float> tiled = vllm::MiniMaxH3VideoVaeDecodeTiledDevice(
+        queue.device, config, staged, latent, lt, lh, lw, &shape);
+
+    CHECK(shape.channels == config.out_channels);
+    CHECK(shape.t == lt * config.patch_size_t);
+    CHECK(shape.h == lh * ps);
+    CHECK(shape.w == lw * ps);
+    REQUIRE(tiled.size() == static_cast<size_t>(shape.channels * shape.t * shape.h * shape.w));
+    for (const float v : tiled) REQUIRE(std::isfinite(v));
+
+    // Decode tile (0,0) on its own and require the assembled canvas to reproduce it
+    // EXACTLY outside the blend region. This is what a wrong slice or a wrong
+    // placement breaks -- and both still produce plausible finite frames.
+    std::vector<float> sub(static_cast<size_t>(config.in_channels * lt * tile_lat * tile_lat));
+    for (int64_t c = 0; c < config.in_channels; ++c) {
+      for (int64_t tt = 0; tt < lt; ++tt) {
+        for (int64_t y = 0; y < tile_lat; ++y) {
+          for (int64_t x = 0; x < tile_lat; ++x) {
+            sub[static_cast<size_t>(((c * lt + tt) * tile_lat + y) * tile_lat + x)] =
+                latent[static_cast<size_t>(((c * lt + tt) * lh + y) * lw + x)];
+          }
+        }
+      }
+    }
+    vllm::MiniMaxH3VideoFrameShape ts{};
+    const std::vector<float> tile0 = vllm::MiniMaxH3VideoVaeDecodeTiledDevice(
+        queue.device, config, staged, sub, lt, tile_lat, tile_lat, &ts);
+    REQUIRE(ts.h == tile_lat * ps);
+
+    // The un-blended interior: rows/cols before the first seam starts.
+    const int64_t keep = (tile_lat - ov_lat) * ps;
+    REQUIRE(keep > 0);
+    double worst = 0.0;
+    for (int64_t c = 0; c < shape.channels; ++c) {
+      for (int64_t tt = 0; tt < shape.t; ++tt) {
+        for (int64_t y = 0; y < keep; ++y) {
+          for (int64_t x = 0; x < keep; ++x) {
+            const double a = tiled[static_cast<size_t>(((c * shape.t + tt) * shape.h + y) *
+                                                           shape.w + x)];
+            const double b = tile0[static_cast<size_t>(((c * ts.t + tt) * ts.h + y) * ts.w + x)];
+            worst = std::max(worst, std::abs(a - b));
+          }
+        }
+      }
+    }
+    INFO("tile (0,0) interior vs a standalone decode, max|diff| = " << worst);
+    CHECK(worst == 0.0);
+  }
+}
+
+TEST_CASE("minimax_h3: the DEVICE video-VAE decoder matches the checkpoint's remote code") {
+  vt::Queue q = vt::GetBackend(vt::DeviceType::kCPU).CreateQueue();
+  CheckVideoVaeDecodeDevice(q, "cpu");
+}
+
+TEST_CASE("minimax_h3: the DEVICE video-VAE decoder matches the remote code on CUDA") {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(vt::DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  vt::Queue q = cuda->CreateQueue();
+  CheckVideoVaeDecodeDevice(q, "cuda");
+}
+
+TEST_CASE("minimax_h3: the video VAE decoder is a ViT, and its manifest says so") {
+  // W4 scoping, grounded in the real checkpoint rather than in a guess: the video
+  // VAE's ENCODER is the 3D CNN (down blocks with Conv3d), but its DECODER — the
+  // half we actually need for generation — is a plain transformer stack. That
+  // makes W4 materially smaller than "port a 48 KB klvae.py" suggested.
+  REQUIRE(vllm_test::kH3VideoVaeTensorCount ==
+          static_cast<int64_t>(std::size(vllm_test::kH3VideoVaeTensors)));
+
+  int64_t decoder = 0, encoder = 0, quant_conv = 0, max_block = -1;
+  bool saw_conv3d = false;
+  for (const vllm_test::H3VideoVaeTensor& t : vllm_test::kH3VideoVaeTensors) {
+    const std::string name = t.name;
+    CHECK(std::string(t.dtype) == "F32");  // the source checkpoint is fp32 throughout
+    if (name.rfind("decoder.", 0) == 0) ++decoder;
+    if (name.rfind("encoder.", 0) == 0) {
+      ++encoder;
+      if (t.rank == 5) saw_conv3d = true;  // [out, in, kt, kh, kw]
+    }
+    if (name.rfind("quant_conv", 0) == 0 || name.rfind("post_quant_conv", 0) == 0) ++quant_conv;
+    const std::string prefix = "decoder.transformer_blocks.";
+    if (name.rfind(prefix, 0) == 0) {
+      const size_t start = prefix.size();
+      size_t end = start;
+      while (end < name.size() && name[end] >= '0' && name[end] <= '9') ++end;
+      if (end > start) max_block = std::max<int64_t>(max_block, std::stoll(name.substr(start, end - start)));
+    }
+  }
+  CHECK(decoder == 440);
+  CHECK(encoder == 116);
+  CHECK(quant_conv == 4);
+  CHECK(saw_conv3d);          // the ENCODER is the 3D CNN
+  CHECK(max_block == 35);     // the DECODER is a 36-block transformer
+
+  // Each decoder block carries exactly the transformer parts we already have
+  // primitives for: fused qkv attention, a 2-matrix feed-forward, two norms, and
+  // two learned residual scales.
+  std::map<std::string, bool> present;
+  for (const vllm_test::H3VideoVaeTensor& t : vllm_test::kH3VideoVaeTensors) present[t.name] = true;
+  for (const char* suffix : {"attn.to_qkv.weight", "attn.to_qkv.bias", "attn.to_out.weight",
+                             "attn.to_out.bias", "ff.w1.weight", "ff.w2.weight",
+                             "norm1.weight", "norm2.weight", "scale1", "scale2"}) {
+    const std::string name = "decoder.transformer_blocks.0." + std::string(suffix);
+    INFO("decoder block part " << name);
+    CHECK(present.count(name) == 1);
+  }
+  // Plus the ViT surround: patch embed, learned mask/register tokens, output head.
+  for (const char* name : {"decoder.x_embedder.weight", "decoder.mask_token",
+                           "decoder.register_tokens", "decoder.norm_out.weight",
+                           "decoder.proj_out.weight", "post_quant_conv.weight"}) {
+    INFO("decoder surround " << name);
+    CHECK(present.count(name) == 1);
+  }
+}
+
+TEST_CASE("minimax_h3: the encoder text tower matches upstream, with all three H3 deltas") {
+  // The H3-Encoder produces the [seq, 5120] prompt_embeds the DiT consumes. Its
+  // ARCHITECTURE is a Qwen3-VL (which this project already ports); what is
+  // H3-specific are three deltas, and all three are exercised here:
+  //   layer truncation, the UNNORMALIZED output, and DeepStack injection.
+  vllm::MiniMaxH3EncoderConfig config;
+  config.hidden_size = vllm_test::kH3EncHidden;
+  config.num_hidden_layers = vllm_test::kH3EncConfigLayers;
+  config.selected_layer = vllm_test::kH3EncSelectedLayer;
+  config.num_attention_heads = vllm_test::kH3EncHeads;
+  config.num_key_value_heads = vllm_test::kH3EncKvHeads;
+  config.head_dim = vllm_test::kH3EncHeadDim;
+  config.intermediate_size = vllm_test::kH3EncIntermediate;
+  config.rms_norm_eps = 1e-6;
+  config.rope_theta = 10000.0;
+  config.mrope_section.assign(vllm_test::kH3EncMropeSection,
+                              vllm_test::kH3EncMropeSection + 3);
+
+  // DELTA 1: the config claims more layers than are kept.
+  CHECK(vllm::MiniMaxH3EncoderNumLayers(config.num_hidden_layers, config.selected_layer) ==
+        vllm_test::kH3EncSelectedLayer);
+  CHECK(vllm_test::kH3EncConfigLayers > vllm_test::kH3EncSelectedLayer);
+  // The shipped rule is 50-of-N.
+  CHECK(vllm::kMiniMaxH3EncoderSelectedLayer == 50);
+  CHECK(vllm::kMiniMaxH3EncoderHiddenDim == 5120);
+  // Truncation must never EXTEND a shallower model.
+  CHECK(vllm::MiniMaxH3EncoderNumLayers(8, 50) == 8);
+
+  const int64_t seq = vllm_test::kH3EncSeq;
+  const int64_t hidden = config.hidden_size;
+  const int64_t q_width = config.num_attention_heads * config.head_dim;
+  const int64_t kv_width = config.num_key_value_heads * config.head_dim;
+
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& name, int64_t count, double scale, double offset) {
+    weights.tensors[name] = MakeParam("encoder." + name, count, scale, offset);
+  };
+  put("embed_tokens.weight", vllm_test::kH3EncVocab * hidden, 0.1, 0.0);
+  for (int64_t l = 0; l < vllm_test::kH3EncSelectedLayer; ++l) {
+    const std::string p = "layers." + std::to_string(l) + ".";
+    put(p + "self_attn.qkv_proj.weight", (q_width + 2 * kv_width) * hidden, 0.1, 0.0);
+    put(p + "self_attn.o_proj.weight", hidden * q_width, 0.1, 0.0);
+    put(p + "self_attn.q_norm.weight", config.head_dim, 0.1, 1.0);
+    put(p + "self_attn.k_norm.weight", config.head_dim, 0.1, 1.0);
+    put(p + "mlp.gate_up_proj.weight", 2 * config.intermediate_size * hidden, 0.1, 0.0);
+    put(p + "mlp.down_proj.weight", hidden * config.intermediate_size, 0.1, 0.0);
+    put(p + "input_layernorm.weight", hidden, 0.1, 1.0);
+    put(p + "post_attention_layernorm.weight", hidden, 0.1, 1.0);
+  }
+
+  const std::vector<float> inputs_embeds =
+      MakeParam("encoder.inputs_embeds", seq * hidden, 1.0);
+  std::vector<int64_t> positions(static_cast<size_t>(3 * seq));
+  for (int64_t axis = 0; axis < 3; ++axis) {
+    for (int64_t s = 0; s < seq; ++s) positions[static_cast<size_t>(axis * seq + s)] = s;
+  }
+
+  // DELTAS 2 + 3: the plain path returns the UNNORMALIZED state; the DeepStack
+  // path additionally injects visual features into the first N layers.
+  const std::vector<float> plain = vllm::MiniMaxH3EncoderTextForward(
+      config, weights, inputs_embeds, positions.data(), seq, nullptr, {});
+  REQUIRE(plain.size() == std::size(vllm_test::kH3EncGolden));
+  const double plain_err = MaxAbsDiff(plain, vllm_test::kH3EncGolden, plain.size());
+  INFO("encoder (plain) max|diff| = " << plain_err);
+  CHECK(plain_err <= 1e-4);
+
+  std::vector<uint8_t> visual_mask(static_cast<size_t>(seq));
+  for (int64_t s = 0; s < seq; ++s) {
+    visual_mask[static_cast<size_t>(s)] =
+        static_cast<uint8_t>(vllm_test::kH3EncVisualMask[s]);
+  }
+  std::vector<std::vector<float>> deepstack;
+  for (int64_t i = 0; i < vllm_test::kH3EncDeepstackLayers; ++i) {
+    deepstack.push_back(MakeParam("encoder.deepstack." + std::to_string(i),
+                                  vllm_test::kH3EncNumVisual * hidden, 0.1, 0.0));
+  }
+  const std::vector<float> injected = vllm::MiniMaxH3EncoderTextForward(
+      config, weights, inputs_embeds, positions.data(), seq, visual_mask.data(), deepstack);
+  REQUIRE(injected.size() == std::size(vllm_test::kH3EncDeepstackGolden));
+  const double deep_err =
+      MaxAbsDiff(injected, vllm_test::kH3EncDeepstackGolden, injected.size());
+  INFO("encoder (deepstack) max|diff| = " << deep_err);
+  CHECK(deep_err <= 1e-4);
+
+  // DeepStack must actually change the result, or the test proves nothing.
+  double delta = 0.0;
+  for (size_t i = 0; i < plain.size(); ++i) {
+    delta = std::max(delta, std::abs(static_cast<double>(plain[i]) - injected[i]));
+  }
+  CHECK(delta > 1e-5);
+}
+
+// fl2va CONDITIONING, end to end through the pipeline. Everything below was
+// already ported and gated in PIECES -- the packed keyframe layout, the VAE 3D-CNN
+// encoder, condition-noise augmentation, the denoise loop's pinned condition rows.
+// What did not exist was any path from "caller has an image" to "the DiT is
+// conditioned on it", so the whole feature was unreachable.
+//
+// The load-bearing assertion is that conditioning CHANGES THE RESULT. A wiring
+// that accepted the rows and ignored them would produce perfectly finite,
+// correctly shaped output and pass every structural check.
+// The video VAE works in IMAGENET-NORMALIZED pixel space, and the conversions sit
+// OUTSIDE ViT3DDecoder -- so the decoder's own 1.19e-07 gate never covered them,
+// exactly like post_quant_conv before it. Omitting the output step feeds
+// ImageNet-normalized values to a writer that expects [-1, 1]: it casts colour (the
+// per-channel means differ) and compresses the dynamic range ~4.4x (std ~0.22),
+// which is what "dark and washed out" looks like.
+TEST_CASE("minimax_h3: ImageNet pixel de/normalization matches upstream's wrapper") {
+  const int64_t n = 5;
+  // Round trip: normalize then de-normalize must return the original, for values
+  // that stay inside the [0,1] clamp.
+  std::vector<float> pixels;
+  for (int64_t c = 0; c < 3; ++c) {
+    for (int64_t i = 0; i < n; ++i) pixels.push_back(-0.6f + 0.3f * static_cast<float>(i));
+  }
+  std::vector<float> round = pixels;
+  vllm::MiniMaxH3VideoNormalizePixels(round, 3, n);
+  vllm::MiniMaxH3VideoDenormalizePixels(round, 3, n);
+  CHECK(MaxAbsDiff(round, pixels.data(), pixels.size()) <= 1e-5);
+
+  // Exact values against upstream's formula (vae.py:659,693), per channel -- a
+  // shared mean/std would round-trip fine yet still cast colour.
+  const float mean[3] = {0.485f, 0.456f, 0.406f};
+  const float sd[3] = {0.229f, 0.224f, 0.225f};
+  std::vector<float> one(3, 0.0f);  // one value per channel, ImageNet-normalized 0
+  vllm::MiniMaxH3VideoDenormalizePixels(one, 3, 1);
+  for (int64_t c = 0; c < 3; ++c) {
+    CHECK(one[static_cast<size_t>(c)] == doctest::Approx(mean[c] * 2.0f - 1.0f).epsilon(1e-5));
+  }
+
+  // The clamp happens BEFORE the [-1,1] map (vae.py:693 order): a far
+  // out-of-gamut value must saturate at exactly +/-1, not overshoot.
+  std::vector<float> hot = {50.0f, -50.0f, 50.0f};
+  vllm::MiniMaxH3VideoDenormalizePixels(hot, 3, 1);
+  CHECK(hot[0] == doctest::Approx(1.0f));
+  CHECK(hot[1] == doctest::Approx(-1.0f));
+  CHECK(hot[2] == doctest::Approx(1.0f));
+
+  // And the per-channel std is really applied: an ImageNet-normalized 1.0 must
+  // land at a DIFFERENT pixel per channel.
+  std::vector<float> unit = {1.0f, 1.0f, 1.0f};
+  vllm::MiniMaxH3VideoDenormalizePixels(unit, 3, 1);
+  for (int64_t c = 0; c < 3; ++c) {
+    CHECK(unit[static_cast<size_t>(c)] ==
+          doctest::Approx((mean[c] + sd[c]) * 2.0f - 1.0f).epsilon(1e-5));
+  }
+  CHECK(unit[0] != doctest::Approx(unit[1]));
+}
+
+TEST_CASE("minimax_h3: fl2va keyframe conditioning is wired and load-bearing") {
+  const std::unique_ptr<GoldenWeights> dit = BuildGoldenWeights();
+  const MiniMaxH3DitParams& p = dit->params;
+
+  // A reduced 3D-CNN encoder: one level, tiny channels. Real geometry is irrelevant
+  // here -- what matters is that a real encode feeds real rows into the loop.
+  vllm::MiniMaxH3EncoderFcn3dConfig ecfg;
+  ecfg.ch = 8;
+  ecfg.ch_mult = {1};
+  ecfg.space_down = {1};
+  ecfg.time_down = {1};
+  ecfg.num_res_blocks = 1;
+  ecfg.in_channels = 3;
+  ecfg.z_channels = 2 * p.latents_dim;  // moments width: mean | logvar
+  ecfg.num_groups = 4;
+
+  const int64_t IH = 8, IW = 8;
+  vllm::MiniMaxH3AudioVaeWeights ew;
+  auto put = [&](const std::string& n, int64_t c, double s, double o) {
+    ew.tensors[n] = MakeParam("fl2va.enc." + n, c, s, o);
+  };
+  put("conv_in.weight", ecfg.ch * ecfg.in_channels * 27, 0.05, 0.0);
+  put("conv_in.bias", ecfg.ch, 0.01, 0.0);
+  for (int64_t b = 0; b < ecfg.num_res_blocks; ++b) {
+    const std::string pre = "down.0.block." + std::to_string(b) + ".";
+    put(pre + "norm1.weight", ecfg.ch, 0.1, 1.0);
+    put(pre + "norm1.bias", ecfg.ch, 0.05, 0.0);
+    put(pre + "conv1.weight", ecfg.ch * ecfg.ch * 27, 0.05, 0.0);
+    put(pre + "conv1.bias", ecfg.ch, 0.01, 0.0);
+    put(pre + "norm2.weight", ecfg.ch, 0.1, 1.0);
+    put(pre + "norm2.bias", ecfg.ch, 0.05, 0.0);
+    put(pre + "conv2.weight", ecfg.ch * ecfg.ch * 27, 0.05, 0.0);
+    put(pre + "conv2.bias", ecfg.ch, 0.01, 0.0);
+  }
+  put("norm_out.weight", ecfg.ch, 0.1, 1.0);
+  put("norm_out.bias", ecfg.ch, 0.05, 0.0);
+  put("conv_out.weight", ecfg.z_channels * ecfg.ch * 27, 0.05, 0.0);
+  put("conv_out.bias", ecfg.z_channels, 0.01, 0.0);
+  put("quant_conv.weight", ecfg.z_channels * ecfg.z_channels, 0.05, 0.0);
+  put("quant_conv.bias", ecfg.z_channels, 0.01, 0.0);
+
+  const std::vector<float> image = MakeParam("fl2va.image", ecfg.in_channels * IH * IW, 1.0);
+
+  SUBCASE("the encoder yields a deterministic latent (the MEAN, not a sample)") {
+    vllm::MiniMaxH3VideoFrameShape ls{}, ls2{};
+    vllm::MiniMaxH3EncoderFcn3dConfig c = ecfg;
+    c.t = 1; c.h = IH; c.w = IW;
+    const std::vector<float> a1 = vllm::MiniMaxH3VideoVaeEncodeToLatent(c, ew, image, &ls);
+    const std::vector<float> a2 = vllm::MiniMaxH3VideoVaeEncodeToLatent(c, ew, image, &ls2);
+    REQUIRE(!a1.empty());
+    CHECK(ls.t == ls2.t);
+    // z_channels out, not 2*z: the logvar half must be dropped.
+    CHECK(static_cast<int64_t>(a1.size()) == (ecfg.z_channels / 2) * ls.t * ls.h * ls.w);
+    CHECK(MaxAbsDiff(a1, a2.data(), a1.size()) == 0.0);
+    for (const float v : a1) REQUIRE(std::isfinite(v));
+  }
+
+  SUBCASE("ref2va IMAGE references are wired, and audio references are REFUSED") {
+    vllm::MiniMaxH3T2vaRequest req;
+    req.text_len = 4;
+    req.latent_t = 2;
+    req.latent_h = 4;
+    req.latent_w = 4;
+    req.audio_t = 4;
+    req.audio_channel = 2;
+    req.num_steps = 3;
+
+    std::vector<vllm::MiniMaxH3RefBlock> blocks;
+    const std::vector<float> ref_rows = vllm::MiniMaxH3EncodeReferenceImages(
+        ecfg, ew, p, {image}, IH, IW, &blocks);
+    REQUIRE(blocks.size() == 1);
+    CHECK(blocks[0].kind == vllm::MiniMaxH3RefBlock::Kind::kImage);
+    CHECK(blocks[0].latent_t >= 1);
+    REQUIRE(!ref_rows.empty());
+
+    const int64_t frame_rows = (req.latent_h / p.patch_size_h) * (req.latent_w / p.patch_size_w);
+    const std::vector<float> prompt = MakeParam("ref2va.prompt", req.text_len * p.text_dim, 0.2);
+    const std::vector<float> nv =
+        MakeParam("ref2va.nv", req.latent_t * frame_rows * p.video_row_width(), 0.3);
+    const std::vector<float> na =
+        MakeParam("ref2va.na", req.audio_t * req.audio_channel * p.audio_latents_dim, 0.3);
+
+    const vllm::MiniMaxH3DenoiseResult plain = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, req, p, dit->views, prompt, nv, na, vt::DType::kF32);
+
+    vllm::MiniMaxH3T2vaRequest r2 = req;
+    r2.ref_blocks = blocks;
+    r2.keyframe_cond_rows = ref_rows;  // the same pinned-condition mechanism
+    const vllm::MiniMaxH3DenoiseResult withref = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, r2, p, dit->views, prompt, nv, na, vt::DType::kF32);
+    for (const float v : withref.video_rows) REQUIRE(std::isfinite(v));
+
+    const size_t n = std::min(plain.video_rows.size(), withref.video_rows.size());
+    REQUIRE(n > 0);
+    double delta = 0.0;
+    for (size_t i = 0; i < n; ++i) {
+      delta = std::max(delta,
+                       std::abs(static_cast<double>(plain.video_rows[i]) - withref.video_rows[i]));
+    }
+    INFO("ref2va image reference moved the video rows by " << delta);
+    CHECK(delta > 1e-5);
+
+    // An audio-bearing block that supplies NO rows must still be refused: the
+    // layout would grow around packed rows nothing ever wrote, and the loop would
+    // pin whatever happened to be in the buffer.
+    vllm::MiniMaxH3T2vaRequest bad = req;
+    vllm::MiniMaxH3RefBlock ab;
+    ab.kind = vllm::MiniMaxH3RefBlock::Kind::kAudio;
+    ab.ref_audio_t = 2;
+    bad.ref_blocks = {ab};
+    CHECK_THROWS(vllm::MiniMaxH3DenoiseT2va(vt::Device{}, bad, p, dit->views, prompt, nv, na,
+                                            vt::DType::kF32));
+    // ... and so must one that supplies the WRONG number of rows.
+    bad.audio_ref_rows = MakeParam("ref2va.short", (ab.ref_audio_t * req.audio_channel - 1) *
+                                                       p.audio_latents_dim, 0.3);
+    CHECK_THROWS(vllm::MiniMaxH3DenoiseT2va(vt::Device{}, bad, p, dit->views, prompt, nv, na,
+                                            vt::DType::kF32));
+
+    // fl2va and ref2va are mutually exclusive and must say so.
+    vllm::MiniMaxH3T2vaRequest both = req;
+    both.ref_blocks = blocks;
+    both.keyframe_frame_indices = {0};
+    CHECK_THROWS(vllm::MiniMaxH3DenoiseT2va(vt::Device{}, both, p, dit->views, prompt, nv, na,
+                                            vt::DType::kF32));
+  }
+
+  SUBCASE("ref2va VIDEO references carry a temporal extent, and stay silent") {
+    const int64_t FT = 3;  // a 3-frame reference clip
+    const std::vector<float> clip =
+        MakeParam("ref2va.clip", ecfg.in_channels * FT * IH * IW, 1.0);
+    vllm::MiniMaxH3RefBlock vb{};
+    const std::vector<float> vrows = vllm::MiniMaxH3EncodeReferenceVideo(
+        ecfg, ew, p, clip, FT, IH, IW, &vb);
+    REQUIRE(!vrows.empty());
+    CHECK(vb.kind == vllm::MiniMaxH3RefBlock::Kind::kVideoAudio);
+    // ref_audio_t 0 is what keeps it honest: no audio rows are claimed, because
+    // the audio-VAE encoder that would produce them is not ported.
+    CHECK(vb.ref_audio_t == 0);
+    CHECK(vb.latent_t >= 1);
+
+    // A video reference must occupy MORE rows than a single image one: kImage
+    // counts exactly one frame however large its latent_t, so a clip that came
+    // back as kImage would silently lose its temporal extent.
+    std::vector<vllm::MiniMaxH3RefBlock> iblocks;
+    const std::vector<float> irows =
+        vllm::MiniMaxH3EncodeReferenceImages(ecfg, ew, p, {image}, IH, IW, &iblocks);
+    REQUIRE(iblocks.size() == 1);
+    CHECK(vrows.size() > irows.size());
+
+    vllm::MiniMaxH3T2vaRequest req;
+    req.text_len = 4;
+    req.latent_t = 2;
+    req.latent_h = 4;
+    req.latent_w = 4;
+    req.audio_t = 4;
+    req.audio_channel = 2;
+    req.num_steps = 3;
+    const int64_t frame_rows = (req.latent_h / p.patch_size_h) * (req.latent_w / p.patch_size_w);
+    const std::vector<float> prompt = MakeParam("refvid.prompt", req.text_len * p.text_dim, 0.2);
+    const std::vector<float> nv =
+        MakeParam("refvid.nv", req.latent_t * frame_rows * p.video_row_width(), 0.3);
+    const std::vector<float> na =
+        MakeParam("refvid.na", req.audio_t * req.audio_channel * p.audio_latents_dim, 0.3);
+
+    const vllm::MiniMaxH3DenoiseResult plain = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, req, p, dit->views, prompt, nv, na, vt::DType::kF32);
+
+    vllm::MiniMaxH3T2vaRequest rv = req;
+    rv.ref_blocks = {vb};
+    rv.keyframe_cond_rows = vrows;
+    const vllm::MiniMaxH3DenoiseResult withvid = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, rv, p, dit->views, prompt, nv, na, vt::DType::kF32);
+    for (const float v : withvid.video_rows) REQUIRE(std::isfinite(v));
+    const size_t n = std::min(plain.video_rows.size(), withvid.video_rows.size());
+    REQUIRE(n > 0);
+    double delta = 0.0;
+    for (size_t i = 0; i < n; ++i) {
+      delta = std::max(delta,
+                       std::abs(static_cast<double>(plain.video_rows[i]) - withvid.video_rows[i]));
+    }
+    INFO("ref2va video reference moved the video rows by " << delta);
+    CHECK(delta > 1e-5);
+
+    // A video reference WITH audio but WITHOUT the encoded audio rows must be
+    // refused: its audio slots would otherwise be pinned to nothing.
+    vllm::MiniMaxH3T2vaRequest bad = req;
+    vllm::MiniMaxH3RefBlock loud = vb;
+    loud.ref_audio_t = 2;
+    bad.ref_blocks = {loud};
+    bad.keyframe_cond_rows = vrows;
+    CHECK_THROWS(vllm::MiniMaxH3DenoiseT2va(vt::Device{}, bad, p, dit->views, prompt, nv, na,
+                                            vt::DType::kF32));
+  }
+
+  SUBCASE("keyframe rows reach the denoise loop and CHANGE the result") {
+    vllm::MiniMaxH3T2vaRequest req;
+    req.text_len = 4;
+    req.latent_t = 2;
+    req.latent_h = 4;
+    req.latent_w = 4;
+    req.audio_t = 4;
+    req.audio_channel = 2;
+    req.num_frames = 5;
+    req.num_steps = 3;
+
+    const int64_t frame_rows = (req.latent_h / p.patch_size_h) * (req.latent_w / p.patch_size_w);
+    const std::vector<float> prompt =
+        MakeParam("fl2va.prompt", req.text_len * p.text_dim, 0.2);
+    const std::vector<float> nv =
+        MakeParam("fl2va.nv", req.latent_t * frame_rows * p.video_row_width(), 0.3);
+    const std::vector<float> na =
+        MakeParam("fl2va.na", req.audio_t * req.audio_channel * p.audio_latents_dim, 0.3);
+
+    const vllm::MiniMaxH3DenoiseResult plain = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, req, p, dit->views, prompt, nv, na, vt::DType::kF32);
+
+    vllm::MiniMaxH3T2vaRequest cond = req;
+    cond.keyframe_frame_indices = {0};
+    cond.keyframe_cond_rows = vllm::MiniMaxH3EncodeKeyframeCondRows(
+        ecfg, ew, p, {image}, IH, IW, req.latent_t, /*noise_aug=*/1.0, {});
+    REQUIRE(!cond.keyframe_cond_rows.empty());
+
+    // The layout itself must differ: a keyframe adds condition rows.
+    const vllm::MiniMaxH3PackedSequence pk_plain = vllm::BuildMiniMaxH3PackedSequence(
+        req.text_len, req.latent_t, req.latent_h, req.latent_w, req.audio_t, req.audio_channel,
+        false, {}, 0);
+    const vllm::MiniMaxH3PackedSequence pk_cond = vllm::BuildMiniMaxH3PackedSequence(
+        req.text_len, req.latent_t, req.latent_h, req.latent_w, req.audio_t, req.audio_channel,
+        true, {0}, req.num_frames);
+    CHECK(pk_cond.img_pos.size() > pk_plain.img_pos.size());
+
+    const vllm::MiniMaxH3DenoiseResult conditioned = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, cond, p, dit->views, prompt, nv, na, vt::DType::kF32);
+
+    for (const float v : conditioned.video_rows) REQUIRE(std::isfinite(v));
+    REQUIRE(!conditioned.video_rows.empty());
+
+    // THE assertion: identical prompt, identical noise, identical schedule -- the
+    // only difference is the keyframe, so the video MUST move. Ignoring the rows
+    // would still produce finite, correctly shaped output.
+    const size_t n = std::min(plain.video_rows.size(), conditioned.video_rows.size());
+    REQUIRE(n > 0);
+    double delta = 0.0;
+    for (size_t i = 0; i < n; ++i) {
+      delta = std::max(delta, std::abs(static_cast<double>(plain.video_rows[i]) -
+                                       conditioned.video_rows[i]));
+    }
+    INFO("keyframe conditioning moved the video rows by " << delta);
+    CHECK(delta > 1e-5);
+  }
+
+  // --- the AUDIO half of ref2va. A reduced audio VAE encoder whose latent width
+  // is the DiT's own audio row width, so the rows it emits ARE packed rows.
+  vllm::MiniMaxH3AudioVaeEncoderConfig acfg;
+  acfg.encoder_dim = 4;
+  acfg.encoder_rates = {2, 2};
+  acfg.latent_dim = 16;
+  acfg.vae_latent_channels = p.audio_latents_dim;
+  acfg.attn_proj = true;
+  acfg.attn_proj_heads = 2;
+  const vllm::MiniMaxH3AudioVaeWeights aw = BuildAudioEncoderWeights(acfg, "ref2va.aud.");
+  const int64_t kRefSamples = 24;  // 24 / hop 4 -> 6 latent frames
+
+  SUBCASE("ref2va AUDIO references are wired, and CHANGE the result") {
+    vllm::MiniMaxH3T2vaRequest req;
+    req.text_len = 4;
+    req.latent_t = 2;
+    req.latent_h = 4;
+    req.latent_w = 4;
+    req.audio_t = 4;
+    req.audio_channel = 2;
+    req.num_steps = 3;
+
+    // A stereo reference waveform, encoded by the audio VAE's ENCODER half.
+    const std::vector<float> stereo =
+        MakeParam("ref2va.wave", req.audio_channel * kRefSamples, 0.9);
+    vllm::MiniMaxH3RefBlock ab{};
+    const std::vector<float> arows = vllm::MiniMaxH3EncodeReferenceAudio(
+        acfg, aw, stereo, req.audio_channel, kRefSamples, {}, {}, /*noise_aug=*/1.0, {}, &ab);
+    CHECK(ab.kind == vllm::MiniMaxH3RefBlock::Kind::kAudio);
+    CHECK(ab.ref_audio_t == kRefSamples / acfg.hop_length());
+    REQUIRE(arows.size() ==
+            static_cast<size_t>(ab.ref_audio_t * req.audio_channel * p.audio_latents_dim));
+    for (const float v : arows) REQUIRE(std::isfinite(v));
+
+    // The layout must GROW by exactly the rows the block claims -- an audio
+    // reference occupies packed audio positions, it does not overwrite targets.
+    const vllm::MiniMaxH3PackedSequence pk_plain = vllm::BuildMiniMaxH3PackedSequence(
+        req.text_len, req.latent_t, req.latent_h, req.latent_w, req.audio_t, req.audio_channel,
+        false, {}, 0);
+    const vllm::MiniMaxH3PackedSequence pk_ref = vllm::BuildMiniMaxH3PackedSequenceRef2va(
+        req.text_len, req.latent_t, req.latent_h, req.latent_w, req.audio_t, {ab},
+        req.audio_channel);
+    CHECK(static_cast<int64_t>(pk_ref.audio_pos.size()) ==
+          static_cast<int64_t>(pk_plain.audio_pos.size()) + ab.ref_audio_t * req.audio_channel);
+
+    const int64_t frame_rows = (req.latent_h / p.patch_size_h) * (req.latent_w / p.patch_size_w);
+    const std::vector<float> prompt = MakeParam("ref2aud.prompt", req.text_len * p.text_dim, 0.2);
+    const std::vector<float> nv =
+        MakeParam("ref2aud.nv", req.latent_t * frame_rows * p.video_row_width(), 0.3);
+    const std::vector<float> na =
+        MakeParam("ref2aud.na", req.audio_t * req.audio_channel * p.audio_latents_dim, 0.3);
+
+    const vllm::MiniMaxH3DenoiseResult plain = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, req, p, dit->views, prompt, nv, na, vt::DType::kF32);
+
+    vllm::MiniMaxH3T2vaRequest ra = req;
+    ra.ref_blocks = {ab};
+    ra.audio_ref_rows = arows;
+    const vllm::MiniMaxH3DenoiseResult withaudio = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, ra, p, dit->views, prompt, nv, na, vt::DType::kF32);
+    for (const float v : withaudio.audio_rows) REQUIRE(std::isfinite(v));
+    for (const float v : withaudio.video_rows) REQUIRE(std::isfinite(v));
+
+    // THE assertion, the audio-side twin of the keyframe one: identical prompt,
+    // identical noise, identical schedule -- the only difference is the reference
+    // audio, so BOTH streams must move. Wiring that accepts the rows and ignores
+    // them would still produce finite, correctly shaped output.
+    const size_t na_n = std::min(plain.audio_rows.size(), withaudio.audio_rows.size());
+    REQUIRE(na_n > 0);
+    double audio_delta = 0.0;
+    for (size_t i = 0; i < na_n; ++i) {
+      audio_delta = std::max(audio_delta, std::abs(static_cast<double>(plain.audio_rows[i]) -
+                                                   withaudio.audio_rows[i]));
+    }
+    INFO("ref2va audio reference moved the audio rows by " << audio_delta);
+    CHECK(audio_delta > 1e-5);
+
+    const size_t nv_n = std::min(plain.video_rows.size(), withaudio.video_rows.size());
+    REQUIRE(nv_n > 0);
+    double video_delta = 0.0;
+    for (size_t i = 0; i < nv_n; ++i) {
+      video_delta = std::max(video_delta, std::abs(static_cast<double>(plain.video_rows[i]) -
+                                                   withaudio.video_rows[i]));
+    }
+    INFO("ref2va audio reference moved the VIDEO rows by " << video_delta);
+    CHECK(video_delta > 1e-5);
+
+    // And the reference itself is LOAD-BEARING, not merely present: a DIFFERENT
+    // waveform must give a different result. Wiring that reserved the rows and
+    // then pinned a constant would pass every check above and fail this one.
+    const std::vector<float> other =
+        MakeParam("ref2va.wave.other", req.audio_channel * kRefSamples, 0.9);
+    vllm::MiniMaxH3RefBlock ob{};
+    vllm::MiniMaxH3T2vaRequest rb = ra;
+    rb.audio_ref_rows = vllm::MiniMaxH3EncodeReferenceAudio(
+        acfg, aw, other, req.audio_channel, kRefSamples, {}, {}, /*noise_aug=*/1.0, {}, &ob);
+    CHECK(ob.ref_audio_t == ab.ref_audio_t);
+    const vllm::MiniMaxH3DenoiseResult otheraudio = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, rb, p, dit->views, prompt, nv, na, vt::DType::kF32);
+    double which_delta = 0.0;
+    for (size_t i = 0; i < na_n; ++i) {
+      which_delta = std::max(which_delta, std::abs(static_cast<double>(withaudio.audio_rows[i]) -
+                                                  otheraudio.audio_rows[i]));
+    }
+    INFO("a DIFFERENT reference waveform moved the audio rows by " << which_delta);
+    CHECK(which_delta > 1e-5);
+  }
+
+  SUBCASE("ref2va VIDEO+AUDIO references carry both, and both are load-bearing") {
+    const int64_t FT = 3;
+    const std::vector<float> clip =
+        MakeParam("ref2va.avclip", ecfg.in_channels * FT * IH * IW, 1.0);
+    vllm::MiniMaxH3RefBlock vb{};
+    const std::vector<float> vrows =
+        vllm::MiniMaxH3EncodeReferenceVideo(ecfg, ew, p, clip, FT, IH, IW, &vb);
+    REQUIRE(!vrows.empty());
+    CHECK(vb.ref_audio_t == 0);  // silent until an encoded waveform says otherwise
+
+    vllm::MiniMaxH3T2vaRequest req;
+    req.text_len = 4;
+    req.latent_t = 2;
+    req.latent_h = 4;
+    req.latent_w = 4;
+    req.audio_t = 4;
+    req.audio_channel = 2;
+    req.num_steps = 3;
+
+    const std::vector<float> stereo =
+        MakeParam("ref2va.avwave", req.audio_channel * kRefSamples, 0.9);
+    vllm::MiniMaxH3RefBlock ab{};
+    const std::vector<float> arows = vllm::MiniMaxH3EncodeReferenceAudio(
+        acfg, aw, stereo, req.audio_channel, kRefSamples, {}, {}, /*noise_aug=*/1.0, {}, &ab);
+    // ONE block carrying both: the clip's geometry plus the waveform's extent.
+    vllm::MiniMaxH3RefBlock av = vb;
+    av.ref_audio_t = ab.ref_audio_t;
+    CHECK(av.kind == vllm::MiniMaxH3RefBlock::Kind::kVideoAudio);
+    CHECK(av.ref_audio_t > 0);
+
+    const int64_t frame_rows = (req.latent_h / p.patch_size_h) * (req.latent_w / p.patch_size_w);
+    const std::vector<float> prompt = MakeParam("ref2av.prompt", req.text_len * p.text_dim, 0.2);
+    const std::vector<float> nv =
+        MakeParam("ref2av.nv", req.latent_t * frame_rows * p.video_row_width(), 0.3);
+    const std::vector<float> na =
+        MakeParam("ref2av.na", req.audio_t * req.audio_channel * p.audio_latents_dim, 0.3);
+
+    // The SILENT same-clip reference is the control: the only difference is sound.
+    vllm::MiniMaxH3T2vaRequest silent = req;
+    silent.ref_blocks = {vb};
+    silent.keyframe_cond_rows = vrows;
+    const vllm::MiniMaxH3DenoiseResult quiet = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, silent, p, dit->views, prompt, nv, na, vt::DType::kF32);
+
+    vllm::MiniMaxH3T2vaRequest loud = req;
+    loud.ref_blocks = {av};
+    loud.keyframe_cond_rows = vrows;
+    loud.audio_ref_rows = arows;
+    const vllm::MiniMaxH3DenoiseResult sounded = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, loud, p, dit->views, prompt, nv, na, vt::DType::kF32);
+    for (const float v : sounded.audio_rows) REQUIRE(std::isfinite(v));
+    for (const float v : sounded.video_rows) REQUIRE(std::isfinite(v));
+
+    const size_t na_n = std::min(quiet.audio_rows.size(), sounded.audio_rows.size());
+    REQUIRE(na_n > 0);
+    double audio_delta = 0.0;
+    for (size_t i = 0; i < na_n; ++i) {
+      audio_delta = std::max(audio_delta, std::abs(static_cast<double>(quiet.audio_rows[i]) -
+                                                  sounded.audio_rows[i]));
+    }
+    INFO("ref2va video+audio moved the audio rows by " << audio_delta);
+    CHECK(audio_delta > 1e-5);
+
+    const size_t nv_n = std::min(quiet.video_rows.size(), sounded.video_rows.size());
+    REQUIRE(nv_n > 0);
+    double video_delta = 0.0;
+    for (size_t i = 0; i < nv_n; ++i) {
+      video_delta = std::max(video_delta, std::abs(static_cast<double>(quiet.video_rows[i]) -
+                                                  sounded.video_rows[i]));
+    }
+    INFO("ref2va video+audio moved the VIDEO rows by " << video_delta);
+    CHECK(video_delta > 1e-5);
+
+    // The VISUAL half must still be load-bearing once audio joins it: encode a
+    // different clip and the result must move again.
+    const std::vector<float> clip2 =
+        MakeParam("ref2va.avclip2", ecfg.in_channels * FT * IH * IW, 1.0);
+    vllm::MiniMaxH3RefBlock vb2{};
+    vllm::MiniMaxH3T2vaRequest loud2 = loud;
+    loud2.keyframe_cond_rows =
+        vllm::MiniMaxH3EncodeReferenceVideo(ecfg, ew, p, clip2, FT, IH, IW, &vb2);
+    const vllm::MiniMaxH3DenoiseResult sounded2 = vllm::MiniMaxH3DenoiseT2va(
+        vt::Device{}, loud2, p, dit->views, prompt, nv, na, vt::DType::kF32);
+    double visual_delta = 0.0;
+    for (size_t i = 0; i < nv_n; ++i) {
+      visual_delta = std::max(visual_delta, std::abs(static_cast<double>(sounded.video_rows[i]) -
+                                                    sounded2.video_rows[i]));
+    }
+    INFO("a DIFFERENT reference clip (with the same audio) moved the video rows by "
+         << visual_delta);
+    CHECK(visual_delta > 1e-5);
+  }
+}
+
+TEST_CASE("minimax_h3: the WHOLE t2va path composes end to end") {
+  // Not a quality result -- reduced dimensions and random weights -- but a real
+  // structural end-to-end exercise of the assembled pipeline: packed layout ->
+  // sigma schedules -> a multi-step denoise loop of DiT forwards -> unpatchify /
+  // audio unpack -> denormalize -> BOTH VAE decoders -> frames + stereo waveform.
+  // Each stage is separately gated against upstream; this proves they COMPOSE and
+  // that shapes and finiteness survive the whole path.
+  const std::unique_ptr<GoldenWeights> dit = BuildGoldenWeights();
+  const MiniMaxH3DitParams& p = dit->params;
+
+  vllm::MiniMaxH3T2vaRequest request;
+  request.text_len = 4;
+  request.latent_t = 2;
+  request.latent_h = 4;
+  request.latent_w = 4;
+  request.audio_t = 4;      // audio rows = audio_t * audio_channel
+  request.audio_channel = 2;
+  request.num_steps = 3;    // 3 schedule points -> 2 denoise steps
+  request.video_shift = 12.0;
+  request.audio_shift = 3.0;
+
+  // --- video VAE decoder sized to the DiT's video latent ---
+  vllm::MiniMaxH3VideoVaeDecoderConfig video_config;
+  video_config.block.dim = 16;
+  video_config.block.heads = 2;
+  video_config.block.dim_head = 8;
+  video_config.block.ff_inner = 16;
+  video_config.block.eps = 1e-5;
+  video_config.num_layers = 1;
+  video_config.in_channels = p.latents_dim;
+  video_config.out_channels = 3;
+  video_config.patch_size = 2;
+  video_config.patch_size_t = 1;
+  video_config.num_register_tokens = 2;
+  video_config.rope_apply_dim = 6;
+  video_config.rope_theta = 100.0;
+
+  vllm::MiniMaxH3AudioVaeWeights video_weights;
+  {
+    const int64_t dim = video_config.block.dim;
+    const int64_t inner = video_config.block.heads * video_config.block.dim_head;
+    auto put = [&](const std::string& n, int64_t c, double sc, double off) {
+      video_weights.tensors[n] = MakeParam("e2e.vvae." + n, c, sc, off);
+    };
+    put("x_embedder.weight", dim * video_config.in_channels, 0.1, 0.0);
+    put("x_embedder.bias", dim, 0.05, 0.0);
+    put("register_tokens", video_config.num_register_tokens * dim, 0.1, 0.0);
+    put("norm_out.weight", dim, 0.1, 1.0);
+    put("norm_out.bias", dim, 0.05, 0.0);
+    const int64_t patch_dim = video_config.out_channels * video_config.patch_size_t *
+                              video_config.patch_size * video_config.patch_size;
+    put("proj_out.weight", patch_dim * dim, 0.1, 0.0);
+    put("proj_out.bias", patch_dim, 0.05, 0.0);
+    for (int64_t l = 0; l < video_config.num_layers; ++l) {
+      const std::string b = "transformer_blocks." + std::to_string(l) + ".";
+      put(b + "norm1.weight", dim, 0.1, 1.0);
+      put(b + "norm2.weight", dim, 0.1, 1.0);
+      put(b + "scale1", dim, 0.1, 0.0);
+      put(b + "scale2", dim, 0.1, 0.0);
+      put(b + "attn.to_qkv.weight", 3 * inner * dim, 0.1, 0.0);
+      put(b + "attn.to_qkv.bias", 3 * inner, 0.05, 0.0);
+      put(b + "attn.to_out.weight", dim * inner, 0.1, 0.0);
+      put(b + "attn.to_out.bias", dim, 0.05, 0.0);
+      put(b + "ff.w1.weight", 2 * video_config.block.ff_inner * dim, 0.1, 0.0);
+      put(b + "ff.w1.bias", 2 * video_config.block.ff_inner, 0.05, 0.0);
+      put(b + "ff.w2.weight", dim * video_config.block.ff_inner, 0.1, 0.0);
+      put(b + "ff.w2.bias", dim, 0.05, 0.0);
+    }
+  }
+
+  // --- audio VAE, with dec_in_proj so it consumes the DiT's audio latent width ---
+  vllm::MiniMaxH3AudioVaeConfig audio_config;
+  audio_config.num_mels = 8;
+  audio_config.upsample_initial_channel = 8;
+  audio_config.upsample_rates = {2};
+  audio_config.upsample_kernel_sizes = {4};
+  audio_config.resblock_kernel_sizes = {3};
+  audio_config.resblock_dilation_sizes = {{1}};
+  audio_config.use_tanh_at_final = false;
+  audio_config.use_bias_at_final = false;
+  audio_config.snake_logscale = true;
+
+  vllm::MiniMaxH3AudioVaeWeights audio_weights;
+  {
+    auto put = [&](const std::string& n, int64_t c, double sc, double off) {
+      audio_weights.tensors[n] = MakeParam("e2e.avae." + n, c, sc, off);
+    };
+    auto put_conv = [&](const std::string& prefix, int64_t oc, int64_t ic, int64_t k, bool bias) {
+      put(prefix + ".parametrizations.weight.original0", oc, 0.03, 0.15);
+      put(prefix + ".parametrizations.weight.original1", oc * ic * k, 0.08, 0.0);
+      if (bias) put(prefix + ".bias", oc, 0.05, 0.0);
+    };
+    // dec_in_proj: the DiT's audio latent width -> num_mels.
+    put("dec_in_proj.weight", audio_config.num_mels * p.audio_latents_dim, 0.1, 0.0);
+    put("dec_in_proj.bias", audio_config.num_mels, 0.05, 0.0);
+    put_conv("conv_pre", audio_config.upsample_initial_channel, audio_config.num_mels, 7, true);
+    const int64_t ch = audio_config.upsample_initial_channel / 2;
+    put("ups.0.0.parametrizations.weight.original0", audio_config.upsample_initial_channel, 0.03, 0.15);
+    put("ups.0.0.parametrizations.weight.original1",
+        audio_config.upsample_initial_channel * ch * 4, 0.08, 0.0);
+    put("ups.0.0.bias", ch, 0.05, 0.0);
+    put_conv("resblocks.0.convs1.0", ch, ch, 3, true);
+    put_conv("resblocks.0.convs2.0", ch, ch, 3, true);
+    for (const char* a : {"resblocks.0.activations.0", "resblocks.0.activations.1",
+                          "activation_post"}) {
+      put(std::string(a) + ".act.alpha", ch, 0.2, 0.0);
+      put(std::string(a) + ".act.beta", ch, 0.2, 0.0);
+    }
+    put_conv("conv_post", 1, ch, 7, false);
+  }
+
+  // --- inputs ---
+  const std::vector<float> prompt_embeds =
+      MakeParam("e2e.prompt_embeds", request.text_len * p.text_dim, 1.0);
+  const int64_t frame_rows = (request.latent_h / p.patch_size_h) * (request.latent_w / p.patch_size_w);
+  const int64_t video_rows = request.latent_t * frame_rows;
+  const int64_t audio_rows = request.audio_t * request.audio_channel;
+  const std::vector<float> noise_video =
+      MakeParam("e2e.noise_video", video_rows * p.video_row_width(), 1.0);
+  const std::vector<float> noise_audio =
+      MakeParam("e2e.noise_audio", audio_rows * p.audio_latents_dim, 1.0);
+
+  const vllm::MiniMaxH3T2vaResult out = vllm::MiniMaxH3GenerateT2va(
+      Cpu(), request, p, dit->views, video_config, video_weights, audio_config, audio_weights,
+      prompt_embeds, noise_video, noise_audio, vt::DType::kF32);
+
+  // Frames: [3, T*pt, H*ps, W*ps].
+  CHECK(out.frame_shape.channels == 3);
+  CHECK(out.frame_shape.t == request.latent_t * video_config.patch_size_t);
+  CHECK(out.frame_shape.h == request.latent_h * video_config.patch_size);
+  CHECK(out.frame_shape.w == request.latent_w * video_config.patch_size);
+  CHECK(static_cast<int64_t>(out.frames.size()) ==
+        out.frame_shape.channels * out.frame_shape.t * out.frame_shape.h * out.frame_shape.w);
+  for (float v : out.frames) REQUIRE(std::isfinite(v));
+
+  // Audio: stereo, in [-1, 1], at the H3 sample rate.
+  CHECK(out.audio_channels == request.audio_channel);
+  CHECK(out.sample_rate == vllm::kMiniMaxH3AudioSampleRate);
+  CHECK(out.audio_samples_per_channel > 0);
+  CHECK(static_cast<int64_t>(out.waveform.size()) ==
+        out.audio_channels * out.audio_samples_per_channel);
+  for (float v : out.waveform) {
+    REQUIRE(std::isfinite(v));
+    CHECK(v >= -1.0f);
+    CHECK(v <= 1.0f);
+  }
+
+  // The denoise loop must have MOVED the latents: if the output equalled the noise
+  // the pipeline would be silently bypassing the DiT.
+  double moved = 0.0;
+  for (size_t i = 0; i < noise_video.size(); ++i) {
+    moved = std::max(moved, static_cast<double>(std::abs(noise_video[i])));
+  }
+  CHECK(moved > 0.0);
+
+  // DEVICE PATH through the WHOLE pipeline. The denoise loop stages the DiT weights
+  // once and runs every step device-resident; this asserts the resulting video and
+  // audio match the CPU pipeline. Without it the device wiring is reachable only
+  // through the DiT-forward unit test, not through the loop that actually drives it.
+  {
+    vt::Backend* cuda = nullptr;
+    try {
+      cuda = &vt::GetBackend(vt::DeviceType::kCUDA);
+    } catch (...) {
+      cuda = nullptr;
+    }
+    if (cuda == nullptr) {
+      MESSAGE("SKIP: no CUDA backend registered (device t2va)");
+    } else {
+      const vt::Queue dq = cuda->CreateQueue();
+      const vllm::MiniMaxH3T2vaResult dev = vllm::MiniMaxH3GenerateT2va(
+          dq.device, request, p, dit->views, video_config, video_weights, audio_config,
+          audio_weights, prompt_embeds, noise_video, noise_audio, vt::DType::kF32);
+      REQUIRE(dev.frames.size() == out.frames.size());
+      REQUIRE(dev.waveform.size() == out.waveform.size());
+      double fmax = 0.0, amax = 0.0;
+      for (size_t i = 0; i < out.frames.size(); ++i) {
+        fmax = std::max(fmax, std::abs(static_cast<double>(dev.frames[i] - out.frames[i])));
+      }
+      for (size_t i = 0; i < out.waveform.size(); ++i) {
+        amax = std::max(amax, std::abs(static_cast<double>(dev.waveform[i] - out.waveform[i])));
+      }
+      INFO("device-vs-cpu t2va: frames " << fmax << ", waveform " << amax);
+      // Not bit-identical by construction (the device path reuses the tuned shared
+      // ops, whose reductions differ), so this is the same tolerance class the DiT
+      // forward is held to, carried through the VAEs.
+      CHECK(fmax <= 2e-3);
+      CHECK(amax <= 2e-3);
+      for (float v : dev.frames) REQUIRE(std::isfinite(v));
+    }
+  }
+
+  // post_quant_conv: the real checkpoint ships it, and the pipeline must APPLY it
+  // to the latent before decoding. The weight set above deliberately omits it (a
+  // reduced-dimension set need not carry every wrapper tensor), so re-run WITH one
+  // and require the frames to CHANGE. Without this the wiring is a branch no test
+  // enters, which is how the step went missing in the first place.
+  vllm::MiniMaxH3AudioVaeWeights video_weights_pqc = video_weights;
+  const int64_t lc = p.latents_dim;
+  std::vector<float> pqc(static_cast<size_t>(lc * lc), 0.0f);
+  for (int64_t i = 0; i < lc; ++i) pqc[static_cast<size_t>(i * lc + i)] = 1.0f;  // identity...
+  pqc[1] = 0.25f;  // ...plus one off-diagonal term, so it genuinely MIXES channels
+  video_weights_pqc.tensors["post_quant_conv.weight"] = pqc;
+  video_weights_pqc.tensors["post_quant_conv.bias"] = std::vector<float>(lc, 0.0f);
+
+  const vllm::MiniMaxH3T2vaResult out_pqc = vllm::MiniMaxH3GenerateT2va(
+      Cpu(), request, p, dit->views, video_config, video_weights_pqc, audio_config, audio_weights,
+      prompt_embeds, noise_video, noise_audio, vt::DType::kF32);
+  REQUIRE(out_pqc.frames.size() == out.frames.size());
+  double frame_delta = 0.0;
+  for (size_t i = 0; i < out.frames.size(); ++i) {
+    frame_delta = std::max(frame_delta,
+                           std::abs(static_cast<double>(out_pqc.frames[i] - out.frames[i])));
+  }
+  INFO("post_quant_conv frame delta = " << frame_delta);
+  CHECK(frame_delta > 1e-6);
+  // The AUDIO path must be untouched by a VIDEO-side wrapper tensor.
+  REQUIRE(out_pqc.waveform.size() == out.waveform.size());
+  for (size_t i = 0; i < out.waveform.size(); ++i) {
+    CHECK(out_pqc.waveform[i] == out.waveform[i]);
+  }
+}
+
+TEST_CASE("minimax_h3: a ComfyUI-format GGUF loads into a runnable DiT") {
+  // Closes the GGUF arm: the manifest test proved names and shapes resolve; this
+  // proves a real GGUF file DEQUANTIZES into weights the forward actually runs.
+  // A synthetic checkpoint is used so the test needs no download; the shapes and
+  // the `comfy.gguf.orig_shape` reshape rule mirror the real file exactly.
+  MiniMaxH3DitParams want;  // the geometry the loader must RECOVER from shapes
+  want.num_layers = 2;
+  want.token_refiner_num_layers = 1;
+  want.hidden_size = 64;
+  want.num_attention_heads = 4;
+  want.attention_head_dim = 16;
+  want.ffn_hidden_size = 128;
+  want.latents_dim = 8;
+  want.audio_latents_dim = 6;
+  want.text_dim = 24;
+  want.timestep_input_dim = 16;
+  want.time_embed_hidden_size = 64;
+  want.time_embed_dim = 32;
+  want.adaln_out_features = 18 * want.hidden_size;
+  want.final_adaln_out_features = 2 * want.hidden_size;
+  want.rope_inv_freq_len = 2;
+
+  gguf_test::GgufModelBuilder builder;
+  builder.AddKv(gguf_test::StrKv("general.architecture", "wan"));
+
+  // GGUF stores `ne` REVERSED vs torch, so a logical [out, in] weight is written
+  // [in, out]. F32 everywhere keeps the test about the LOADER, not about quant
+  // error (the K-quant families go through the same shared dequant entry point).
+  auto add = [&](const std::string& name, const std::vector<int64_t>& logical) {
+    int64_t numel = 1;
+    for (int64_t d : logical) numel *= d;
+    const std::vector<float> values = MakeParam("gguf." + name, numel, 0.1);
+    std::string bytes(reinterpret_cast<const char*>(values.data()), values.size() * sizeof(float));
+    std::vector<uint64_t> ne;
+    for (auto it = logical.rbegin(); it != logical.rend(); ++it) {
+      ne.push_back(static_cast<uint64_t>(*it));
+    }
+    builder.AddTensor(name, ne, /*ggml_type=*/0 /*F32*/, bytes);
+  };
+
+  const int64_t inner = want.num_attention_heads * want.attention_head_dim;
+  const int64_t video_width = want.video_row_width();
+  add("video_patch_proj.weight", {want.hidden_size, video_width});
+  add("video_patch_proj.bias", {want.hidden_size});
+  add("audio_patch_proj.weight", {want.hidden_size, want.audio_latents_dim});
+  add("audio_patch_proj.bias", {want.hidden_size});
+  add("condition_proj.weight", {want.hidden_size, want.text_dim});
+  add("condition_proj.bias", {want.hidden_size});
+  add("time_embedder.proj_in.weight", {want.time_embed_hidden_size, want.timestep_input_dim});
+  add("time_embedder.proj_in.bias", {want.time_embed_hidden_size});
+  add("time_embedder.proj_out.weight", {want.time_embed_dim, want.time_embed_hidden_size});
+  add("time_embedder.proj_out.bias", {want.time_embed_dim});
+  add("rope.inv_freq", {want.rope_inv_freq_len});
+  auto add_block = [&](const std::string& prefix, bool with_adaln) {
+    add(prefix + ".norm1.weight", {want.hidden_size});
+    add(prefix + ".norm2.weight", {want.hidden_size});
+    add(prefix + ".attn.qkv_proj.weight", {3 * inner, want.hidden_size});
+    add(prefix + ".attn.q_norm.weight", {want.attention_head_dim});
+    add(prefix + ".attn.k_norm.weight", {want.attention_head_dim});
+    add(prefix + ".attn.out_proj.weight", {want.hidden_size, inner});
+    add(prefix + ".mlp.fc1.weight", {2 * want.ffn_hidden_size, want.hidden_size});
+    add(prefix + ".mlp.fc2.weight", {want.hidden_size, want.ffn_hidden_size});
+    if (with_adaln) {
+      add(prefix + ".adaln_proj.linear.weight", {want.adaln_out_features, want.time_embed_dim});
+      add(prefix + ".adaln_proj.linear.bias", {want.adaln_out_features});
+    }
+  };
+  for (int64_t i = 0; i < want.token_refiner_num_layers; ++i) {
+    add_block("token_refiner.blocks." + std::to_string(i), false);
+  }
+  add("token_refiner.final_norm.weight", {want.hidden_size});
+  for (int64_t i = 0; i < want.num_layers; ++i) {
+    add_block("blocks." + std::to_string(i), true);
+  }
+  add("final_layer.norm.weight", {want.hidden_size});
+  add("final_layer.adaln_proj.linear.weight", {want.final_adaln_out_features, want.time_embed_dim});
+  add("final_layer.adaln_proj.linear.bias", {want.final_adaln_out_features});
+  add("final_layer.video_out.weight", {video_width, want.hidden_size});
+  add("final_layer.video_out.bias", {video_width});
+  add("final_layer.audio_out.weight", {want.audio_latents_dim, want.hidden_size});
+  add("final_layer.audio_out.bias", {want.audio_latents_dim});
+
+  const std::string path = "/tmp/minimax_h3_loader_test.gguf";
+  {
+    const std::string bytes = builder.Build();
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    CHECK(std::fwrite(bytes.data(), 1, bytes.size(), fh) == bytes.size());
+    std::fclose(fh);
+  }
+
+  const vllm::GgufFile gguf = vllm::GgufFile::Open(path);
+  const vllm::MiniMaxH3GgufDit loaded = vllm::LoadMiniMaxH3DitFromGguf(gguf);
+
+  // The geometry must be RECOVERED from tensor shapes alone.
+  CHECK(loaded.params.num_layers == want.num_layers);
+  CHECK(loaded.params.token_refiner_num_layers == want.token_refiner_num_layers);
+  CHECK(loaded.params.hidden_size == want.hidden_size);
+  CHECK(loaded.params.num_attention_heads == want.num_attention_heads);
+  CHECK(loaded.params.attention_head_dim == want.attention_head_dim);
+  CHECK(loaded.params.ffn_hidden_size == want.ffn_hidden_size);
+  CHECK(loaded.params.latents_dim == want.latents_dim);
+  CHECK(loaded.params.audio_latents_dim == want.audio_latents_dim);
+  CHECK(loaded.params.text_dim == want.text_dim);
+  CHECK(loaded.params.rope_inv_freq_len == want.rope_inv_freq_len);
+  CHECK(static_cast<int64_t>(loaded.weights.blocks.size()) == want.num_layers);
+  CHECK(static_cast<int64_t>(loaded.weights.refiner.size()) == want.token_refiner_num_layers);
+
+  // A loaded weight must carry the LOGICAL (torch) shape, not the reversed ne.
+  CHECK(loaded.weights.blocks[0].qkv_proj.shape[0] == 3 * inner);
+  CHECK(loaded.weights.blocks[0].qkv_proj.shape[1] == want.hidden_size);
+
+  // And the whole thing must actually RUN: a real forward off GGUF-loaded weights.
+  const MiniMaxH3PackedSequence packed = BuildMiniMaxH3PackedSequence(
+      4, 2, 4, 4, 2, 2, /*include_keyframe_cond=*/false, {}, 0);
+  const int64_t seq = packed.seq_len;
+  const int64_t num_img = static_cast<int64_t>(packed.img_pos.size());
+  const int64_t num_audio = static_cast<int64_t>(packed.audio_pos.size());
+  const int64_t num_text = static_cast<int64_t>(packed.text_pos.size());
+  const std::vector<float> x(static_cast<size_t>(seq * video_width), 0.25f);
+  const std::vector<float> audio_x(static_cast<size_t>(seq * want.audio_latents_dim), 0.1f);
+  const std::vector<float> prompt(static_cast<size_t>(num_text * want.text_dim), 0.2f);
+  const std::vector<float> unique_ts = {0.4f};
+  const std::vector<int64_t> inverse(static_cast<size_t>(seq), 0);
+  const std::vector<int32_t> refiner_cu = {0, static_cast<int32_t>(num_text),
+                                           static_cast<int32_t>(num_text)};
+  MiniMaxH3DitInputs in;
+  in.seq_len = seq;
+  in.x = x.data();
+  in.audio_x = audio_x.data();
+  in.img_position_ids = packed.img_position_ids.data();
+  in.unique_timesteps = unique_ts.data();
+  in.num_unique_timesteps = 1;
+  in.inverse_indices = inverse.data();
+  in.token_tags = packed.token_tags.data();
+  in.prompt_embeds = prompt.data();
+  in.img_pos = packed.img_pos.data();
+  in.num_img_pos = num_img;
+  in.audio_pos = packed.audio_pos.data();
+  in.num_audio_pos = num_audio;
+  in.text_pos = packed.text_pos.data();
+  in.num_text_pos = num_text;
+  in.infer_out_pos = packed.img_pos.data();
+  in.num_infer_out_pos = num_img;
+  in.update_mask = packed.update_mask.data();
+  in.cu_seqlens = packed.cu_seqlens.data();
+  in.num_cu_seqlens = static_cast<int64_t>(packed.cu_seqlens.size());
+  in.refiner_cu_seqlens = refiner_cu.data();
+  in.num_refiner_cu_seqlens = static_cast<int64_t>(refiner_cu.size());
+
+  const MiniMaxH3DitOutputs got =
+      MiniMaxH3DitForward(Cpu(), loaded.params, loaded.weights, in, vt::DType::kF32);
+  CHECK(static_cast<int64_t>(got.video_logits.size()) == num_img * video_width);
+  CHECK(static_cast<int64_t>(got.audio_logits.size()) == num_audio * want.audio_latents_dim);
+  for (float v : got.video_logits) REQUIRE(std::isfinite(v));
+  for (float v : got.audio_logits) REQUIRE(std::isfinite(v));
+  std::remove(path.c_str());
+}
+
+TEST_CASE("minimax_h3: an NVFP4 checkpoint loads into a runnable DiT") {
+  // Closes the NVFP4 arm's loader: the manifest test proved the real checkpoint's
+  // layout IS ours; this proves a file in that layout dequantizes into weights the
+  // forward runs. Synthetic so no download is needed, but the triple is built
+  // exactly as the real file stores it.
+  MiniMaxH3DitParams want;
+  want.num_layers = 1;
+  want.token_refiner_num_layers = 1;
+  want.hidden_size = 64;
+  want.num_attention_heads = 4;
+  want.attention_head_dim = 16;
+  want.ffn_hidden_size = 128;
+  want.latents_dim = 8;
+  want.audio_latents_dim = 6;
+  want.text_dim = 32;   // must be a multiple of 16 (the NVFP4 group)
+  want.timestep_input_dim = 16;
+  want.time_embed_hidden_size = 64;
+  want.time_embed_dim = 32;
+  want.adaln_out_features = 18 * want.hidden_size;
+  want.final_adaln_out_features = 2 * want.hidden_size;
+  want.rope_inv_freq_len = 2;
+
+  struct Entry {
+    std::string name;
+    std::string dtype;
+    std::vector<int64_t> shape;
+    std::string bytes;
+  };
+  std::vector<Entry> entries;
+
+  auto add_plain = [&](const std::string& name, const std::vector<int64_t>& shape) {
+    int64_t numel = 1;
+    for (int64_t d : shape) numel *= d;
+    const std::vector<float> values = MakeParam("nvfp4." + name, numel, 0.1);
+    entries.push_back({name, "F32", shape,
+                       std::string(reinterpret_cast<const char*>(values.data()),
+                                   values.size() * sizeof(float))});
+  };
+  // A quantized projection: packed U8 [out, in/2] + E4M3 [out, in/16] + F32 scalar.
+  auto add_quant = [&](const std::string& name, int64_t out_dim, int64_t in_dim) {
+    REQUIRE(in_dim % 16 == 0);
+    std::string packed(static_cast<size_t>(out_dim * (in_dim / 2)), '\0');
+    for (size_t i = 0; i < packed.size(); ++i) {
+      packed[i] = static_cast<char>((i * 37 + 11) & 0xFF);  // deterministic nibbles
+    }
+    std::string scales(static_cast<size_t>(out_dim * (in_dim / 16)), '\0');
+    for (size_t i = 0; i < scales.size(); ++i) {
+      scales[i] = static_cast<char>(0x38);  // e4m3 ~ 1.0
+    }
+    const float global = 0.5f;
+    entries.push_back({name, "U8", {out_dim, in_dim / 2}, packed});
+    entries.push_back({name + "_scale", "F8_E4M3", {out_dim, in_dim / 16}, scales});
+    entries.push_back({name + "_scale_2", "F32", {},
+                       std::string(reinterpret_cast<const char*>(&global), sizeof(float))});
+  };
+
+  const int64_t inner = want.num_attention_heads * want.attention_head_dim;
+  const int64_t video_width = want.video_row_width();
+  // Islands stay unquantized, exactly as the real checkpoint has them.
+  add_plain("video_patch_proj.weight", {want.hidden_size, video_width});
+  add_plain("video_patch_proj.bias", {want.hidden_size});
+  add_plain("audio_patch_proj.weight", {want.hidden_size, want.audio_latents_dim});
+  add_plain("audio_patch_proj.bias", {want.hidden_size});
+  add_plain("condition_proj.bias", {want.hidden_size});
+  add_plain("time_embedder.proj_in.weight", {want.time_embed_hidden_size, want.timestep_input_dim});
+  add_plain("time_embedder.proj_in.bias", {want.time_embed_hidden_size});
+  add_plain("time_embedder.proj_out.weight", {want.time_embed_dim, want.time_embed_hidden_size});
+  add_plain("time_embedder.proj_out.bias", {want.time_embed_dim});
+  add_plain("rope.inv_freq", {want.rope_inv_freq_len});
+  // condition_proj is quantized in the real file.
+  add_quant("condition_proj.weight", want.hidden_size, want.text_dim);
+  auto add_block = [&](const std::string& prefix, bool with_adaln) {
+    add_plain(prefix + ".norm1.weight", {want.hidden_size});
+    add_plain(prefix + ".norm2.weight", {want.hidden_size});
+    add_plain(prefix + ".attn.q_norm.weight", {want.attention_head_dim});
+    add_plain(prefix + ".attn.k_norm.weight", {want.attention_head_dim});
+    add_quant(prefix + ".attn.qkv_proj.weight", 3 * inner, want.hidden_size);
+    add_quant(prefix + ".attn.out_proj.weight", want.hidden_size, inner);
+    add_quant(prefix + ".mlp.fc1.weight", 2 * want.ffn_hidden_size, want.hidden_size);
+    add_quant(prefix + ".mlp.fc2.weight", want.hidden_size, want.ffn_hidden_size);
+    if (with_adaln) {
+      add_quant(prefix + ".adaln_proj.linear.weight", want.adaln_out_features, want.time_embed_dim);
+      add_plain(prefix + ".adaln_proj.linear.bias", {want.adaln_out_features});
+    }
+  };
+  add_block("token_refiner.blocks.0", false);
+  add_plain("token_refiner.final_norm.weight", {want.hidden_size});
+  add_block("blocks.0", true);
+  add_plain("final_layer.norm.weight", {want.hidden_size});
+  add_quant("final_layer.adaln_proj.linear.weight", want.final_adaln_out_features, want.time_embed_dim);
+  add_plain("final_layer.adaln_proj.linear.bias", {want.final_adaln_out_features});
+  add_plain("final_layer.video_out.weight", {video_width, want.hidden_size});
+  add_plain("final_layer.video_out.bias", {video_width});
+  add_plain("final_layer.audio_out.weight", {want.audio_latents_dim, want.hidden_size});
+  add_plain("final_layer.audio_out.bias", {want.audio_latents_dim});
+
+  // Serialize a safetensors file: 8-byte header length, JSON header, then data.
+  std::string header = "{";
+  size_t offset = 0;
+  bool first = true;
+  for (const Entry& e : entries) {
+    if (!first) header += ",";
+    first = false;
+    header += "\"" + e.name + "\":{\"dtype\":\"" + e.dtype + "\",\"shape\":[";
+    for (size_t i = 0; i < e.shape.size(); ++i) {
+      if (i) header += ",";
+      header += std::to_string(e.shape[i]);
+    }
+    header += "],\"data_offsets\":[" + std::to_string(offset) + "," +
+              std::to_string(offset + e.bytes.size()) + "]}";
+    offset += e.bytes.size();
+  }
+  header += "}";
+  const std::string path = "/tmp/minimax_h3_nvfp4_test.safetensors";
+  {
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    const uint64_t n = header.size();
+    std::fwrite(&n, sizeof(n), 1, fh);
+    std::fwrite(header.data(), 1, header.size(), fh);
+    for (const Entry& e : entries) std::fwrite(e.bytes.data(), 1, e.bytes.size(), fh);
+    std::fclose(fh);
+  }
+
+  const vllm::SafetensorsFile st = vllm::SafetensorsFile::Open(path);
+  const vllm::MiniMaxH3GgufDit loaded = vllm::LoadMiniMaxH3DitFromNvfp4(st);
+
+  // Geometry recovered from the DEQUANTIZED shapes: a packed [out, in/2] weight
+  // must come back as the logical [out, in].
+  CHECK(loaded.params.hidden_size == want.hidden_size);
+  CHECK(loaded.params.num_attention_heads == want.num_attention_heads);
+  CHECK(loaded.params.attention_head_dim == want.attention_head_dim);
+  CHECK(loaded.params.ffn_hidden_size == want.ffn_hidden_size);
+  CHECK(loaded.params.text_dim == want.text_dim);
+  CHECK(loaded.weights.blocks[0].qkv_proj.shape[0] == 3 * inner);
+  CHECK(loaded.weights.blocks[0].qkv_proj.shape[1] == want.hidden_size);
+  CHECK(loaded.shapes.at("blocks.0.mlp.fc1.weight")[1] == want.hidden_size);
+  // The quant sidecars must NOT appear as model tensors.
+  CHECK(loaded.storage.count("blocks.0.attn.qkv_proj.weight_scale") == 0);
+  CHECK(loaded.storage.count("blocks.0.attn.qkv_proj.weight_scale_2") == 0);
+
+  // The STREAMING stager must recover the same model as the reference loader.
+  // It exists because the reference one materializes every weight as host f32 --
+  // ~132 GB for the real checkpoint, an OOM kill during load on a 122 GiB unified
+  // box -- so the streamed path is what a real run actually uses, and "it loads
+  // without OOM" is not the same claim as "it loads the right numbers".
+  {
+    vt::Queue q = vt::GetBackend(vt::DeviceType::kCPU).CreateQueue();
+    vllm::MiniMaxH3DitParams streamed_params;
+    const vllm::MiniMaxH3DitDeviceWeights streamed =
+        vllm::StreamMiniMaxH3Nvfp4ToDeviceBf16(q, st, &streamed_params);
+    CHECK(streamed_params.hidden_size == want.hidden_size);
+    CHECK(streamed_params.num_layers == loaded.params.num_layers);
+    REQUIRE(streamed.weights.blocks.size() == loaded.weights.blocks.size());
+
+    // A packed weight comes back at the same logical shape, and its VALUES match
+    // the reference to bf16 rounding -- the streamed path stores bf16 where the
+    // reference keeps f32, so the tolerance is the cast, not the algorithm.
+    const vt::Tensor& sq_ = streamed.weights.blocks[0].qkv_proj;
+    REQUIRE(sq_.rank == 2);
+    CHECK(sq_.shape[0] == 3 * inner);
+    CHECK(sq_.shape[1] == want.hidden_size);
+    CHECK(sq_.dtype == vt::DType::kBF16);
+    const std::vector<float>& ref = loaded.storage.at("blocks.0.attn.qkv_proj.weight");
+    const int64_t n = sq_.shape[0] * sq_.shape[1];
+    REQUIRE(static_cast<int64_t>(ref.size()) == n);
+    const uint16_t* got = static_cast<const uint16_t*>(sq_.data);
+    double worst = 0.0;
+    for (int64_t i = 0; i < n; ++i) {
+      const uint32_t widened = static_cast<uint32_t>(got[i]) << 16;
+      float v;
+      std::memcpy(&v, &widened, sizeof(v));
+      worst = std::max(worst, std::abs(static_cast<double>(v) - ref[static_cast<size_t>(i)]));
+    }
+    INFO("streamed NVFP4 vs reference loader, max|diff| = " << worst);
+    CHECK(worst <= 1e-2);  // bf16 has ~8 mantissa bits; values here are O(1)
+
+    // rope.inv_freq must stay HOST-resident: the forward reads it before any
+    // kernel runs, so a device pointer here segfaults rather than misbehaving.
+    CHECK(!streamed.rope_inv_freq_host.empty());
+    CHECK(streamed.weights.rope_inv_freq.data == streamed.rope_inv_freq_host.data());
+  }
+
+  // And it must RUN.
+  const MiniMaxH3PackedSequence packed = BuildMiniMaxH3PackedSequence(
+      4, 2, 4, 4, 2, 2, /*include_keyframe_cond=*/false, {}, 0);
+  const int64_t seq = packed.seq_len;
+  const int64_t num_img = static_cast<int64_t>(packed.img_pos.size());
+  const int64_t num_audio = static_cast<int64_t>(packed.audio_pos.size());
+  const int64_t num_text = static_cast<int64_t>(packed.text_pos.size());
+  const std::vector<float> x(static_cast<size_t>(seq * video_width), 0.25f);
+  const std::vector<float> audio_x(static_cast<size_t>(seq * want.audio_latents_dim), 0.1f);
+  const std::vector<float> prompt(static_cast<size_t>(num_text * want.text_dim), 0.2f);
+  const std::vector<float> unique_ts = {0.4f};
+  const std::vector<int64_t> inverse(static_cast<size_t>(seq), 0);
+  const std::vector<int32_t> refiner_cu = {0, static_cast<int32_t>(num_text),
+                                           static_cast<int32_t>(num_text)};
+  MiniMaxH3DitInputs in;
+  in.seq_len = seq;
+  in.x = x.data();
+  in.audio_x = audio_x.data();
+  in.img_position_ids = packed.img_position_ids.data();
+  in.unique_timesteps = unique_ts.data();
+  in.num_unique_timesteps = 1;
+  in.inverse_indices = inverse.data();
+  in.token_tags = packed.token_tags.data();
+  in.prompt_embeds = prompt.data();
+  in.img_pos = packed.img_pos.data();
+  in.num_img_pos = num_img;
+  in.audio_pos = packed.audio_pos.data();
+  in.num_audio_pos = num_audio;
+  in.text_pos = packed.text_pos.data();
+  in.num_text_pos = num_text;
+  in.infer_out_pos = packed.img_pos.data();
+  in.num_infer_out_pos = num_img;
+  in.update_mask = packed.update_mask.data();
+  in.cu_seqlens = packed.cu_seqlens.data();
+  in.num_cu_seqlens = static_cast<int64_t>(packed.cu_seqlens.size());
+  in.refiner_cu_seqlens = refiner_cu.data();
+  in.num_refiner_cu_seqlens = static_cast<int64_t>(refiner_cu.size());
+
+  const MiniMaxH3DitOutputs got =
+      MiniMaxH3DitForward(Cpu(), loaded.params, loaded.weights, in, vt::DType::kF32);
+  CHECK(static_cast<int64_t>(got.video_logits.size()) == num_img * video_width);
+  for (float v : got.video_logits) REQUIRE(std::isfinite(v));
+  for (float v : got.audio_logits) REQUIRE(std::isfinite(v));
+  std::remove(path.c_str());
+}
+
+TEST_CASE("minimax_h3: the encoder VISION block matches upstream") {
+  // The repeated unit of the H3-Encoder's Qwen3-VL vision tower. It differs from
+  // the text tower in ways that all matter numerically: LayerNorm (with bias) not
+  // RMSNorm, a [q_all|k_all|v_all] qkv layout, fp32 rotary, NON-CAUSAL attention
+  // segmented by cu_seqlens, and the TANH-approximate GELU.
+  vllm::MiniMaxH3VisionBlockConfig config;
+  config.hidden_size = vllm_test::kH3EncVisDim;
+  config.num_heads = vllm_test::kH3EncVisHeads;
+  config.intermediate_size = vllm_test::kH3EncVisIntermediate;
+  config.eps = 1e-6;
+
+  const int64_t dim = config.hidden_size;
+  const int64_t seq = vllm_test::kH3EncVisSeq;
+
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& suffix, int64_t count, double scale, double offset) {
+    weights.tensors["vb." + suffix] = MakeParam("encoder.vision." + suffix, count, scale, offset);
+  };
+  put("norm1.weight", dim, 0.1, 1.0);
+  put("norm1.bias", dim, 0.05, 0.0);
+  put("norm2.weight", dim, 0.1, 1.0);
+  put("norm2.bias", dim, 0.05, 0.0);
+  put("attn.qkv.weight", 3 * dim * dim, 0.1, 0.0);
+  put("attn.qkv.bias", 3 * dim, 0.05, 0.0);
+  put("attn.proj.weight", dim * dim, 0.1, 0.0);
+  put("attn.proj.bias", dim, 0.05, 0.0);
+  put("mlp.linear_fc1.weight", config.intermediate_size * dim, 0.1, 0.0);
+  put("mlp.linear_fc1.bias", config.intermediate_size, 0.05, 0.0);
+  put("mlp.linear_fc2.weight", dim * config.intermediate_size, 0.1, 0.0);
+  put("mlp.linear_fc2.bias", dim, 0.05, 0.0);
+
+  const std::vector<float> hidden = MakeParam("encoder.vision.input", seq * dim, 1.0);
+  const std::vector<float> cos(vllm_test::kH3EncVisCos,
+                               vllm_test::kH3EncVisCos + std::size(vllm_test::kH3EncVisCos));
+  const std::vector<float> sin(vllm_test::kH3EncVisSin,
+                               vllm_test::kH3EncVisSin + std::size(vllm_test::kH3EncVisSin));
+  std::vector<int32_t> cu;
+  for (size_t i = 0; i < std::size(vllm_test::kH3EncVisCuSeqlens); ++i) {
+    cu.push_back(static_cast<int32_t>(vllm_test::kH3EncVisCuSeqlens[i]));
+  }
+  // Two packed segments, so the varlen boundary is genuinely exercised.
+  REQUIRE(cu.size() == 3);
+
+  const std::vector<float> got = vllm::MiniMaxH3VisionBlockForward(
+      config, weights, "vb", hidden, seq, cos.data(), sin.data(), cu.data(),
+      static_cast<int64_t>(cu.size()) - 1);
+
+  REQUIRE(got.size() == std::size(vllm_test::kH3EncVisBlockGolden));
+  const double err = MaxAbsDiff(got, vllm_test::kH3EncVisBlockGolden, got.size());
+  INFO("vision block max|diff| = " << err);
+  CHECK(err <= 1e-5);
+
+  // Attention must NOT cross the packed-image boundary: perturbing a token in the
+  // SECOND segment must leave the FIRST segment's outputs untouched.
+  std::vector<float> perturbed = hidden;
+  perturbed[static_cast<size_t>(cu[1] * dim)] += 1.0f;
+  const std::vector<float> other = vllm::MiniMaxH3VisionBlockForward(
+      config, weights, "vb", perturbed, seq, cos.data(), sin.data(), cu.data(),
+      static_cast<int64_t>(cu.size()) - 1);
+  for (int64_t i = 0; i < cu[1] * dim; ++i) {
+    CHECK(other[static_cast<size_t>(i)] == got[static_cast<size_t>(i)]);
+  }
+  // ...and must actually change the segment it belongs to.
+  bool changed = false;
+  for (int64_t i = cu[1] * dim; i < seq * dim; ++i) {
+    if (other[static_cast<size_t>(i)] != got[static_cast<size_t>(i)]) changed = true;
+  }
+  CHECK(changed);
+}
+
+TEST_CASE("minimax_h3: the FULL encoder vision tower matches upstream") {
+  // Completes the encoder: patch embed -> bilinear-interpolated position embedding
+  // -> 2D rotary -> block stack -> DeepStack mergers + final patch merger.
+  vllm::MiniMaxH3VisionTowerConfig config;
+  config.block.hidden_size = vllm_test::kH3EncVisDim;
+  config.block.num_heads = vllm_test::kH3EncVisHeads;
+  config.block.intermediate_size = vllm_test::kH3EncVisIntermediate;
+  config.block.eps = 1e-6;
+  config.depth = vllm_test::kH3EncTowerDepth;
+  config.patch_size = vllm_test::kH3EncTowerPatch;
+  config.temporal_patch_size = vllm_test::kH3EncTowerTemporalPatch;
+  config.in_channels = vllm_test::kH3EncTowerInCh;
+  config.spatial_merge_size = vllm_test::kH3EncTowerMerge;
+  config.out_hidden_size = vllm_test::kH3EncTowerOutHidden;
+  config.num_position_embeddings = vllm_test::kH3EncTowerNumPos;
+  config.rope_theta = 10000.0;
+  for (size_t i = 0; i < std::size(vllm_test::kH3EncTowerDeepstackIdx); ++i) {
+    config.deepstack_visual_indexes.push_back(vllm_test::kH3EncTowerDeepstackIdx[i]);
+  }
+
+  const int64_t dim = config.block.hidden_size;
+  const int64_t merged_width = dim * config.spatial_merge_size * config.spatial_merge_size;
+  std::vector<int64_t> grid;
+  for (size_t i = 0; i < std::size(vllm_test::kH3EncTowerGridThw); ++i) {
+    grid.push_back(vllm_test::kH3EncTowerGridThw[i]);
+  }
+
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& n, int64_t count, double scale, double offset) {
+    weights.tensors[n] = MakeParam("encoder.tower." + n, count, scale, offset);
+  };
+  const int64_t patch_elems = config.in_channels * config.temporal_patch_size *
+                              config.patch_size * config.patch_size;
+  put("patch_embed.proj.weight", dim * patch_elems, 0.1, 0.0);
+  put("patch_embed.proj.bias", dim, 0.05, 0.0);
+  put("pos_embed.weight", config.num_position_embeddings * dim, 0.1, 0.0);
+  for (int64_t l = 0; l < config.depth; ++l) {
+    const std::string b = "blocks." + std::to_string(l) + ".";
+    put(b + "norm1.weight", dim, 0.1, 1.0);
+    put(b + "norm1.bias", dim, 0.05, 0.0);
+    put(b + "norm2.weight", dim, 0.1, 1.0);
+    put(b + "norm2.bias", dim, 0.05, 0.0);
+    put(b + "attn.qkv.weight", 3 * dim * dim, 0.1, 0.0);
+    put(b + "attn.qkv.bias", 3 * dim, 0.05, 0.0);
+    put(b + "attn.proj.weight", dim * dim, 0.1, 0.0);
+    put(b + "attn.proj.bias", dim, 0.05, 0.0);
+    put(b + "mlp.linear_fc1.weight", config.block.intermediate_size * dim, 0.1, 0.0);
+    put(b + "mlp.linear_fc1.bias", config.block.intermediate_size, 0.05, 0.0);
+    put(b + "mlp.linear_fc2.weight", dim * config.block.intermediate_size, 0.1, 0.0);
+    put(b + "mlp.linear_fc2.bias", dim, 0.05, 0.0);
+  }
+  // The final merger norms the PRE-shuffle width; the DeepStack mergers norm the
+  // POST-shuffle width. Getting these the wrong way round changes the result.
+  put("merger.norm.weight", dim, 0.1, 1.0);
+  put("merger.norm.bias", dim, 0.05, 0.0);
+  put("merger.linear_fc1.weight", merged_width * merged_width, 0.1, 0.0);
+  put("merger.linear_fc1.bias", merged_width, 0.05, 0.0);
+  put("merger.linear_fc2.weight", config.out_hidden_size * merged_width, 0.1, 0.0);
+  put("merger.linear_fc2.bias", config.out_hidden_size, 0.05, 0.0);
+  for (size_t d = 0; d < config.deepstack_visual_indexes.size(); ++d) {
+    const std::string m = "deepstack_merger_list." + std::to_string(d) + ".";
+    put(m + "norm.weight", merged_width, 0.1, 1.0);
+    put(m + "norm.bias", merged_width, 0.05, 0.0);
+    put(m + "linear_fc1.weight", merged_width * merged_width, 0.1, 0.0);
+    put(m + "linear_fc1.bias", merged_width, 0.05, 0.0);
+    put(m + "linear_fc2.weight", config.out_hidden_size * merged_width, 0.1, 0.0);
+    put(m + "linear_fc2.bias", config.out_hidden_size, 0.05, 0.0);
+  }
+
+  const std::vector<float> pixels =
+      MakeParam("encoder.tower.pixels", vllm_test::kH3EncTowerPatches * patch_elems, 1.0);
+  const vllm::MiniMaxH3VisionTowerResult got =
+      vllm::MiniMaxH3VisionTowerForward(config, weights, pixels, grid);
+
+  CHECK(static_cast<int64_t>(got.merged.size()) ==
+        vllm_test::kH3EncTowerMergedRows * config.out_hidden_size);
+  REQUIRE(got.merged.size() == std::size(vllm_test::kH3EncTowerMergedGolden));
+  const double err = MaxAbsDiff(got.merged, vllm_test::kH3EncTowerMergedGolden, got.merged.size());
+  INFO("vision tower merged max|diff| = " << err);
+  CHECK(err <= 1e-4);
+
+  CHECK(static_cast<int64_t>(got.deepstack.size()) == vllm_test::kH3EncTowerDeepstackCount);
+  std::vector<float> flat;
+  for (const std::vector<float>& d : got.deepstack) flat.insert(flat.end(), d.begin(), d.end());
+  REQUIRE(flat.size() == std::size(vllm_test::kH3EncTowerDeepstackGolden));
+  const double deep_err =
+      MaxAbsDiff(flat, vllm_test::kH3EncTowerDeepstackGolden, flat.size());
+  INFO("vision tower deepstack max|diff| = " << deep_err);
+  CHECK(deep_err <= 1e-4);
+
+  // Two images of DIFFERENT sizes were packed, so the position-embedding
+  // interpolation and the per-frame cu_seqlens both had to handle a ragged batch.
+  CHECK(grid.size() == 6);
+  CHECK(grid[1] != grid[4]);
+}
+
+TEST_CASE("minimax_h3: condition-noise augmentation matches upstream") {
+  // fl2va/ref2va pin their keyframe and reference-audio rows to a NOISED anchor.
+  // The mix is trivial; the ROW ACCOUNTING is what this gates -- and the golden
+  // feeds our side the SAME noise upstream drew, so the comparison isolates the
+  // accounting from torch's RNG (which the pipeline also takes as an input).
+  std::vector<int64_t> shapes;
+  for (size_t i = 0; i < std::size(vllm_test::kH3CondShapes); ++i) {
+    shapes.push_back(vllm_test::kH3CondShapes[i]);
+  }
+  const std::vector<float> clean =
+      MakeParam("cond.clean_video", vllm_test::kH3CondRows * 96, 1.0);
+  const std::vector<float> noise(vllm_test::kH3CondNoiseRows,
+                                 vllm_test::kH3CondNoiseRows + std::size(vllm_test::kH3CondNoiseRows));
+  const std::vector<float> got = vllm::MiniMaxH3ImgvidCondNoiseAug(
+      clean, shapes, vllm_test::kH3CondTargetLatentT, vllm_test::kH3CondImgvidFrames,
+      vllm_test::kH3CondNoiseAug[0], noise);
+  REQUIRE(got.size() == std::size(vllm_test::kH3CondGolden));
+  CHECK(MaxAbsDiff(got, vllm_test::kH3CondGolden, got.size()) <= 1e-6);
+
+  std::vector<int64_t> audio_t;
+  for (size_t i = 0; i < std::size(vllm_test::kH3CondAudioT); ++i) {
+    audio_t.push_back(vllm_test::kH3CondAudioT[i]);
+  }
+  const std::vector<float> clean_audio =
+      MakeParam("cond.clean_audio", vllm_test::kH3CondAudioRows * 32, 1.0);
+  const std::vector<float> audio_noise(
+      vllm_test::kH3CondAudioNoiseRows,
+      vllm_test::kH3CondAudioNoiseRows + std::size(vllm_test::kH3CondAudioNoiseRows));
+  const std::vector<float> got_audio = vllm::MiniMaxH3AudioCondNoiseAug(
+      clean_audio, audio_t, vllm_test::kH3CondNoiseAug[0], audio_noise);
+  REQUIRE(got_audio.size() == std::size(vllm_test::kH3CondAudioGolden));
+  CHECK(MaxAbsDiff(got_audio, vllm_test::kH3CondAudioGolden, got_audio.size()) <= 1e-6);
+
+  // noise_aug == 1.0 is the documented identity (the anchor IS the clean latent).
+  const std::vector<float> identity =
+      vllm::MiniMaxH3ImgvidCondNoiseAug(clean, shapes, vllm_test::kH3CondTargetLatentT,
+                                        vllm_test::kH3CondImgvidFrames, 1.0, noise);
+  for (size_t i = 0; i < identity.size(); ++i) CHECK(identity[i] == clean[i]);
+
+  // Shape/row-count disagreements must throw, not silently mis-slice.
+  CHECK_THROWS(vllm::MiniMaxH3ImgvidCondNoiseAug(clean, {1, 3, 6}, 3, 1, 0.999, noise));
+  CHECK_THROWS(vllm::MiniMaxH3ImgvidCondNoiseAug(clean, shapes, 3, 1, 1.5, noise));
+  CHECK_THROWS(vllm::MiniMaxH3AudioCondNoiseAug(clean_audio, {}, 0.999, audio_noise));
+}
+
+TEST_CASE("minimax_h3: reference-video geometry and frame schedule match upstream") {
+  // The PURE-MATH half of reference_video.py. The rest of that module (probe,
+  // transcode, frame extraction, audio decode) shells out to ffmpeg and is blocked
+  // on the same dependency decision as MP4 muxing -- one decision unlocks both
+  // reference-video INPUT decode and generated-video OUTPUT encode.
+  for (int64_t c = 0; c < vllm_test::kH3RefVidShapeCases; ++c) {
+    const std::pair<int64_t, int64_t> got = vllm::MiniMaxH3ReferenceVideoShape(
+        vllm_test::kH3RefVidShapeInputs[c * 2], vllm_test::kH3RefVidShapeInputs[c * 2 + 1]);
+    INFO("shape case " << c);
+    CHECK(got.first == vllm_test::kH3RefVidShapeGolden[c * 2]);
+    CHECK(got.second == vllm_test::kH3RefVidShapeGolden[c * 2 + 1]);
+    // Every canvas must land on the 32 grid.
+    CHECK(got.first % 32 == 0);
+    CHECK(got.second % 32 == 0);
+    // The pixel budget is applied BEFORE the snap to 32, so the snapped canvas
+    // may exceed it slightly -- upstream does not re-check after rounding. Assert
+    // the real invariant (within one grid step on each axis) rather than a
+    // stricter one the reference does not hold to.
+    const int64_t slack = (got.first + 32) * (got.second + 32);
+    CHECK(got.first * got.second <= slack);
+    CHECK(got.first * got.second <=
+          vllm::kMiniMaxH3RefVideoMaxPixels + 32 * (got.first + got.second) + 32 * 32);
+  }
+  // Out-of-range aspect ratios are rejected, not clamped.
+  CHECK_THROWS(vllm::MiniMaxH3ReferenceVideoShape(5000, 100));
+
+  int64_t idx_offset = 0, blk_offset = 0;
+  for (int64_t c = 0; c < vllm_test::kH3RefVidFrameCases; ++c) {
+    const vllm::MiniMaxH3ReferenceVideoSchedule got =
+        vllm::MiniMaxH3ReferenceVideoFrameSchedule(vllm_test::kH3RefVidFrameCounts[c]);
+    INFO("frame case " << c << " count=" << vllm_test::kH3RefVidFrameCounts[c]);
+    REQUIRE(static_cast<int64_t>(got.indices.size()) == vllm_test::kH3RefVidIndexLens[c]);
+    for (size_t i = 0; i < got.indices.size(); ++i) {
+      CHECK(got.indices[i] == vllm_test::kH3RefVidIndicesGolden[idx_offset + i]);
+    }
+    REQUIRE(static_cast<int64_t>(got.block_timestamps.size()) == vllm_test::kH3RefVidBlockLens[c]);
+    for (size_t i = 0; i < got.block_timestamps.size(); ++i) {
+      CHECK(got.block_timestamps[i] ==
+            doctest::Approx(vllm_test::kH3RefVidBlockTimestamps[blk_offset + i]).epsilon(1e-9));
+    }
+    // Indices must be strictly increasing and inside the clip.
+    for (size_t i = 1; i < got.indices.size(); ++i) CHECK(got.indices[i] > got.indices[i - 1]);
+    CHECK(got.indices.back() < vllm_test::kH3RefVidFrameCounts[c]);
+    idx_offset += static_cast<int64_t>(got.indices.size());
+    blk_offset += static_cast<int64_t>(got.block_timestamps.size());
+  }
+  CHECK_THROWS(vllm::MiniMaxH3ReferenceVideoFrameSchedule(0));
+}
+
+TEST_CASE("minimax_h3: video VAE tiling plan and seam blend match upstream") {
+  // The tile plan is not a simple stride: it picks the smallest tile count whose
+  // MINIMUM overlaps still cover the input, then distributes the leftover slack in
+  // whole vae_ratio units ROUND-ROBIN across the seams. Getting that wrong shifts
+  // every tile after the first and shows up as seam artifacts, not as an error.
+  int64_t s_off = 0, l_off = 0, o_off = 0;
+  for (int64_t c = 0; c < vllm_test::kH3TileCases; ++c) {
+    const int64_t input_len = vllm_test::kH3TileInputs[c * 3 + 0];
+    const int64_t tile_size = vllm_test::kH3TileInputs[c * 3 + 1];
+    const int64_t overlap_min = vllm_test::kH3TileInputs[c * 3 + 2];
+    const vllm::MiniMaxH3TilePlan got =
+        vllm::MiniMaxH3SplitTiles(input_len, tile_size, overlap_min, vllm_test::kH3TileVaeRatio);
+    INFO("tile case " << c << " len=" << input_len << " tile=" << tile_size);
+    REQUIRE(static_cast<int64_t>(got.starts.size()) == vllm_test::kH3TileCounts[c]);
+    for (size_t i = 0; i < got.starts.size(); ++i) {
+      CHECK(got.starts[i] == vllm_test::kH3TileStarts[s_off + i]);
+      CHECK(got.lengths[i] == vllm_test::kH3TileLens[l_off + i]);
+    }
+    for (size_t i = 0; i < got.overlaps.size(); ++i) {
+      CHECK(got.overlaps[i] == vllm_test::kH3TileOverlaps[o_off + i]);
+    }
+    // Structural invariants the plan must satisfy for tiling to be lossless:
+    // tiles cover the whole axis, and every seam overlaps by at least the minimum.
+    CHECK(got.starts.front() == 0);
+    CHECK(got.starts.back() + got.lengths.back() >= input_len);
+    for (size_t i = 0; i < got.overlaps.size(); ++i) {
+      CHECK(got.overlaps[i] >= overlap_min);
+      CHECK(got.overlaps[i] % vllm_test::kH3TileVaeRatio == overlap_min % vllm_test::kH3TileVaeRatio);
+    }
+    s_off += static_cast<int64_t>(got.starts.size());
+    l_off += static_cast<int64_t>(got.lengths.size());
+    o_off += static_cast<int64_t>(got.starts.size()) - 1;
+  }
+
+  // A tile larger than the input is a single untiled pass with no seams.
+  const vllm::MiniMaxH3TilePlan single = vllm::MiniMaxH3SplitTiles(100, 256, 64, 16);
+  CHECK(single.starts.size() == 1);
+  CHECK(single.lengths[0] == 100);
+  CHECK(single.overlaps.empty());
+
+  // The seam cross-fade.
+  const std::vector<float> a = MakeParam("tiling.a", vllm_test::kH3TileBlendLen, 1.0);
+  const std::vector<float> b = MakeParam("tiling.b", vllm_test::kH3TileBlendLen, 1.0);
+  const std::vector<float> blended =
+      vllm::MiniMaxH3BlendTiles(a, b, vllm_test::kH3TileBlendExtent);
+  REQUIRE(blended.size() == std::size(vllm_test::kH3TileBlendGolden));
+  CHECK(MaxAbsDiff(blended, vllm_test::kH3TileBlendGolden, blended.size()) <= 1e-6);
+  // The fade starts fully on `a` and ends fully on `b`.
+  CHECK(blended.front() == doctest::Approx(a[a.size() - vllm_test::kH3TileBlendExtent]));
+  CHECK(blended[static_cast<size_t>(vllm_test::kH3TileBlendExtent)] ==
+        doctest::Approx(b[static_cast<size_t>(vllm_test::kH3TileBlendExtent)]));
+}
+
+TEST_CASE("minimax_h3: presentation token tags match upstream") {
+  // The fl2va "vision-span override" the denoise loop requires callers to have
+  // applied. The load-bearing detail: a vision block is
+  // <|vision_start|> + pad*count + <|vision_end|>, and the WHOLE block -- markers
+  // included -- is tagged VIDEO. Tagging only the pads leaves two markers as TEXT
+  // and shifts every AdaLN modulation index after them.
+  std::vector<vllm::MiniMaxH3PresentationSpan> spans;
+  for (int64_t i = 0; i < vllm_test::kH3PresSpanCount; ++i) {
+    vllm::MiniMaxH3PresentationSpan span;
+    span.kind = vllm_test::kH3PresSpanKinds[i] == 0
+                    ? vllm::MiniMaxH3PresentationSpan::Kind::kVision
+                    : vllm::MiniMaxH3PresentationSpan::Kind::kText;
+    span.length = vllm_test::kH3PresSpanLens[i];
+    spans.push_back(span);
+  }
+
+  const std::vector<int64_t> tags = vllm::MiniMaxH3BuildPresentationTokenTags(spans);
+  REQUIRE(static_cast<int64_t>(tags.size()) == vllm_test::kH3PresTagCount);
+  REQUIRE(tags.size() == std::size(vllm_test::kH3PresTagsGolden));
+  for (size_t i = 0; i < tags.size(); ++i) CHECK(tags[i] == vllm_test::kH3PresTagsGolden[i]);
+
+  // The tags must only ever be TEXT or VIDEO -- never the audio or padding tags.
+  for (int64_t tag : tags) {
+    CHECK((tag == vllm::kMiniMaxH3TagText || tag == vllm::kMiniMaxH3TagVideo));
+  }
+
+  // A vision block is pad_count + 2 tokens (the two markers).
+  CHECK(vllm::MiniMaxH3VisionBlockTokenLength(3) == 5);
+  CHECK(vllm::MiniMaxH3VisionBlockTokenLength(1) == 3);
+  CHECK_THROWS(vllm::MiniMaxH3VisionBlockTokenLength(0));
+  CHECK_THROWS(vllm::MiniMaxH3BuildPresentationTokenTags({}));
+
+  // Every VIDEO run must be a whole vision block, i.e. its length must equal one
+  // of the emitted vision spans -- proving the markers were tagged with the pads.
+  std::vector<int64_t> video_runs;
+  for (size_t i = 0; i < tags.size();) {
+    if (tags[i] != vllm::kMiniMaxH3TagVideo) {
+      ++i;
+      continue;
+    }
+    size_t j = i;
+    while (j < tags.size() && tags[j] == vllm::kMiniMaxH3TagVideo) ++j;
+    video_runs.push_back(static_cast<int64_t>(j - i));
+    i = j;
+  }
+  std::vector<int64_t> vision_spans;
+  for (const vllm::MiniMaxH3PresentationSpan& span : spans) {
+    if (span.kind == vllm::MiniMaxH3PresentationSpan::Kind::kVision) {
+      vision_spans.push_back(span.length);
+    }
+  }
+  CHECK(video_runs == vision_spans);
+}
+
+TEST_CASE("minimax_h3: the VAE encoder ResnetBlock3D matches upstream") {
+  // The repeated unit of the video VAE's 3D-CNN ENCODER (used for image/video
+  // CONDITIONING, not for output frames). Two details are load-bearing and both
+  // are exercised: the convolution is CAUSAL in time (all padding on the LEFT, so
+  // a frame never sees the future), and GroupNorm's statistics span TIME as well
+  // as space.
+  vllm::MiniMaxH3ResnetBlock3dConfig config;
+  config.in_channels = vllm_test::kH3Res3dInCh;
+  config.out_channels = vllm_test::kH3Res3dOutCh;
+  config.t = vllm_test::kH3Res3dT;
+  config.h = vllm_test::kH3Res3dH;
+  config.w = vllm_test::kH3Res3dW;
+  config.num_groups = vllm_test::kH3Res3dGroups;
+  config.eps = 1e-6;
+
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& n, int64_t count, double scale, double offset) {
+    weights.tensors["rb." + n] = MakeParam("resnet3d." + n, count, scale, offset);
+  };
+  put("norm1.weight", config.in_channels, 0.1, 1.0);
+  put("norm1.bias", config.in_channels, 0.05, 0.0);
+  put("norm2.weight", config.out_channels, 0.1, 1.0);
+  put("norm2.bias", config.out_channels, 0.05, 0.0);
+  put("conv1.weight", config.out_channels * config.in_channels * 27, 0.1, 0.0);
+  put("conv1.bias", config.out_channels, 0.05, 0.0);
+  put("conv2.weight", config.out_channels * config.out_channels * 27, 0.1, 0.0);
+  put("conv2.bias", config.out_channels, 0.05, 0.0);
+  put("nin_shortcut.weight", config.out_channels * config.in_channels, 0.1, 0.0);
+  put("nin_shortcut.bias", config.out_channels, 0.05, 0.0);
+
+  const int64_t spatial = config.t * config.h * config.w;
+  const std::vector<float> x =
+      MakeParam("resnet3d.input", config.in_channels * spatial, 1.0);
+  const std::vector<float> got =
+      vllm::MiniMaxH3ResnetBlock3dForward(config, weights, "rb", x);
+
+  REQUIRE(got.size() == std::size(vllm_test::kH3Res3dGolden));
+  const double err = MaxAbsDiff(got, vllm_test::kH3Res3dGolden, got.size());
+  INFO("resnet3d max|diff| = " << err);
+  CHECK(err <= 1e-4);
+
+  // CAUSALITY, proven rather than assumed: perturbing the LAST frame must leave
+  // the FIRST frame's output bit-identical, while the last frame's own output
+  // changes. A non-causal (symmetric) temporal pad would break the first check.
+  std::vector<float> perturbed = x;
+  for (int64_t c = 0; c < config.in_channels; ++c) {
+    perturbed[static_cast<size_t>(c * spatial + (config.t - 1) * config.h * config.w)] += 5.0f;
+  }
+  const std::vector<float> other =
+      vllm::MiniMaxH3ResnetBlock3dForward(config, weights, "rb", perturbed);
+  // GroupNorm's statistics span time, so a change anywhere perturbs every frame
+  // a little -- an exact-equality check on the whole BLOCK would be wrong. Here
+  // the weaker (but still meaningful) claim is asserted: the perturbed frame moves
+  // strictly more than the first. Strict causality is then proven on the bare
+  // CONVOLUTION below, where no norm mixes the frames.
+  double first_delta = 0.0, last_delta = 0.0;
+  const int64_t frame = config.h * config.w;
+  for (int64_t c = 0; c < config.out_channels; ++c) {
+    for (int64_t i = 0; i < frame; ++i) {
+      first_delta = std::max(first_delta,
+                             std::abs(static_cast<double>(other[static_cast<size_t>(c * spatial + i)]) -
+                                      got[static_cast<size_t>(c * spatial + i)]));
+      const size_t last = static_cast<size_t>(c * spatial + (config.t - 1) * frame + i);
+      last_delta = std::max(last_delta,
+                            std::abs(static_cast<double>(other[last]) - got[last]));
+    }
+  }
+  CHECK(last_delta > first_delta);
+
+  // The causal convolution alone: with norms bypassed, a future-frame change must
+  // NOT reach an earlier frame at all.
+  vllm::MiniMaxH3Conv3dSpec spec;
+  spec.in_channels = spec.out_channels = 1;
+  spec.t = 3;
+  spec.h = spec.w = 1;
+  spec.kernel_t = 3;
+  spec.kernel_h = spec.kernel_w = 1;
+  spec.pad_t = 1;
+  spec.pad_h = spec.pad_w = 0;
+  spec.causal = true;
+  const std::vector<float> kernel = {1.0f, 2.0f, 4.0f};
+  const std::vector<float> a = {1.0f, 0.0f, 0.0f};
+  const std::vector<float> b = {1.0f, 0.0f, 9.0f};  // only the LAST frame differs
+  const std::vector<float> ca = vllm::MiniMaxH3CausalConv3d(a, spec, kernel, nullptr);
+  const std::vector<float> cb = vllm::MiniMaxH3CausalConv3d(b, spec, kernel, nullptr);
+  REQUIRE(ca.size() == cb.size());
+  CHECK(ca[0] == cb[0]);   // frame 0 cannot see frame 2
+  CHECK(ca[1] == cb[1]);   // frame 1 cannot see frame 2
+  CHECK(ca[2] != cb[2]);   // frame 2 does
+}
+
+TEST_CASE("minimax_h3: the VAE encoder Downsample3D matches upstream") {
+  // The strided conv between encoder levels. Its subtlety is the ASYMMETRIC
+  // pre-pad: one pixel on the RIGHT of W and the BOTTOM of H before a stride-2
+  // conv with padding (1, 0, 0). Padding symmetrically instead shifts the whole
+  // sampling lattice by half a pixel -- no error, just a subtly wrong latent.
+  vllm::MiniMaxH3Downsample3dConfig config;
+  config.in_channels = vllm_test::kH3Down3dInCh;
+  config.out_channels = vllm_test::kH3Down3dOutCh;
+  config.t = vllm_test::kH3Down3dT;
+  config.h = vllm_test::kH3Down3dH;
+  config.w = vllm_test::kH3Down3dW;
+  config.time_stride = 2;
+  config.space_stride = 2;
+
+  const std::vector<float> weight =
+      MakeParam("down3d.conv.weight", config.out_channels * config.in_channels * 27, 0.1);
+  const std::vector<float> bias = MakeParam("down3d.conv.bias", config.out_channels, 0.05);
+  const std::vector<float> x = MakeParam(
+      "down3d.input", config.in_channels * config.t * config.h * config.w, 1.0);
+
+  const std::vector<float> got = vllm::MiniMaxH3Downsample3d(x, config, weight, bias);
+
+  const int64_t expected = config.out_channels * vllm_test::kH3Down3dOutT *
+                           vllm_test::kH3Down3dOutH * vllm_test::kH3Down3dOutW;
+  CHECK(static_cast<int64_t>(got.size()) == expected);
+  REQUIRE(got.size() == std::size(vllm_test::kH3Down3dGolden));
+  const double err = MaxAbsDiff(got, vllm_test::kH3Down3dGolden, got.size());
+  INFO("downsample3d max|diff| = " << err);
+  CHECK(err <= 1e-4);
+
+  // Strides genuinely halve each axis (T 3->2 under the causal pad, H/W 4->2).
+  CHECK(vllm_test::kH3Down3dOutH == config.h / 2);
+  CHECK(vllm_test::kH3Down3dOutW == config.w / 2);
+}
+
+TEST_CASE("minimax_h3: the whole VAE 3D-CNN encoder matches upstream") {
+  // Completes the video VAE: conv_in -> per level [ResnetBlock3D x N, then a
+  // Downsample3D or a 1x1x1 channel match] -> GroupNorm -> SiLU -> conv_out.
+  // Conditioning-only -- a t2va generation path never calls this.
+  vllm::MiniMaxH3EncoderFcn3dConfig config;
+  config.ch = vllm_test::kH3EncFcnCh;
+  config.ch_mult.assign(vllm_test::kH3EncFcnChMult,
+                        vllm_test::kH3EncFcnChMult + vllm_test::kH3EncFcnLevels);
+  config.space_down.assign(vllm_test::kH3EncFcnSpaceDown,
+                           vllm_test::kH3EncFcnSpaceDown + vllm_test::kH3EncFcnLevels);
+  config.time_down.assign(vllm_test::kH3EncFcnTimeDown,
+                          vllm_test::kH3EncFcnTimeDown + vllm_test::kH3EncFcnLevels);
+  config.num_res_blocks = vllm_test::kH3EncFcnResBlocks;
+  config.in_channels = vllm_test::kH3EncFcnInCh;
+  config.z_channels = vllm_test::kH3EncFcnZCh;
+  config.t = vllm_test::kH3EncFcnT;
+  config.h = vllm_test::kH3EncFcnH;
+  config.w = vllm_test::kH3EncFcnW;
+  config.num_groups = 32;
+  config.eps = 1e-6;
+
+  vllm::MiniMaxH3AudioVaeWeights weights;
+  auto put = [&](const std::string& n, int64_t count, double scale, double offset) {
+    weights.tensors[n] = MakeParam("encfcn." + n, count, scale, offset);
+  };
+
+  const int64_t levels = vllm_test::kH3EncFcnLevels;
+  std::vector<int64_t> block_mid(static_cast<size_t>(levels));
+  for (int64_t i = 0; i < levels; ++i) block_mid[i] = config.ch * config.ch_mult[i];
+  std::vector<int64_t> block_in(static_cast<size_t>(levels));
+  block_in[0] = block_mid[0];
+  for (int64_t i = 1; i < levels; ++i) block_in[i] = block_mid[i - 1];
+
+  put("conv_in.weight", block_in[0] * config.in_channels * 27, 0.1, 0.0);
+  put("conv_in.bias", block_in[0], 0.05, 0.0);
+  for (int64_t l = 0; l < levels; ++l) {
+    for (int64_t b = 0; b < config.num_res_blocks; ++b) {
+      const std::string prefix = "down." + std::to_string(l) + ".block." + std::to_string(b);
+      const int64_t ci = (b == 0) ? block_in[l] : block_mid[l];
+      const int64_t co = block_mid[l];
+      put(prefix + ".norm1.weight", ci, 0.1, 1.0);
+      put(prefix + ".norm1.bias", ci, 0.05, 0.0);
+      put(prefix + ".norm2.weight", co, 0.1, 1.0);
+      put(prefix + ".norm2.bias", co, 0.05, 0.0);
+      put(prefix + ".conv1.weight", co * ci * 27, 0.1, 0.0);
+      put(prefix + ".conv1.bias", co, 0.05, 0.0);
+      put(prefix + ".conv2.weight", co * co * 27, 0.1, 0.0);
+      put(prefix + ".conv2.bias", co, 0.05, 0.0);
+      if (ci != co) {
+        put(prefix + ".nin_shortcut.weight", co * ci, 0.1, 0.0);
+        put(prefix + ".nin_shortcut.bias", co, 0.05, 0.0);
+      }
+    }
+    const std::string ds = "down." + std::to_string(l) + ".downsample";
+    if (config.space_down[l] * config.time_down[l] > 1) {
+      put(ds + ".conv.weight", block_mid[l] * block_mid[l] * 27, 0.1, 0.0);
+      put(ds + ".conv.bias", block_mid[l], 0.05, 0.0);
+    }
+  }
+  const int64_t last = block_mid[levels - 1];
+  put("norm_out.weight", last, 0.1, 1.0);
+  put("norm_out.bias", last, 0.05, 0.0);
+  put("conv_out.weight", config.z_channels * last * 27, 0.1, 0.0);
+  put("conv_out.bias", config.z_channels, 0.05, 0.0);
+
+  const std::vector<float> x = MakeParam(
+      "encfcn.input", config.in_channels * config.t * config.h * config.w, 1.0);
+  vllm::MiniMaxH3VideoFrameShape shape;
+  const std::vector<float> got =
+      vllm::MiniMaxH3EncoderFcn3dForward(config, weights, x, &shape);
+
+  CHECK(shape.channels == config.z_channels);
+  CHECK(shape.t == vllm_test::kH3EncFcnOutT);
+  CHECK(shape.h == vllm_test::kH3EncFcnOutH);
+  CHECK(shape.w == vllm_test::kH3EncFcnOutW);
+  REQUIRE(got.size() == std::size(vllm_test::kH3EncFcnGolden));
+  const double err = MaxAbsDiff(got, vllm_test::kH3EncFcnGolden, got.size());
+  INFO("encoder fcn3d max|diff| = " << err);
+  CHECK(err <= 1e-4);
+}
+
+TEST_CASE("minimax_h3: the MM processor is Qwen3-VL reuse, with H3's own config") {
+  // H3's FL2VA/processor is a stock Qwen3VLProcessor, so the MM front end is REUSE
+  // of this project's existing Qwen3-VL processor rather than a new port. What
+  // needed proving is that H3's ACTUAL config parses and drives it correctly --
+  // including the video bounds, which differ from the image ones.
+  const std::string preproc = R"({
+    "size": {"longest_edge": 16777216, "shortest_edge": 65536},
+    "patch_size": 16, "temporal_patch_size": 2, "merge_size": 2,
+    "image_mean": [0.5, 0.5, 0.5], "image_std": [0.5, 0.5, 0.5],
+    "processor_class": "Qwen3VLProcessor",
+    "image_processor_type": "Qwen2VLImageProcessorFast"
+  })";
+  const std::string cfg = R"({
+    "image_token_id": 151655, "vision_start_token_id": 151652,
+    "vision_end_token_id": 151653
+  })";
+  const std::string preproc_path = "/tmp/minimax_h3_preproc.json";
+  const std::string cfg_path = "/tmp/minimax_h3_cfg.json";
+  for (const auto& entry : {std::make_pair(preproc_path, preproc), std::make_pair(cfg_path, cfg)}) {
+    FILE* fh = std::fopen(entry.first.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    std::fwrite(entry.second.data(), 1, entry.second.size(), fh);
+    std::fclose(fh);
+  }
+
+  const vllm::multimodal::Qwen3VLProcessorConfig config =
+      vllm::multimodal::LoadQwen3VLProcessorConfig(preproc_path, cfg_path, "MiniMaxAI/MiniMax-H3");
+  CHECK(config.patch_size == 16);
+  CHECK(config.temporal_patch_size == 2);
+  CHECK(config.merge_size == 2);
+  // H3 normalizes to [-1, 1] with mean/std 0.5 -- NOT the usual CLIP statistics.
+  CHECK(config.image_mean == doctest::Approx(0.5));
+  CHECK(config.image_std == doctest::Approx(0.5));
+  CHECK(config.min_pixels == 65536);
+  CHECK(config.max_pixels == 16777216);
+
+  // The vision tower consumes patches on a `patch_size * merge_size` grid.
+  const int64_t factor = config.patch_size * config.merge_size;
+  CHECK(factor == 32);
+
+  // A 768x1344 canvas (H3's default) already sits on the 32 grid and inside the
+  // budget, so smart_resize must be the IDENTITY -- resizing it would silently
+  // change the conditioning image.
+  const std::array<int64_t, 2> keep =
+      vllm::multimodal::SmartResize(768, 1344, factor, config.min_pixels, config.max_pixels);
+  CHECK(keep[0] == 768);
+  CHECK(keep[1] == 1344);
+
+  // Off-grid inputs snap to the grid and stay inside the pixel budget.
+  for (const auto& wh : {std::make_pair<int64_t, int64_t>(1000, 700),
+                         std::make_pair<int64_t, int64_t>(33, 4000),
+                         std::make_pair<int64_t, int64_t>(4000, 33)}) {
+    const std::array<int64_t, 2> got =
+        vllm::multimodal::SmartResize(wh.first, wh.second, factor, config.min_pixels, config.max_pixels);
+    INFO("smart_resize " << wh.first << "x" << wh.second);
+    CHECK(got[0] % factor == 0);
+    CHECK(got[1] % factor == 0);
+    CHECK(got[0] > 0);
+    CHECK(got[1] > 0);
+  }
+
+  // H3's VIDEO bounds differ from its image bounds (shortest 4096, longest
+  // 25165824) and the video budget includes the TEMPORAL extent.
+  const int64_t video_min = 4096, video_max = 25165824;
+  const std::array<int64_t, 2> video = vllm::multimodal::VideoSmartResize(
+      /*num_frames=*/8, 768, 1344, config.temporal_patch_size, factor, video_min, video_max);
+  CHECK(video[0] % factor == 0);
+  CHECK(video[1] % factor == 0);
+  CHECK(video_min < config.min_pixels);   // video floor is LOWER than the image one
+  CHECK(video_max > config.max_pixels);   // and its ceiling HIGHER
+
+  std::remove(preproc_path.c_str());
+  std::remove(cfg_path.c_str());
+}
+
+TEST_CASE("minimax_h3: the decoded waveform serializes to a valid WAV") {
+  // Dependency-free audio output. The container question for /v1/videos (MP4, and
+  // how to get a muxer) is still open; WAV needs none of it and is required under
+  // either outcome.
+  const int64_t channels = 2, samples = 5, rate = vllm::kMiniMaxH3AudioSampleRate;
+  // CHANNEL-MAJOR, as the VAE emits: all of channel 0, then all of channel 1.
+  const std::vector<float> waveform = {0.0f,  0.5f,  -0.5f, 1.0f,  -1.0f,
+                                       0.25f, -0.25f, 0.75f, -0.75f, 0.125f};
+  const std::string wav = vllm::MiniMaxH3WriteWav(waveform, channels, samples, rate);
+
+  REQUIRE(wav.size() == 44u + static_cast<size_t>(channels * samples * 2));
+  CHECK(wav.compare(0, 4, "RIFF") == 0);
+  CHECK(wav.compare(8, 4, "WAVE") == 0);
+  CHECK(wav.compare(12, 4, "fmt ") == 0);
+  CHECK(wav.compare(36, 4, "data") == 0);
+
+  auto u16 = [&](size_t off) {
+    return static_cast<uint16_t>(static_cast<uint8_t>(wav[off]) |
+                                 (static_cast<uint8_t>(wav[off + 1]) << 8));
+  };
+  auto u32 = [&](size_t off) {
+    uint32_t v = 0;
+    for (int i = 0; i < 4; ++i) v |= static_cast<uint32_t>(static_cast<uint8_t>(wav[off + i])) << (8 * i);
+    return v;
+  };
+  CHECK(u32(4) == 36u + static_cast<uint32_t>(channels * samples * 2));
+  CHECK(u32(16) == 16u);                       // PCM fmt chunk
+  CHECK(u16(20) == 1u);                        // format = PCM
+  CHECK(u16(22) == channels);
+  CHECK(u32(24) == static_cast<uint32_t>(rate));
+  CHECK(u32(28) == static_cast<uint32_t>(rate * channels * 2));  // byte rate
+  CHECK(u16(32) == channels * 2);              // block align
+  CHECK(u16(34) == 16u);                       // bits per sample
+  CHECK(u32(40) == static_cast<uint32_t>(channels * samples * 2));
+
+  // INTERLEAVE: sample s of channel c must sit at frame s, slot c -- getting this
+  // backwards yields audio that plays but with the channels time-smeared.
+  auto sample_at = [&](int64_t frame, int64_t ch) {
+    const size_t off = 44 + static_cast<size_t>((frame * channels + ch) * 2);
+    return static_cast<int16_t>(u16(off));
+  };
+  for (int64_t s2 = 0; s2 < samples; ++s2) {
+    for (int64_t c = 0; c < channels; ++c) {
+      const float want = waveform[static_cast<size_t>(c * samples + s2)];
+      const int16_t got = sample_at(s2, c);
+      CHECK(got == static_cast<int16_t>(std::lround(want * 32767.0f)));
+    }
+  }
+  // Full-scale maps to the extremes without wrapping.
+  CHECK(sample_at(3, 0) == 32767);
+  CHECK(sample_at(4, 0) == -32767);
+
+  // Out-of-range input is clamped, not wrapped.
+  const std::vector<float> hot = {2.0f, -2.0f};
+  const std::string clamped = vllm::MiniMaxH3WriteWav(hot, 1, 2, rate);
+  auto hot_at = [&](size_t i) {
+    const size_t off = 44 + i * 2;
+    return static_cast<int16_t>(static_cast<uint8_t>(clamped[off]) |
+                                (static_cast<uint8_t>(clamped[off + 1]) << 8));
+  };
+  CHECK(hot_at(0) == 32767);
+  CHECK(hot_at(1) == -32767);
+
+  CHECK_THROWS(vllm::MiniMaxH3WriteWav(waveform, 3, samples, rate));  // size mismatch
+}
+
+TEST_CASE("minimax_h3: a reference WAV reads back channel-major, and refuses what it cannot fix") {
+  // The reader exists for REFERENCE AUDIO: ref2va conditions on a supplied
+  // waveform. It is gated against the writer it inverts, because a de-interleave
+  // that is backwards produces audio that still plays -- just with the channels
+  // time-smeared into each other, which no shape check catches.
+  const int64_t rate = vllm::kMiniMaxH3AudioSampleRate;
+  const int64_t samples = 9;
+  std::vector<float> stereo(static_cast<size_t>(2 * samples));
+  for (int64_t t = 0; t < samples; ++t) {
+    stereo[static_cast<size_t>(t)] = 0.1f * static_cast<float>(t);              // channel 0
+    stereo[static_cast<size_t>(samples + t)] = -0.05f * static_cast<float>(t);  // channel 1
+  }
+  const std::string wav = vllm::MiniMaxH3WriteWav(stereo, 2, samples, rate);
+
+  int64_t got = 0;
+  const std::vector<float> back = vllm::MiniMaxH3ReadWav(wav, 2, rate, &got);
+  CHECK(got == samples);
+  REQUIRE(back.size() == stereo.size());
+  // 16-bit PCM: one quantization step is 1/32768, so the round trip is exact to
+  // within half a step.
+  const double err = MaxAbsDiff(back, stereo.data(), stereo.size());
+  INFO("WAV round-trip max|diff| = " << err);
+  CHECK(err <= 1.0 / 32768.0);
+  // Channel-major really is channel-major: channel 1 must be the DESCENDING ramp.
+  CHECK(back[static_cast<size_t>(samples + 1)] < 0.0f);
+  CHECK(back[1] > 0.0f);
+
+  // A MONO file is REPEATED up to the model's channel count (vae.py:305-313), so
+  // a mono reference conditions both channels rather than silencing one.
+  const std::vector<float> mono(stereo.begin(), stereo.begin() + samples);
+  const std::string mono_wav = vllm::MiniMaxH3WriteWav(mono, 1, samples, rate);
+  int64_t mono_got = 0;
+  const std::vector<float> widened =
+      vllm::MiniMaxH3ReadWav(mono_wav, vllm::kMiniMaxH3AudioChannels, rate, &mono_got);
+  CHECK(mono_got == samples);
+  REQUIRE(widened.size() == static_cast<size_t>(vllm::kMiniMaxH3AudioChannels * samples));
+  for (int64_t t = 0; t < samples; ++t) {
+    CHECK(widened[static_cast<size_t>(t)] == widened[static_cast<size_t>(samples + t)]);
+  }
+
+  // A rate the VAE was not trained at is REFUSED, not resampled: encoding a
+  // 44.1 kHz file as 32 kHz would shift every latent frame, and there is no audio
+  // dependency here to resample with.
+  const std::string wrong_rate = vllm::MiniMaxH3WriteWav(stereo, 2, samples, 44100);
+  CHECK_THROWS(vllm::MiniMaxH3ReadWav(wrong_rate, 2, rate, nullptr));
+  CHECK_NOTHROW(vllm::MiniMaxH3ReadWav(wrong_rate, 2, /*want_sample_rate=*/0, nullptr));
+
+  // And malformed input is refused rather than read as audio.
+  CHECK_THROWS(vllm::MiniMaxH3ReadWav("not a wav at all", 2, rate, nullptr));
+  std::string truncated = wav.substr(0, 40);
+  CHECK_THROWS(vllm::MiniMaxH3ReadWav(truncated, 2, rate, nullptr));
+  // A chunk BEFORE `data` must be walked over, not assumed away: a fixed 44-byte
+  // header would read the LIST payload as samples.
+  std::string with_list = wav.substr(0, 36);
+  const std::string list_body = "INFOxxxx";
+  with_list += "LIST";
+  for (int i = 0; i < 4; ++i) {
+    with_list.push_back(static_cast<char>((list_body.size() >> (8 * i)) & 0xFF));
+  }
+  with_list += list_body;
+  with_list += wav.substr(36);
+  int64_t list_got = 0;
+  const std::vector<float> after_list = vllm::MiniMaxH3ReadWav(with_list, 2, rate, &list_got);
+  CHECK(list_got == samples);
+  CHECK(MaxAbsDiff(after_list, back.data(), back.size()) == 0.0);
+}
+
+TEST_CASE("minimax_h3: video output -- PPM frames and the MP4 mux command") {
+  // The library produces the ARTIFACTS and BUILDS the argv; the example/server
+  // layer spawns ffmpeg. Both halves here are pure data transforms, so both are
+  // testable without a subprocess.
+  vllm::MiniMaxH3VideoFrameShape shape;
+  shape.channels = 3;
+  shape.t = 2;
+  shape.h = 2;
+  shape.w = 3;
+  const int64_t plane = shape.h * shape.w;
+  std::vector<float> frames(static_cast<size_t>(3 * shape.t * plane), 0.0f);
+  // Frame 1, pixel (0,0): pure red at full scale; (0,1): black; (1,2): white.
+  auto set = [&](int64_t f, int64_t y, int64_t x, float r, float g, float b) {
+    frames[static_cast<size_t>((0 * shape.t + f) * plane + y * shape.w + x)] = r;
+    frames[static_cast<size_t>((1 * shape.t + f) * plane + y * shape.w + x)] = g;
+    frames[static_cast<size_t>((2 * shape.t + f) * plane + y * shape.w + x)] = b;
+  };
+  set(1, 0, 0, 1.0f, -1.0f, -1.0f);
+  set(1, 0, 1, -1.0f, -1.0f, -1.0f);
+  set(1, 1, 2, 1.0f, 1.0f, 1.0f);
+
+  const std::string ppm = vllm::MiniMaxH3WritePpmFrame(frames, shape, 1);
+  const std::string header = "P6\n3 2\n255\n";
+  CHECK(ppm.compare(0, header.size(), header) == 0);
+  REQUIRE(ppm.size() == header.size() + static_cast<size_t>(plane * 3));
+  auto px = [&](int64_t y, int64_t x, int64_t c) {
+    return static_cast<uint8_t>(ppm[header.size() + static_cast<size_t>((y * shape.w + x) * 3 + c)]);
+  };
+  // [-1, 1] maps to [0, 255]; PPM is row-major INTERLEAVED RGB, unlike the
+  // planar [C, T, H, W] the VAE emits.
+  CHECK(px(0, 0, 0) == 255);
+  CHECK(px(0, 0, 1) == 0);
+  CHECK(px(0, 0, 2) == 0);
+  CHECK(px(0, 1, 0) == 0);
+  CHECK(px(1, 2, 0) == 255);
+  CHECK(px(1, 2, 2) == 255);
+  // Mid-grey (0.0) lands mid-range, and a different frame is genuinely different.
+  CHECK(px(1, 0, 0) == 128);
+  CHECK(vllm::MiniMaxH3WritePpmFrame(frames, shape, 0) != ppm);
+  CHECK_THROWS(vllm::MiniMaxH3WritePpmFrame(frames, shape, 2));
+
+  // The mux command.
+  vllm::MiniMaxH3MuxRequest request;
+  request.frame_pattern = "/tmp/h3/frame_%06d.ppm";
+  request.audio_path = "/tmp/h3/audio.wav";
+  request.output_path = "/tmp/h3/out.mp4";
+  request.fps = vllm::kMiniMaxH3Fps;
+  request.crf = 18;
+  const std::vector<std::string> argv = vllm::MiniMaxH3BuildMp4MuxArgs(request);
+
+  auto has = [&](const std::string& token) {
+    return std::find(argv.begin(), argv.end(), token) != argv.end();
+  };
+  CHECK(argv.front() == "ffmpeg");
+  CHECK(argv.back() == request.output_path);
+  CHECK(has("-framerate"));
+  CHECK(has("24"));                 // H3's fixed output frame rate
+  CHECK(has(request.frame_pattern));
+  CHECK(has(request.audio_path));
+  CHECK(has("libx264"));
+  CHECK(has("yuv420p"));            // so every player accepts it
+  CHECK(has("aac"));
+  CHECK(has("-shortest"));          // no trailing silence or orphan video
+  CHECK(has("+faststart"));         // moov atom first => streamable
+
+  // A silent clip must not request an audio codec or -shortest.
+  vllm::MiniMaxH3MuxRequest silent = request;
+  silent.audio_path.clear();
+  const std::vector<std::string> silent_argv = vllm::MiniMaxH3BuildMp4MuxArgs(silent);
+  CHECK(std::find(silent_argv.begin(), silent_argv.end(), "aac") == silent_argv.end());
+  CHECK(std::find(silent_argv.begin(), silent_argv.end(), "-shortest") == silent_argv.end());
+  CHECK(silent_argv.back() == request.output_path);
+
+  vllm::MiniMaxH3MuxRequest bad = request;
+  bad.output_path.clear();
+  CHECK_THROWS(vllm::MiniMaxH3BuildMp4MuxArgs(bad));
+}
+
+TEST_CASE("minimax_h3: config parse enforces the upstream invariants") {
+  nlohmann::json config = {
+      {"num_layers", 50},        {"token_refiner_num_layers", 2}, {"hidden_size", 5376},
+      {"num_attention_heads", 56}, {"attention_head_dim", 128},   {"ffn_hidden_size", 14336},
+      {"latents_dim", 24},       {"audio_latents_dim", 32},       {"patch_size", {1, 2, 2}},
+      {"text_dim", 5120},        {"timestep_input_dim", 256},     {"time_embed_hidden_size", 5376},
+      {"time_embed_dim", 2688},  {"adaln_out_features", 18 * 5376},
+      {"final_adaln_out_features", 2 * 5376},                     {"rope_inv_freq_len", 16},
+  };
+  const MiniMaxH3DitParams p = ParseMiniMaxH3DitParams(config);
+  // The SHIPPED MiniMax-H3 geometry.
+  CHECK(p.num_layers == 50);
+  CHECK(p.hidden_size == 5376);
+  CHECK(p.num_attention_heads == 56);
+  CHECK(p.video_row_width() == 96);   // 24 * 1 * 2 * 2
+  CHECK(p.rope_rot_dim() == 96);      // 6 * 16, rotating 96 of 128 head dims
+  CHECK(p.rope_rot_dim() <= p.attention_head_dim);
+
+  // adaln_out_features must stay 6 vectors x 3 modalities x hidden_size.
+  nlohmann::json bad = config;
+  bad["adaln_out_features"] = 17 * 5376;
+  CHECK_THROWS(ParseMiniMaxH3DitParams(bad));
+  // patch_size must carry exactly three values.
+  nlohmann::json bad_patch = config;
+  bad_patch["patch_size"] = {1, 2};
+  CHECK_THROWS(ParseMiniMaxH3DitParams(bad_patch));
+}
+
+TEST_CASE("minimax_h3: the DiT weight contract covers the shipped checkpoint") {
+  MiniMaxH3DitParams p;  // shipped defaults
+  const std::vector<vllm::MiniMaxH3TensorSpec> specs = EnumerateMiniMaxH3DitTensors(p);
+
+  // 11 stem entries + refiner (2 x 8 + 1) + blocks (50 x 10) + 7 final entries.
+  CHECK(specs.size() == 11 + (2 * 8 + 1) + (50 * 10) + 7);
+
+  auto find = [&](const std::string& name) -> const vllm::MiniMaxH3TensorSpec* {
+    for (const vllm::MiniMaxH3TensorSpec& spec : specs) {
+      if (spec.name == name) return &spec;
+    }
+    return nullptr;
+  };
+  // The 12 fp32 parameters plus the fp32 rope buffer
+  // (minimax_h3_transformer.py:85-101) must be marked fp32 and nothing else.
+  const char* fp32_names[] = {
+      "video_patch_proj.weight",     "video_patch_proj.bias",
+      "audio_patch_proj.weight",     "audio_patch_proj.bias",
+      "time_embedder.proj_in.weight", "time_embedder.proj_in.bias",
+      "time_embedder.proj_out.weight", "time_embedder.proj_out.bias",
+      "final_layer.video_out.weight", "final_layer.video_out.bias",
+      "final_layer.audio_out.weight", "final_layer.audio_out.bias",
+      "rope.inv_freq",
+  };
+  size_t fp32_count = 0;
+  for (const vllm::MiniMaxH3TensorSpec& spec : specs) fp32_count += spec.fp32 ? 1 : 0;
+  CHECK(fp32_count == std::size(fp32_names));
+  for (const char* name : fp32_names) {
+    const vllm::MiniMaxH3TensorSpec* spec = find(name);
+    REQUIRE(spec != nullptr);
+    CHECK(spec->fp32);
+  }
+
+  // MHA: qkv is 3 * heads * head_dim rows wide, and the text condition projection
+  // consumes the encoder's 5120-wide hidden state.
+  const vllm::MiniMaxH3TensorSpec* qkv = find("blocks.0.attn.qkv_proj.weight");
+  REQUIRE(qkv != nullptr);
+  CHECK(qkv->shape[0] == 3 * 56 * 128);
+  CHECK(qkv->shape[1] == 5376);
+  const vllm::MiniMaxH3TensorSpec* cond = find("condition_proj.weight");
+  REQUIRE(cond != nullptr);
+  CHECK(cond->shape[1] == 5120);
+}
+
+TEST_CASE("minimax_h3: grouped-qkv checkpoint reorder is a pure permutation") {
+  // The checkpoint stores [q, k, v] PER HEAD; the fused projection wants
+  // [q_all, k_all, v_all] (minimax_h3_transformer.py:139-168). H3 is MHA, so
+  // heads_per_group == 1.
+  const int64_t groups = 3, head_dim = 2, in_features = 2;
+  const int64_t rows = groups * (1 + 2) * head_dim;
+  std::vector<float> weight(static_cast<size_t>(rows * in_features));
+  for (size_t i = 0; i < weight.size(); ++i) weight[i] = static_cast<float>(i);
+
+  const std::vector<float> out =
+      MiniMaxH3ReorderGroupedQkv(weight, groups, 1, head_dim, in_features);
+  REQUIRE(out.size() == weight.size());
+
+  const int64_t q_rows = groups * head_dim;
+  for (int64_t g = 0; g < groups; ++g) {
+    for (int64_t r = 0; r < head_dim; ++r) {
+      for (int64_t c = 0; c < in_features; ++c) {
+        const int64_t src_q = (g * 3 * head_dim + r) * in_features + c;
+        const int64_t src_k = (g * 3 * head_dim + head_dim + r) * in_features + c;
+        const int64_t src_v = (g * 3 * head_dim + 2 * head_dim + r) * in_features + c;
+        CHECK(out[static_cast<size_t>((g * head_dim + r) * in_features + c)] == weight[src_q]);
+        CHECK(out[static_cast<size_t>((q_rows + g * head_dim + r) * in_features + c)] ==
+              weight[src_k]);
+        CHECK(out[static_cast<size_t>((2 * q_rows + g * head_dim + r) * in_features + c)] ==
+              weight[src_v]);
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// KEEP-QUANT GGUF arm. This is the path that makes a quantized H3 run cheap on
+// hardware WITHOUT fp4 tensor cores: the ggml block-quant GEMM carries no arch
+// gate at all (src/vt/cuda/cuda_quant_dot.cu has no #if), unlike every
+// cutlass/marlin/fp4 path. So it runs at native speed on archs where NVFP4 can
+// only be emulated.
+// ---------------------------------------------------------------------------
+
+static void CheckKeepQuantForward(vt::Queue& q, const char* label) {
+  MiniMaxH3DitParams want;
+  want.num_layers = 2;
+  want.token_refiner_num_layers = 1;
+  want.hidden_size = 64;
+  want.num_attention_heads = 4;
+  want.attention_head_dim = 16;
+  want.ffn_hidden_size = 128;
+  want.latents_dim = 8;
+  want.audio_latents_dim = 6;
+  want.text_dim = 32;  // whole Q8_0 blocks, so condition_proj is keep-quant ELIGIBLE
+  want.timestep_input_dim = 16;
+  want.time_embed_hidden_size = 64;
+  want.time_embed_dim = 32;
+  want.adaln_out_features = 18 * want.hidden_size;
+  want.final_adaln_out_features = 2 * want.hidden_size;
+  want.rope_inv_freq_len = 2;
+
+  gguf_test::GgufModelBuilder builder;
+  builder.AddKv(gguf_test::StrKv("general.architecture", "wan"));
+
+  // F32 for anything that is NOT an eligible 2-D projection (norms, biases,
+  // rope.inv_freq): the loader must dequantize those either way.
+  auto add_f32 = [&](const std::string& name, const std::vector<int64_t>& logical) {
+    int64_t numel = 1;
+    for (int64_t d : logical) numel *= d;
+    const std::vector<float> values = MakeParam("kq." + name, numel, 0.1);
+    std::string bytes(reinterpret_cast<const char*>(values.data()), values.size() * sizeof(float));
+    std::vector<uint64_t> ne;
+    for (auto it = logical.rbegin(); it != logical.rend(); ++it) {
+      ne.push_back(static_cast<uint64_t>(*it));
+    }
+    builder.AddTensor(name, ne, /*ggml_type=*/0 /*F32*/, bytes);
+  };
+
+  // Real Q8_0 blocks, produced by the SAME quantizer a converter would use, so
+  // this runs over bytes a real checkpoint could contain.
+  auto add_q8 = [&](const std::string& name, int64_t out_dim, int64_t in_dim) {
+    const std::vector<float> values = MakeParam("kq." + name, out_dim * in_dim, 0.1);
+    const size_t row_bytes = vt::RowSizeBytes(vt::DType::kQ8_0, in_dim);
+    std::string bytes(static_cast<size_t>(out_dim) * row_bytes, '\0');
+    vt::cpu::FromFloatFn q = vt::cpu::BlockFromFloat(vt::DType::kQ8_0);
+    REQUIRE(q != nullptr);
+    for (int64_t r = 0; r < out_dim; ++r) {
+      q(values.data() + r * in_dim, bytes.data() + static_cast<size_t>(r) * row_bytes, in_dim);
+    }
+    builder.AddTensor(name, {static_cast<uint64_t>(in_dim), static_cast<uint64_t>(out_dim)},
+                      /*ggml_type=*/8 /*Q8_0*/, bytes);
+  };
+
+  const int64_t inner = want.num_attention_heads * want.attention_head_dim;
+  const int64_t video_width = want.video_row_width();
+
+  // fp32 islands stay f32 in the file; the DiT's own projections go Q8_0.
+  add_f32("video_patch_proj.weight", {want.hidden_size, video_width});
+  add_f32("video_patch_proj.bias", {want.hidden_size});
+  add_f32("audio_patch_proj.weight", {want.hidden_size, want.audio_latents_dim});
+  add_f32("audio_patch_proj.bias", {want.hidden_size});
+  add_q8("condition_proj.weight", want.hidden_size, want.text_dim);
+  add_f32("condition_proj.bias", {want.hidden_size});
+  add_f32("time_embedder.proj_in.weight", {want.time_embed_hidden_size, want.timestep_input_dim});
+  add_f32("time_embedder.proj_in.bias", {want.time_embed_hidden_size});
+  add_f32("time_embedder.proj_out.weight", {want.time_embed_dim, want.time_embed_hidden_size});
+  add_f32("time_embedder.proj_out.bias", {want.time_embed_dim});
+  add_f32("rope.inv_freq", {want.rope_inv_freq_len});
+
+  auto add_block = [&](const std::string& prefix, bool adaln) {
+    add_f32(prefix + ".norm1.weight", {want.hidden_size});
+    add_f32(prefix + ".norm2.weight", {want.hidden_size});
+    add_q8(prefix + ".attn.qkv_proj.weight", 3 * inner, want.hidden_size);
+    add_f32(prefix + ".attn.q_norm.weight", {want.attention_head_dim});
+    add_f32(prefix + ".attn.k_norm.weight", {want.attention_head_dim});
+    add_q8(prefix + ".attn.out_proj.weight", want.hidden_size, inner);
+    add_q8(prefix + ".mlp.fc1.weight", 2 * want.ffn_hidden_size, want.hidden_size);
+    add_q8(prefix + ".mlp.fc2.weight", want.hidden_size, want.ffn_hidden_size);
+    if (adaln) {
+      add_q8(prefix + ".adaln_proj.linear.weight", want.adaln_out_features, want.time_embed_dim);
+      add_f32(prefix + ".adaln_proj.linear.bias", {want.adaln_out_features});
+    }
+  };
+  for (int64_t i = 0; i < want.token_refiner_num_layers; ++i) {
+    add_block("token_refiner.blocks." + std::to_string(i), false);
+  }
+  add_f32("token_refiner.final_norm.weight", {want.hidden_size});
+  for (int64_t i = 0; i < want.num_layers; ++i) {
+    add_block("blocks." + std::to_string(i), true);
+  }
+  add_f32("final_layer.norm.weight", {want.hidden_size});
+  add_q8("final_layer.adaln_proj.linear.weight", want.final_adaln_out_features,
+         want.time_embed_dim);
+  add_f32("final_layer.adaln_proj.linear.bias", {want.final_adaln_out_features});
+  add_f32("final_layer.video_out.weight", {video_width, want.hidden_size});
+  add_f32("final_layer.video_out.bias", {video_width});
+  add_f32("final_layer.audio_out.weight", {want.audio_latents_dim, want.hidden_size});
+  add_f32("final_layer.audio_out.bias", {want.audio_latents_dim});
+
+  const std::string path = "/tmp/minimax_h3_keepquant_test.gguf";
+  {
+    const std::string bytes = builder.Build();
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    CHECK(std::fwrite(bytes.data(), 1, bytes.size(), fh) == bytes.size());
+    std::fclose(fh);
+  }
+
+  const vllm::GgufFile gguf = vllm::GgufFile::Open(path);
+  const vllm::MiniMaxH3GgufDit dequantized =
+      vllm::LoadMiniMaxH3DitFromGguf(gguf, /*keep_quant=*/false);
+  const vllm::MiniMaxH3GgufDit kept = vllm::LoadMiniMaxH3DitFromGguf(gguf, /*keep_quant=*/true);
+
+  // The keep-quant load must ACTUALLY have kept things quantized -- otherwise the
+  // output comparison below would pass trivially by comparing two identical paths.
+  CHECK(dequantized.quant_storage.empty());
+  CHECK_FALSE(kept.quant_storage.empty());
+  CHECK(kept.quant_dtype.at("blocks.0.attn.qkv_proj.weight") == vt::DType::kQ8_0);
+  CHECK(kept.weights.blocks[0].qkv_proj.dtype == vt::DType::kQ8_0);
+  // ...and must have left the ineligible tensors alone (1-D norms/biases).
+  CHECK(kept.quant_storage.count("blocks.0.norm1.weight") == 0);
+  CHECK(kept.weights.blocks[0].norm1.dtype == vt::DType::kF32);
+  // Keep-quant is the whole point: the resident bytes must be SMALLER.
+  size_t kept_bytes = 0;
+  for (const auto& kv : kept.quant_storage) kept_bytes += kv.second.size();
+  size_t dequant_bytes = 0;
+  for (const auto& kv : dequantized.storage) {
+    if (kept.quant_storage.count(kv.first) != 0) dequant_bytes += kv.second.size() * sizeof(float);
+  }
+  INFO("kept " << kept_bytes << " B vs dequantized " << dequant_bytes << " B");
+  CHECK(kept_bytes < dequant_bytes);
+
+  // Both must produce the same answer. vt::MatmulBT routes the block weight to
+  // kMatmulBTQuant, whose per-element product is bit-for-bit the dequantized
+  // value; only the K-reduction ORDER differs, so this is a matmul tolerance.
+  const std::unique_ptr<DitForwardCase> c = BuildDitForwardCase(kept.params);
+  const MiniMaxH3DitDeviceWeights staged_deq =
+      StageMiniMaxH3DitWeights(q, dequantized.params, dequantized.weights, vt::DType::kF32);
+  const MiniMaxH3DitDeviceWeights staged_kq =
+      StageMiniMaxH3DitWeights(q, kept.params, kept.weights, vt::DType::kF32);
+  const MiniMaxH3DitOutputs out_deq =
+      MiniMaxH3DitForwardDevice(q, dequantized.params, staged_deq.weights, c->in, vt::DType::kF32);
+  const MiniMaxH3DitOutputs out_kq =
+      MiniMaxH3DitForwardDevice(q, kept.params, staged_kq.weights, c->in, vt::DType::kF32);
+
+  REQUIRE(out_kq.video_logits.size() == out_deq.video_logits.size());
+  const double video_err =
+      MaxAbsDiff(out_kq.video_logits, out_deq.video_logits.data(), out_kq.video_logits.size());
+  const double audio_err =
+      MaxAbsDiff(out_kq.audio_logits, out_deq.audio_logits.data(), out_kq.audio_logits.size());
+  INFO(label << " keep-quant vs dequantized: video " << video_err << ", audio " << audio_err);
+  CHECK(video_err <= 2e-3);
+  CHECK(audio_err <= 2e-3);
+  // And the forward must have produced something, not all zeros -- the failure
+  // mode a keep-quant slice hits when its bytes never reach the device.
+  double magnitude = 0.0;
+  for (float v : out_kq.video_logits) magnitude = std::max(magnitude, std::abs((double)v));
+  CHECK(magnitude > 1e-6);
+}
+
+TEST_CASE("minimax_h3: the KEEP-QUANT GGUF arm matches the dequantized load (CPU backend)") {
+  vt::Queue q{Cpu(), nullptr};
+  CheckKeepQuantForward(q, "cpu");
+}
+
+// The one that actually matters for the GGUF arm's premise: this exercises
+// kMatmulBTQuant's CUDA kernel over H3's own shapes. It is also the only place the
+// ALL-ZEROS failure mode is reachable -- a keep-quant slice whose bytes never reach
+// the device reads as valid host memory on CPU and as zeros on the GPU.
+TEST_CASE("minimax_h3: the KEEP-QUANT GGUF arm matches the dequantized load on CUDA") {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(vt::DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  vt::Queue q = cuda->CreateQueue();
+  CheckKeepQuantForward(q, "cuda");
+}
+
+// ---------------------------------------------------------------------------
+// PATH 2: checkpoint loaders. The VAE/encoder FORWARDS were gated against the
+// checkpoint's own remote code, which proved the MATH. These gate the BINDING:
+// that the SHIPPED file's tensors actually land on the structs those forwards
+// read. For the audio VAE they do not do so directly, and this is where that is
+// caught.
+// ---------------------------------------------------------------------------
+
+TEST_CASE("minimax_h3: the REAL audio-VAE checkpoint maps onto the decoder's names") {
+  // Drive the loader's mapping rules over the REAL 1087-tensor manifest (names +
+  // shapes, captured from the file's own header by range request; no payload).
+  // The two mismatches this pins down are silent-failure shaped:
+  //   * the file ships LEGACY weight_g/weight_v, the decoder reads
+  //     parametrizations.weight.original0/1;
+  //   * BigVGAN is under `decoder.`, but dec_in_proj.* is top level.
+  auto mapped = [](const std::string& name) -> std::string {
+    if (name.rfind("encoder.", 0) == 0) return "";  // audio ENCODER: not decoded
+    std::string key = name;
+    if (key.rfind("decoder.", 0) == 0) key = key.substr(8);
+    if (key.size() >= 7 && key.compare(key.size() - 7, 7, ".filter") == 0) return "";
+    const std::string g = ".weight_g", v = ".weight_v";
+    if (key.size() > g.size() && key.compare(key.size() - g.size(), g.size(), g) == 0) {
+      return key.substr(0, key.size() - g.size()) + ".parametrizations.weight.original0";
+    }
+    if (key.size() > v.size() && key.compare(key.size() - v.size(), v.size(), v) == 0) {
+      return key.substr(0, key.size() - v.size()) + ".parametrizations.weight.original1";
+    }
+    return key;
+  };
+
+  std::set<std::string> decoder_names;
+  int64_t skipped_filters = 0, skipped_encoder = 0, weight_norm_pairs = 0;
+  for (int64_t i = 0; i < vllm_test::kH3AudioVaeTensorCount; ++i) {
+    const std::string name = vllm_test::kH3AudioVaeTensors[i].name;
+    if (name.rfind("encoder.", 0) == 0) {
+      ++skipped_encoder;
+      continue;
+    }
+    const std::string key = mapped(name);
+    if (key.empty()) {
+      ++skipped_filters;
+      continue;
+    }
+    CHECK(decoder_names.insert(key).second);  // the mapping must be INJECTIVE
+    if (key.find(".parametrizations.weight.original") != std::string::npos) ++weight_norm_pairs;
+  }
+
+  // The file really does carry an encoder and really does use the legacy spelling
+  // — if either stopped being true these counts would move, and the loader's
+  // renaming would silently become dead code.
+  CHECK(skipped_encoder > 0);
+  CHECK(skipped_filters > 0);
+  CHECK(weight_norm_pairs > 0);
+
+  // The decoder's own entry points must be present under the MAPPED names.
+  CHECK(decoder_names.count("dec_in_proj.weight") == 1);
+  CHECK(decoder_names.count("dec_in_proj.bias") == 1);
+  CHECK(decoder_names.count("conv_pre.parametrizations.weight.original0") == 1);
+  CHECK(decoder_names.count("conv_pre.parametrizations.weight.original1") == 1);
+  CHECK(decoder_names.count("conv_pre.bias") == 1);
+  CHECK(decoder_names.count("conv_post.parametrizations.weight.original0") == 1);
+  CHECK(decoder_names.count("conv_post.parametrizations.weight.original1") == 1);
+  CHECK(decoder_names.count("activation_post.act.alpha") == 1);
+  CHECK(decoder_names.count("activation_post.act.beta") == 1);
+  CHECK(decoder_names.count("ups.0.0.parametrizations.weight.original0") == 1);
+  CHECK(decoder_names.count("resblocks.0.convs1.0.parametrizations.weight.original0") == 1);
+  CHECK(decoder_names.count("resblocks.0.convs2.0.parametrizations.weight.original1") == 1);
+  CHECK(decoder_names.count("resblocks.0.activations.0.act.alpha") == 1);
+  // Nothing may keep the legacy spelling after mapping.
+  for (const std::string& n : decoder_names) {
+    CHECK(n.find(".weight_g") == std::string::npos);
+    CHECK(n.find(".weight_v") == std::string::npos);
+    CHECK(n.rfind("decoder.", 0) != 0);
+  }
+
+  // The SHIPPED geometry, recovered from the manifest's shapes alone, must equal
+  // the config the decoder was gated with.
+  auto shape_of = [](const std::string& want) {
+    for (int64_t i = 0; i < vllm_test::kH3AudioVaeTensorCount; ++i) {
+      if (want == vllm_test::kH3AudioVaeTensors[i].name) return vllm_test::kH3AudioVaeTensors[i];
+    }
+    FAIL("manifest is missing ", want);
+    return vllm_test::kH3AudioVaeTensors[0];
+  };
+  // dec_in_proj: Conv1d(vae_latent_channels -> num_mels, k=1).
+  const auto dip = shape_of("dec_in_proj.weight");
+  CHECK(dip.rank == 3);
+  CHECK(dip.shape[0] == 2048);  // num_mels
+  CHECK(dip.shape[1] == 32);    // vae latent channels
+  CHECK(dip.shape[2] == 1);     // k = 1
+  // conv_pre: num_mels -> upsample_initial_channel, k=7.
+  const auto pre = shape_of("decoder.conv_pre.weight_v");
+  CHECK(pre.shape[0] == 1024);  // upsample_initial_channel
+  CHECK(pre.shape[1] == 2048);  // num_mels
+  CHECK(pre.shape[2] == 7);
+  // conv_post: 7 upsamples halve 1024 down to 8, then -> 1 channel, k=7.
+  const auto post = shape_of("decoder.conv_post.weight_v");
+  CHECK(post.shape[0] == 1);
+  CHECK(post.shape[1] == 8);
+  CHECK(post.shape[2] == 7);
+}
+
+TEST_CASE("minimax_h3: the audio-VAE loader materializes weights the decoder RUNS") {
+  // The manifest test above gates the NAME mapping against the real checkpoint.
+  // This gates the loader end to end: a real safetensors file, written with the
+  // SHIPPED spellings (decoder. prefix, legacy weight_g/weight_v, kaiser-sinc
+  // filters present), must produce weights the decoder actually decodes with.
+  struct Entry {
+    std::string name, dtype;
+    std::vector<int64_t> shape;
+    std::string bytes;
+  };
+  std::vector<Entry> entries;
+  auto add = [&](const std::string& name, const std::vector<int64_t>& shape) {
+    int64_t numel = 1;
+    for (int64_t d : shape) numel *= d;
+    const std::vector<float> values = MakeParam("stvae." + name, numel, 0.05);
+    entries.push_back({name, "F32", shape,
+                       std::string(reinterpret_cast<const char*>(values.data()),
+                                   values.size() * sizeof(float))});
+  };
+  // A conv, in the checkpoint's LEGACY weight-norm spelling.
+  auto add_conv = [&](const std::string& prefix, int64_t out_ch, int64_t in_ch, int64_t k,
+                      bool bias) {
+    add(prefix + ".weight_g", {out_ch, 1, 1});
+    add(prefix + ".weight_v", {out_ch, in_ch, k});
+    if (bias) add(prefix + ".bias", {out_ch});
+  };
+
+  const int64_t mels = vllm_test::kH3AudioVaeNumMels;
+  const int64_t init_ch = vllm_test::kH3AudioVaeInitialChannel;
+  add_conv("decoder.conv_pre", init_ch, mels, 7, true);
+  // Two upsample stages (rates 2,2 / kernels 4,4), matching the golden config.
+  // ConvTranspose1d stores its weight TRANSPOSED — [in, out, k], with the
+  // weight-norm magnitude sized by INPUT channels — which the real checkpoint
+  // confirms (decoder.ups.0.0.weight_v is [1024, 512, 9], bias [512]).
+  auto add_deconv = [&](const std::string& prefix, int64_t in_ch, int64_t out_ch, int64_t k) {
+    add(prefix + ".weight_g", {in_ch, 1, 1});
+    add(prefix + ".weight_v", {in_ch, out_ch, k});
+    add(prefix + ".bias", {out_ch});
+  };
+  add_deconv("decoder.ups.0.0", init_ch, init_ch / 2, 4);
+  add_deconv("decoder.ups.1.0", init_ch / 2, init_ch / 4, 4);
+  // 3 resblock kernels x 3 dilations, per upsample stage.
+  const std::vector<int64_t> ks = {3, 7, 11};
+  for (int64_t u = 0; u < 2; ++u) {
+    const int64_t ch = u == 0 ? init_ch / 2 : init_ch / 4;
+    for (size_t kidx = 0; kidx < ks.size(); ++kidx) {
+      const std::string rb = "decoder.resblocks." + std::to_string(u * 3 + kidx);
+      for (int64_t c = 0; c < 3; ++c) {
+        add_conv(rb + ".convs1." + std::to_string(c), ch, ch, ks[kidx], true);
+        add_conv(rb + ".convs2." + std::to_string(c), ch, ch, ks[kidx], true);
+      }
+      for (int64_t a = 0; a < 6; ++a) {
+        const std::string act = rb + ".activations." + std::to_string(a);
+        add(act + ".act.alpha", {ch});
+        add(act + ".act.beta", {ch});
+        // Present in the file, and the loader must SKIP them (computed at load).
+        add(act + ".upsample.filter", {1, 1, 12});
+        add(act + ".downsample.lowpass.filter", {1, 1, 12});
+      }
+    }
+  }
+  add("decoder.activation_post.act.alpha", {init_ch / 4});
+  add("decoder.activation_post.act.beta", {init_ch / 4});
+  add("decoder.activation_post.upsample.filter", {1, 1, 12});
+  add_conv("decoder.conv_post", 1, init_ch / 4, 7, false);
+  // The audio ENCODER shares the file and must be ignored.
+  add("encoder.block.0.alpha", {8});
+
+  std::string header = "{";
+  size_t offset = 0;
+  bool first = true;
+  for (const Entry& e : entries) {
+    if (!first) header += ",";
+    first = false;
+    header += "\"" + e.name + "\":{\"dtype\":\"" + e.dtype + "\",\"shape\":[";
+    for (size_t i = 0; i < e.shape.size(); ++i) {
+      if (i) header += ",";
+      header += std::to_string(e.shape[i]);
+    }
+    header += "],\"data_offsets\":[" + std::to_string(offset) + "," +
+              std::to_string(offset + e.bytes.size()) + "]}";
+    offset += e.bytes.size();
+  }
+  header += "}";
+  const std::string path = "/tmp/minimax_h3_audio_vae_loader.safetensors";
+  {
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    const uint64_t n = header.size();
+    std::fwrite(&n, sizeof(n), 1, fh);
+    std::fwrite(header.data(), 1, header.size(), fh);
+    for (const Entry& e : entries) std::fwrite(e.bytes.data(), 1, e.bytes.size(), fh);
+    std::fclose(fh);
+  }
+
+  const vllm::SafetensorsFile st = vllm::SafetensorsFile::Open(path);
+  const vllm::MiniMaxH3AudioVaeWeights w = vllm::LoadMiniMaxH3AudioVaeWeights(st);
+
+  // Renamed, de-prefixed, filters and encoder dropped.
+  CHECK(w.Has("conv_pre.parametrizations.weight.original0"));
+  CHECK(w.Has("conv_pre.parametrizations.weight.original1"));
+  CHECK(w.Has("conv_pre.bias"));
+  CHECK(w.Has("resblocks.0.activations.0.act.alpha"));
+  CHECK_FALSE(w.Has("decoder.conv_pre.weight_g"));   // legacy spelling gone
+  CHECK_FALSE(w.Has("conv_pre.weight_g"));
+  CHECK_FALSE(w.Has("resblocks.0.activations.0.upsample.filter"));  // computed
+  CHECK_FALSE(w.Has("encoder.block.0.alpha"));                      // not decoded
+
+  // And it DECODES: the loaded weights drive the real decoder to a finite,
+  // in-range waveform. This is the step a name-only check cannot reach.
+  vllm::MiniMaxH3AudioVaeConfig cfg;
+  cfg.num_mels = mels;
+  cfg.upsample_initial_channel = init_ch;
+  cfg.upsample_rates = {2, 2};
+  cfg.upsample_kernel_sizes = {4, 4};
+  cfg.resblock_kernel_sizes = ks;
+  cfg.resblock_dilation_sizes = {{1, 3, 5}, {1, 3, 5}, {1, 3, 5}};
+  const int64_t frames = vllm_test::kH3AudioVaeFrames;
+  const std::vector<float> latent = MakeParam("stvae.input", mels * frames, 1.0);
+  int64_t out_samples = 0;
+  const std::vector<float> wave =
+      vllm::MiniMaxH3AudioVaeDecode(cfg, w, latent, frames, &out_samples);
+  CHECK(out_samples == frames * 4);  // two stride-2 upsamples
+  REQUIRE(wave.size() == static_cast<size_t>(out_samples));
+  for (float v : wave) {
+    CHECK(std::isfinite(v));
+    CHECK(v >= -1.0f);
+    CHECK(v <= 1.0f);
+  }
+}
+
+TEST_CASE("minimax_h3: the REAL audio-VAE checkpoint maps onto the ENCODER's names") {
+  // The mirror of the decoder's manifest test, for the half that had no loader.
+  // Same file, same 1087 tensors, opposite selection: `encoder.*` (de-prefixed),
+  // plus the TOP-LEVEL `pre_block.*` and `mean_proj.*`. `logs_proj.*` must be left
+  // behind -- loading it would imply conditioning samples the distribution.
+  auto mapped = [](const std::string& name) -> std::string {
+    const bool is_encoder = name.rfind("encoder.", 0) == 0;
+    if (!is_encoder && name.rfind("pre_block.", 0) != 0 && name.rfind("mean_proj.", 0) != 0) {
+      return "";
+    }
+    std::string key = is_encoder ? name.substr(std::strlen("encoder.")) : name;
+    const std::string g = ".weight_g", v = ".weight_v";
+    if (key.size() > g.size() && key.compare(key.size() - g.size(), g.size(), g) == 0) {
+      return key.substr(0, key.size() - g.size()) + ".parametrizations.weight.original0";
+    }
+    if (key.size() > v.size() && key.compare(key.size() - v.size(), v.size(), v) == 0) {
+      return key.substr(0, key.size() - v.size()) + ".parametrizations.weight.original1";
+    }
+    return key;
+  };
+
+  std::set<std::string> encoder_names;
+  int64_t weight_norm_pairs = 0, skipped_decoder = 0, skipped_logs = 0;
+  for (int64_t i = 0; i < vllm_test::kH3AudioVaeTensorCount; ++i) {
+    const std::string name = vllm_test::kH3AudioVaeTensors[i].name;
+    if (name.rfind("logs_proj.", 0) == 0) {
+      ++skipped_logs;
+      continue;
+    }
+    const std::string key = mapped(name);
+    if (key.empty()) {
+      ++skipped_decoder;
+      continue;
+    }
+    CHECK(encoder_names.insert(key).second);  // the mapping must be INJECTIVE
+    if (key.find(".parametrizations.weight.original") != std::string::npos) ++weight_norm_pairs;
+  }
+  CHECK(skipped_decoder > 0);  // the decoder really does share the file
+  CHECK(skipped_logs == 2);    // logs_proj.weight + logs_proj.bias, both left behind
+  CHECK(weight_norm_pairs > 0);
+
+  // The encoder's own entry points, under the MAPPED names the forward reads.
+  CHECK(encoder_names.count("block.0.parametrizations.weight.original0") == 1);
+  CHECK(encoder_names.count("block.0.parametrizations.weight.original1") == 1);
+  CHECK(encoder_names.count("block.0.bias") == 1);
+  CHECK(encoder_names.count("block.1.block.0.block.0.alpha") == 1);      // ResidualUnit Snake1d
+  CHECK(encoder_names.count("block.1.block.0.block.1.parametrizations.weight.original1") == 1);
+  CHECK(encoder_names.count("block.1.block.4.parametrizations.weight.original1") == 1);  // stride
+  CHECK(encoder_names.count("mean_proj.weight") == 1);
+  CHECK(encoder_names.count("pre_block.attn.qkv.weight") == 1);
+  CHECK(encoder_names.count("pre_block.attn.zero_k_bias") == 1);
+  CHECK(encoder_names.count("pre_block.mlp.w2.weight") == 1);
+  for (const std::string& n : encoder_names) {
+    CHECK(n.find(".weight_g") == std::string::npos);
+    CHECK(n.find(".weight_v") == std::string::npos);
+    CHECK(n.rfind("encoder.", 0) != 0);
+    CHECK(n.rfind("logs_proj", 0) != 0);
+  }
+
+  // The SHIPPED geometry, recovered from the manifest's shapes alone, must equal
+  // the config MiniMaxH3AudioVaeEncoderConfig defaults to. This is the check that
+  // catches a rates list or a latent width that drifted from the checkpoint.
+  auto shape_of = [](const std::string& want) {
+    for (int64_t i = 0; i < vllm_test::kH3AudioVaeTensorCount; ++i) {
+      if (want == vllm_test::kH3AudioVaeTensors[i].name) return vllm_test::kH3AudioVaeTensors[i];
+    }
+    FAIL("manifest is missing ", want);
+    return vllm_test::kH3AudioVaeTensors[0];
+  };
+  const vllm::MiniMaxH3AudioVaeEncoderConfig cfg;  // the SHIPPED defaults
+  // block.0: WNConv1d(1, encoder_dim, k=7).
+  const auto first = shape_of("encoder.block.0.weight_v");
+  CHECK(first.shape[0] == cfg.encoder_dim);
+  CHECK(first.shape[1] == 1);  // a MONO waveform in
+  CHECK(first.shape[2] == 7);
+  // Each EncoderBlock's strided conv doubles the channels; its kernel is 2*stride,
+  // which is how the manifest pins down `encoder_rates` without a config file.
+  int64_t channels = cfg.encoder_dim;
+  for (size_t i = 0; i < cfg.encoder_rates.size(); ++i) {
+    const auto down =
+        shape_of("encoder.block." + std::to_string(i + 1) + ".block.4.weight_v");
+    CHECK(down.shape[0] == channels * 2);
+    CHECK(down.shape[1] == channels);
+    CHECK(down.shape[2] == 2 * cfg.encoder_rates[i]);
+    channels *= 2;
+  }
+  CHECK(channels == cfg.latent_dim);  // 64 * 2^5 == 2048
+  // The final conv lands on d_latent with k=3, and the manifest's index proves the
+  // block count: 1 conv + 5 EncoderBlocks + 1 Snake1d + 1 conv.
+  const auto tail = shape_of("encoder.block." + std::to_string(cfg.encoder_rates.size() + 2) +
+                             ".weight_v");
+  CHECK(tail.shape[0] == cfg.latent_dim);
+  CHECK(tail.shape[1] == channels);
+  CHECK(tail.shape[2] == 3);
+  // pre_block: AttnProjection(latent_dim -> attn_proj_dim), qkv 3x the INPUT width
+  // (the narrowing branch, dac_attn_proj.py:31-37).
+  const auto qkv = shape_of("pre_block.attn.qkv.weight");
+  CHECK(qkv.shape[0] == 3 * cfg.latent_dim);
+  CHECK(qkv.shape[1] == cfg.latent_dim);
+  const auto pproj = shape_of("pre_block.proj.weight");
+  CHECK(pproj.shape[0] == cfg.attn_proj_dim());
+  CHECK(pproj.shape[1] == cfg.latent_dim);
+  // mean_proj: Conv1d(attn_proj_dim -> vae_latent_channels, k=1).
+  const auto mp = shape_of("mean_proj.weight");
+  CHECK(mp.shape[0] == cfg.vae_latent_channels);
+  CHECK(mp.shape[1] == cfg.attn_proj_dim());
+  CHECK(mp.shape[2] == 1);
+}
+
+TEST_CASE("minimax_h3: the audio-VAE ENCODER loader materializes weights that RUN") {
+  // End to end for the encoder half: a real safetensors file written with the
+  // SHIPPED spellings (encoder. prefix, legacy weight_g/weight_v, a decoder and a
+  // logs_proj sharing the file) must load into weights the encoder actually
+  // encodes with. Names alone cannot reach that.
+  const vllm::MiniMaxH3AudioVaeEncoderConfig cfg = ReducedAudioEncoderConfig();
+  struct Entry {
+    std::string name;
+    std::vector<int64_t> shape;
+    std::string bytes;
+  };
+  std::vector<Entry> entries;
+  auto add = [&](const std::string& name, const std::vector<int64_t>& shape, double scale,
+                 double offset) {
+    int64_t numel = 1;
+    for (int64_t d : shape) numel *= d;
+    const std::vector<float> values = MakeParam("stenc." + name, numel, scale, offset);
+    entries.push_back({name, shape,
+                       std::string(reinterpret_cast<const char*>(values.data()),
+                                   values.size() * sizeof(float))});
+  };
+  // A weight-normalized conv, in the checkpoint's LEGACY spelling.
+  auto add_conv = [&](const std::string& prefix, int64_t out_ch, int64_t in_ch, int64_t k) {
+    add(prefix + ".weight_g", {out_ch, 1, 1}, 0.03, 0.15);
+    add(prefix + ".weight_v", {out_ch, in_ch, k}, 0.08, 0.0);
+    add(prefix + ".bias", {out_ch}, 0.05, 0.0);
+  };
+  auto add_alpha = [&](const std::string& name, int64_t ch) {
+    add(name, {1, ch, 1}, 0.2, 1.0);
+  };
+
+  add_conv("encoder.block.0", cfg.encoder_dim, 1, 7);
+  int64_t channels = cfg.encoder_dim;
+  for (size_t i = 0; i < cfg.encoder_rates.size(); ++i) {
+    channels *= 2;
+    const int64_t half = channels / 2;
+    const std::string blk = "encoder.block." + std::to_string(i + 1);
+    for (int64_t u = 0; u < 3; ++u) {
+      const std::string ru = blk + ".block." + std::to_string(u);
+      add_alpha(ru + ".block.0.alpha", half);
+      add_conv(ru + ".block.1", half, half, 7);
+      add_alpha(ru + ".block.2.alpha", half);
+      add_conv(ru + ".block.3", half, half, 1);
+    }
+    add_alpha(blk + ".block.3.alpha", half);
+    add_conv(blk + ".block.4", channels, half, 2 * cfg.encoder_rates[i]);
+  }
+  const size_t rates = cfg.encoder_rates.size();
+  add_alpha("encoder.block." + std::to_string(rates + 1) + ".alpha", channels);
+  add_conv("encoder.block." + std::to_string(rates + 2), cfg.latent_dim, channels, 3);
+
+  const int64_t in_dim = cfg.latent_dim, out_dim = cfg.attn_proj_dim();
+  add("pre_block.norm1.weight", {in_dim}, 0.1, 1.0);
+  add("pre_block.norm1.bias", {in_dim}, 0.05, 0.0);
+  add("pre_block.norm3.weight", {in_dim}, 0.1, 1.0);
+  add("pre_block.norm3.bias", {in_dim}, 0.05, 0.0);
+  add("pre_block.norm2.weight", {out_dim}, 0.1, 1.0);
+  add("pre_block.norm2.bias", {out_dim}, 0.05, 0.0);
+  add("pre_block.attn.q_bias", {in_dim}, 0.05, 0.0);
+  add("pre_block.attn.v_bias", {in_dim}, 0.05, 0.0);
+  add("pre_block.attn.zero_k_bias", {in_dim}, 0.0, 0.0);
+  add("pre_block.attn.qkv.weight", {3 * in_dim, in_dim}, 0.1, 0.0);
+  add("pre_block.attn.proj.weight", {out_dim, out_dim}, 0.1, 0.0);
+  add("pre_block.attn.proj.bias", {out_dim}, 0.05, 0.0);
+  add("pre_block.proj.weight", {out_dim, in_dim}, 0.1, 0.0);
+  add("pre_block.proj.bias", {out_dim}, 0.05, 0.0);
+  add("pre_block.mlp.norm.weight", {out_dim}, 0.1, 1.0);
+  add("pre_block.mlp.norm.bias", {out_dim}, 0.05, 0.0);
+  const int64_t hidden = 2 * out_dim;
+  add("pre_block.mlp.w0.weight", {hidden, out_dim}, 0.1, 0.0);
+  add("pre_block.mlp.w0.bias", {hidden}, 0.05, 0.0);
+  add("pre_block.mlp.w1.weight", {hidden, out_dim}, 0.1, 0.0);
+  add("pre_block.mlp.w1.bias", {hidden}, 0.05, 0.0);
+  add("pre_block.mlp.w2.weight", {out_dim, hidden}, 0.1, 0.0);
+  add("pre_block.mlp.w2.bias", {out_dim}, 0.05, 0.0);
+  add("mean_proj.weight", {cfg.vae_latent_channels, out_dim, 1}, 0.1, 0.0);
+  add("mean_proj.bias", {cfg.vae_latent_channels}, 0.05, 0.0);
+  // The DECODER and the log-variance head share the file. Both must be left behind.
+  add("decoder.conv_pre.weight_g", {8, 1, 1}, 0.1, 0.0);
+  add("decoder.conv_pre.weight_v", {8, 4, 7}, 0.1, 0.0);
+  add("dec_in_proj.weight", {4, 4, 1}, 0.1, 0.0);
+  add("logs_proj.weight", {cfg.vae_latent_channels, out_dim, 1}, 0.1, 0.0);
+  add("logs_proj.bias", {cfg.vae_latent_channels}, 0.05, 0.0);
+
+  std::string header = "{";
+  size_t offset = 0;
+  bool first = true;
+  for (const Entry& e : entries) {
+    if (!first) header += ",";
+    first = false;
+    header += "\"" + e.name + "\":{\"dtype\":\"F32\",\"shape\":[";
+    for (size_t i = 0; i < e.shape.size(); ++i) {
+      if (i) header += ",";
+      header += std::to_string(e.shape[i]);
+    }
+    header += "],\"data_offsets\":[" + std::to_string(offset) + "," +
+              std::to_string(offset + e.bytes.size()) + "]}";
+    offset += e.bytes.size();
+  }
+  header += "}";
+  const std::string path = "/tmp/minimax_h3_audio_vae_encoder_loader.safetensors";
+  {
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    const uint64_t n = header.size();
+    std::fwrite(&n, sizeof(n), 1, fh);
+    std::fwrite(header.data(), 1, header.size(), fh);
+    for (const Entry& e : entries) std::fwrite(e.bytes.data(), 1, e.bytes.size(), fh);
+    std::fclose(fh);
+  }
+
+  const vllm::SafetensorsFile st = vllm::SafetensorsFile::Open(path);
+  const vllm::MiniMaxH3AudioVaeWeights w = vllm::LoadMiniMaxH3AudioVaeEncoderWeights(st);
+
+  // Renamed, de-prefixed, and the decoder half dropped.
+  CHECK(w.Has("block.0.parametrizations.weight.original0"));
+  CHECK(w.Has("block.0.parametrizations.weight.original1"));
+  CHECK(w.Has("block.1.block.0.block.0.alpha"));
+  CHECK(w.Has("pre_block.attn.qkv.weight"));   // top level: NOT de-prefixed
+  CHECK(w.Has("mean_proj.weight"));
+  CHECK_FALSE(w.Has("encoder.block.0.weight_g"));  // legacy spelling gone
+  CHECK_FALSE(w.Has("block.0.weight_g"));
+  CHECK_FALSE(w.Has("conv_pre.parametrizations.weight.original0"));  // decoder half
+  CHECK_FALSE(w.Has("dec_in_proj.weight"));
+  // The log-variance head is refused on purpose: a reference must be the MEAN.
+  CHECK_FALSE(w.Has("logs_proj.weight"));
+  CHECK_FALSE(w.Has("logs_proj.bias"));
+  // A PLAIN Linear's `.weight` must NOT be mistaken for a materialized weight-norm.
+  CHECK_FALSE(w.Has("pre_block.attn.qkv.parametrizations.weight.original0"));
+  CHECK_FALSE(w.Has("mean_proj.parametrizations.weight.original0"));
+
+  // And it ENCODES: the loaded weights drive the real encoder to finite rows of
+  // the shape a reference block claims.
+  int64_t audio_t = 0;
+  const int64_t samples = vllm_test::kH3AudioEncSamples;
+  std::vector<float> stereo = MakeParam("stenc.wave", samples, 1.0);
+  const std::vector<float> copy = stereo;
+  stereo.insert(stereo.end(), copy.begin(), copy.end());
+  const std::vector<float> rows =
+      vllm::MiniMaxH3AudioVaeEncodeToRows(cfg, w, stereo, 2, samples, {}, {}, &audio_t);
+  CHECK(audio_t == vllm_test::kH3AudioEncFrames);
+  REQUIRE(rows.size() == static_cast<size_t>(2 * audio_t * cfg.vae_latent_channels));
+  for (float v : rows) CHECK(std::isfinite(v));
+
+  // A MATERIALIZED weight-norm (the third spelling) must load too: rewriting one
+  // conv as a plain `.weight` has to reconstruct an exact (g, v) pair, so the rows
+  // come out byte-identical.
+  std::vector<Entry> folded;
+  for (const Entry& e : entries) {
+    if (e.name == "encoder.block.0.weight_g") continue;
+    if (e.name == "encoder.block.0.weight_v") {
+      // w = g * v / ||v||, folded at "conversion time".
+      std::vector<float> v(e.bytes.size() / sizeof(float));
+      std::memcpy(v.data(), e.bytes.data(), e.bytes.size());
+      const std::vector<float> g = MakeParam("stenc.encoder.block.0.weight_g", cfg.encoder_dim,
+                                             0.03, 0.15);
+      const std::vector<float> materialized =
+          vllm::MiniMaxH3MaterializeWeightNorm(g, v, cfg.encoder_dim);
+      folded.push_back({"encoder.block.0.weight", e.shape,
+                        std::string(reinterpret_cast<const char*>(materialized.data()),
+                                    materialized.size() * sizeof(float))});
+      continue;
+    }
+    folded.push_back(e);
+  }
+  header = "{";
+  offset = 0;
+  first = true;
+  for (const Entry& e : folded) {
+    if (!first) header += ",";
+    first = false;
+    header += "\"" + e.name + "\":{\"dtype\":\"F32\",\"shape\":[";
+    for (size_t i = 0; i < e.shape.size(); ++i) {
+      if (i) header += ",";
+      header += std::to_string(e.shape[i]);
+    }
+    header += "],\"data_offsets\":[" + std::to_string(offset) + "," +
+              std::to_string(offset + e.bytes.size()) + "]}";
+    offset += e.bytes.size();
+  }
+  header += "}";
+  const std::string folded_path = "/tmp/minimax_h3_audio_vae_encoder_folded.safetensors";
+  {
+    FILE* fh = std::fopen(folded_path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    const uint64_t n = header.size();
+    std::fwrite(&n, sizeof(n), 1, fh);
+    std::fwrite(header.data(), 1, header.size(), fh);
+    for (const Entry& e : folded) std::fwrite(e.bytes.data(), 1, e.bytes.size(), fh);
+    std::fclose(fh);
+  }
+  const vllm::SafetensorsFile fst = vllm::SafetensorsFile::Open(folded_path);
+  const vllm::MiniMaxH3AudioVaeWeights fw = vllm::LoadMiniMaxH3AudioVaeEncoderWeights(fst);
+  CHECK(fw.Has("block.0.parametrizations.weight.original0"));
+  int64_t ft = 0;
+  const std::vector<float> frows =
+      vllm::MiniMaxH3AudioVaeEncodeToRows(cfg, fw, stereo, 2, samples, {}, {}, &ft);
+  CHECK(ft == audio_t);
+  REQUIRE(frows.size() == rows.size());
+  const double fold_err = MaxAbsDiff(frows, rows.data(), rows.size());
+  INFO("materialized-weight-norm encode max|diff| = " << fold_err);
+  CHECK(fold_err <= 1e-6);
+}
+
+TEST_CASE("minimax_h3: the audio-VAE loader accepts a MATERIALIZED weight-norm too") {
+  // A third spelling exists in the wild: repackaged community VAE bundles fold the
+  // weight-norm at conversion time and ship a plain `<conv>.weight`, with no (g, v)
+  // pair at all. The decoder only knows the pair, so the loader reconstructs one --
+  // and the reconstruction must be EXACT, not approximate.
+  struct Entry {
+    std::string name, dtype;
+    std::vector<int64_t> shape;
+    std::string bytes;
+  };
+  std::vector<Entry> entries;
+  auto add = [&](const std::string& name, const std::vector<int64_t>& shape,
+                 const std::vector<float>& values) {
+    entries.push_back({name, "F32", shape,
+                       std::string(reinterpret_cast<const char*>(values.data()),
+                                   values.size() * sizeof(float))});
+  };
+  // One materialized conv weight, plus a plain dec_in_proj (NOT weight-normalized,
+  // so it must be left exactly alone).
+  const std::vector<float> w = MakeParam("matnorm.w", 4 * 3 * 5, 0.3);
+  add("decoder.conv_pre.weight", {4, 3, 5}, w);
+  add("decoder.conv_pre.bias", {4}, MakeParam("matnorm.b", 4, 0.1));
+  const std::vector<float> dip = MakeParam("matnorm.dip", 6 * 2 * 1, 0.2);
+  add("dec_in_proj.weight", {6, 2, 1}, dip);
+
+  std::string header = "{";
+  size_t offset = 0;
+  bool first = true;
+  for (const Entry& e : entries) {
+    if (!first) header += ",";
+    first = false;
+    header += "\"" + e.name + "\":{\"dtype\":\"" + e.dtype + "\",\"shape\":[";
+    for (size_t i = 0; i < e.shape.size(); ++i) {
+      if (i) header += ",";
+      header += std::to_string(e.shape[i]);
+    }
+    header += "],\"data_offsets\":[" + std::to_string(offset) + "," +
+              std::to_string(offset + e.bytes.size()) + "]}";
+    offset += e.bytes.size();
+  }
+  header += "}";
+  const std::string path = "/tmp/minimax_h3_audio_vae_materialized.safetensors";
+  {
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    const uint64_t n = header.size();
+    std::fwrite(&n, sizeof(n), 1, fh);
+    std::fwrite(header.data(), 1, header.size(), fh);
+    for (const Entry& e : entries) std::fwrite(e.bytes.data(), 1, e.bytes.size(), fh);
+    std::fclose(fh);
+  }
+
+  const vllm::SafetensorsFile st = vllm::SafetensorsFile::Open(path);
+  const vllm::MiniMaxH3AudioVaeWeights got = vllm::LoadMiniMaxH3AudioVaeWeights(st);
+
+  // The pair exists, and the plain name is gone.
+  REQUIRE(got.Has("conv_pre.parametrizations.weight.original0"));
+  REQUIRE(got.Has("conv_pre.parametrizations.weight.original1"));
+  CHECK_FALSE(got.Has("conv_pre.weight"));
+  // dec_in_proj is NOT weight-normalized: it must survive verbatim.
+  REQUIRE(got.Has("dec_in_proj.weight"));
+  CHECK_FALSE(got.Has("dec_in_proj.parametrizations.weight.original0"));
+  const std::vector<float>& dip_got = got.Get("dec_in_proj.weight");
+  REQUIRE(dip_got.size() == dip.size());
+  for (size_t i = 0; i < dip.size(); ++i) CHECK(dip_got[i] == dip[i]);
+
+  // THE POINT: running the decoder's own materialization on the reconstructed pair
+  // must return the checkpoint's weight. Anything else is a silently wrong conv.
+  const std::vector<float> back = vllm::MiniMaxH3MaterializeWeightNorm(
+      got.Get("conv_pre.parametrizations.weight.original0"),
+      got.Get("conv_pre.parametrizations.weight.original1"), 4);
+  REQUIRE(back.size() == w.size());
+  double err = 0.0;
+  for (size_t i = 0; i < w.size(); ++i) {
+    err = std::max(err, std::abs(static_cast<double>(back[i] - w[i])));
+  }
+  INFO("materialized round-trip err = " << err);
+  CHECK(err <= 1e-6);
+}
+
+TEST_CASE("minimax_h3: the REAL video-VAE checkpoint maps onto the ViT3D decoder's names") {
+  // Same shape of gate as the audio VAE, over the real 560-tensor manifest. The
+  // mapping is simpler here (no weight-norm spelling change; only the `decoder.`
+  // prefix), which is itself worth pinning: if a future checkpoint revision moved
+  // to the parametrization spelling, this test fails rather than the decode.
+  auto mapped = [](const std::string& name) -> std::string {
+    if (name.rfind("encoder.", 0) == 0) return "";
+    if (name.rfind("quant_conv.", 0) == 0) return "";  // encoder-side stage
+    std::string key = name;
+    if (key.rfind("decoder.", 0) == 0) key = key.substr(8);
+    return key;
+  };
+
+  std::set<std::string> names;
+  int64_t skipped = 0;
+  for (int64_t i = 0; i < vllm_test::kH3VideoVaeTensorCount; ++i) {
+    const std::string key = mapped(vllm_test::kH3VideoVaeTensors[i].name);
+    if (key.empty()) {
+      ++skipped;
+      continue;
+    }
+    CHECK(names.insert(key).second);  // INJECTIVE
+  }
+  CHECK(skipped > 0);  // the encoder half really is present in the file
+
+  // Every name the ViT3D decoder reads must exist post-mapping.
+  CHECK(names.count("x_embedder.weight") == 1);
+  CHECK(names.count("x_embedder.bias") == 1);
+  CHECK(names.count("register_tokens") == 1);
+  CHECK(names.count("norm_out.weight") == 1);
+  CHECK(names.count("proj_out.weight") == 1);
+  CHECK(names.count("transformer_blocks.0.attn.to_qkv.weight") == 1);
+  CHECK(names.count("transformer_blocks.0.attn.to_out.bias") == 1);
+  CHECK(names.count("transformer_blocks.0.ff.w1.weight") == 1);
+  CHECK(names.count("transformer_blocks.0.ff.w2.bias") == 1);
+  CHECK(names.count("transformer_blocks.0.norm1.weight") == 1);
+  CHECK(names.count("transformer_blocks.0.scale1") == 1);
+  CHECK(names.count("transformer_blocks.35.scale2") == 1);  // 36 blocks, 0..35
+  CHECK(names.count("transformer_blocks.36.scale2") == 0);
+  // post_quant_conv is kept (it is a REAL step, see below), quant_conv is not.
+  CHECK(names.count("post_quant_conv.weight") == 1);
+  CHECK(names.count("quant_conv.weight") == 0);
+  for (const std::string& n : names) CHECK(n.rfind("decoder.", 0) != 0);
+}
+
+TEST_CASE("minimax_h3: post_quant_conv is a real step, and it is a 1x1x1 channel mix") {
+  // This tensor sits OUTSIDE ViT3DDecoder, so the decoder gate (8.9e-8 against the
+  // checkpoint's own decoder, whose first op is x_embedder) never covered it and
+  // nothing in this port applied it. Loading it without applying it would be the
+  // worst outcome: a decode that runs, looks plausible, and is wrong.
+  //
+  // The real shape says exactly what it is.
+  auto shape_of = [](const std::string& want) {
+    for (int64_t i = 0; i < vllm_test::kH3VideoVaeTensorCount; ++i) {
+      if (want == vllm_test::kH3VideoVaeTensors[i].name) return vllm_test::kH3VideoVaeTensors[i];
+    }
+    FAIL("manifest is missing ", want);
+    return vllm_test::kH3VideoVaeTensors[0];
+  };
+  const auto pqc = shape_of("post_quant_conv.weight");
+  CHECK(pqc.rank == 5);
+  CHECK(pqc.shape[0] == 24);  // latent channels out
+  CHECK(pqc.shape[1] == 24);  // latent channels in
+  CHECK(pqc.shape[2] == 1);   // 1x1x1 -> a per-position CHANNEL MIX
+  CHECK(pqc.shape[3] == 1);
+  CHECK(pqc.shape[4] == 1);
+  // ...and it feeds x_embedder, which takes those same 24 channels.
+  const auto xe = shape_of("decoder.x_embedder.weight");
+  CHECK(xe.shape[1] == pqc.shape[0]);
+
+  // The implementation, checked against a hand-computed contraction.
+  const int64_t C = 3, P = 4;
+  vllm::MiniMaxH3AudioVaeWeights w;
+  w.tensors["post_quant_conv.weight"] = {1, 2, 3, 4, 5, 6, 7, 8, 9};  // [C, C]
+  w.tensors["post_quant_conv.bias"] = {0.5f, -0.5f, 1.0f};
+  std::vector<float> latent(static_cast<size_t>(C * P));
+  for (int64_t i = 0; i < C * P; ++i) latent[static_cast<size_t>(i)] = float(i + 1);
+  const std::vector<float> got = vllm::MiniMaxH3VideoVaePostQuantConv(w, latent, C, P);
+  REQUIRE(got.size() == latent.size());
+  for (int64_t o = 0; o < C; ++o) {
+    for (int64_t p = 0; p < P; ++p) {
+      double want = w.tensors["post_quant_conv.bias"][static_cast<size_t>(o)];
+      for (int64_t i = 0; i < C; ++i) {
+        want += w.tensors["post_quant_conv.weight"][static_cast<size_t>(o * C + i)] *
+                latent[static_cast<size_t>(i * P + p)];
+      }
+      CHECK(got[static_cast<size_t>(o * P + p)] == doctest::Approx(want).epsilon(1e-6));
+    }
+  }
+  // A channel MIX, not a passthrough: dropping it would change the decoder's input.
+  CHECK(got[0] != doctest::Approx(latent[0]));
+}
+
+TEST_CASE("minimax_h3: the encoder loader FUSES q/k/v and gate/up across shards") {
+  // The one loader that transforms rather than renames. HF ships q/k/v and gate/up
+  // SEPARATE (confirmed from the real FL2VA/text_encoder index: 1058 tensors, 64
+  // layers of model.language_model.layers.N.self_attn.{q,k,v}_proj); the port, like
+  // vLLM, consumes them FUSED. Row-concatenation ORDER is load-bearing: the forward
+  // slices qkv_proj at [0,q) / [q,q+kv) / [q+kv,...), so any other order silently
+  // feeds keys into the query path — which would still run, and still be wrong.
+  struct Entry {
+    std::string name;
+    std::vector<int64_t> shape;
+    std::vector<float> values;
+  };
+  const int64_t H = 8, QD = 16, KVD = 4, FF = 12;
+  auto make = [&](const std::string& name, const std::vector<int64_t>& shape) {
+    int64_t n = 1;
+    for (int64_t d : shape) n *= d;
+    return Entry{name, shape, MakeParam("enc." + name, n, 0.2)};
+  };
+
+  // Two shards, with one layer's tensors SPLIT across them — the case a
+  // single-shard test would miss entirely.
+  std::vector<std::vector<Entry>> shards(2);
+  const std::string lm = "model.language_model.layers.0.";
+  shards[0].push_back(make(lm + "input_layernorm.weight", {H}));
+  shards[0].push_back(make(lm + "post_attention_layernorm.weight", {H}));
+  shards[0].push_back(make(lm + "self_attn.q_proj.weight", {QD, H}));
+  shards[0].push_back(make(lm + "self_attn.q_norm.weight", {4}));
+  shards[0].push_back(make(lm + "self_attn.k_norm.weight", {4}));
+  shards[1].push_back(make(lm + "self_attn.k_proj.weight", {KVD, H}));
+  shards[1].push_back(make(lm + "self_attn.v_proj.weight", {KVD, H}));
+  shards[1].push_back(make(lm + "self_attn.o_proj.weight", {H, QD}));
+  shards[1].push_back(make(lm + "mlp.gate_proj.weight", {FF, H}));
+  shards[1].push_back(make(lm + "mlp.up_proj.weight", {FF, H}));
+  shards[1].push_back(make(lm + "mlp.down_proj.weight", {H, FF}));
+  // A second layer, so truncation has something to cut.
+  const std::string lm1 = "model.language_model.layers.1.";
+  shards[1].push_back(make(lm1 + "input_layernorm.weight", {H}));
+  shards[1].push_back(make(lm1 + "post_attention_layernorm.weight", {H}));
+  shards[1].push_back(make(lm1 + "self_attn.q_proj.weight", {QD, H}));
+  shards[1].push_back(make(lm1 + "self_attn.k_proj.weight", {KVD, H}));
+  shards[1].push_back(make(lm1 + "self_attn.v_proj.weight", {KVD, H}));
+  shards[1].push_back(make(lm1 + "self_attn.q_norm.weight", {4}));
+  shards[1].push_back(make(lm1 + "self_attn.k_norm.weight", {4}));
+  shards[1].push_back(make(lm1 + "self_attn.o_proj.weight", {H, QD}));
+  shards[1].push_back(make(lm1 + "mlp.gate_proj.weight", {FF, H}));
+  shards[1].push_back(make(lm1 + "mlp.up_proj.weight", {FF, H}));
+  shards[1].push_back(make(lm1 + "mlp.down_proj.weight", {H, FF}));
+  // Vision tower: already fused upstream, so it must pass through untouched.
+  shards[0].push_back(make("model.visual.blocks.0.attn.qkv.weight", {3 * H, H}));
+  shards[0].push_back(make("model.visual.patch_embed.proj.bias", {H}));
+  shards[0].push_back(make("model.visual.merger.norm.weight", {H}));
+  // Must NOT be loaded: H3 reads the UNNORMALIZED output, and lm_head is unused.
+  shards[1].push_back(make("model.language_model.norm.weight", {H}));
+  shards[1].push_back(make("lm_head.weight", {4, H}));
+
+  std::vector<std::string> paths;
+  for (size_t s = 0; s < shards.size(); ++s) {
+    std::string header = "{";
+    size_t offset = 0;
+    bool first = true;
+    for (const Entry& e : shards[s]) {
+      if (!first) header += ",";
+      first = false;
+      header += "\"" + e.name + "\":{\"dtype\":\"F32\",\"shape\":[";
+      for (size_t i = 0; i < e.shape.size(); ++i) {
+        if (i) header += ",";
+        header += std::to_string(e.shape[i]);
+      }
+      const size_t nbytes = e.values.size() * sizeof(float);
+      header += "],\"data_offsets\":[" + std::to_string(offset) + "," +
+                std::to_string(offset + nbytes) + "]}";
+      offset += nbytes;
+    }
+    header += "}";
+    const std::string path = "/tmp/minimax_h3_enc_shard" + std::to_string(s) + ".safetensors";
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    const uint64_t n = header.size();
+    std::fwrite(&n, sizeof(n), 1, fh);
+    std::fwrite(header.data(), 1, header.size(), fh);
+    for (const Entry& e : shards[s]) {
+      std::fwrite(e.values.data(), 1, e.values.size() * sizeof(float), fh);
+    }
+    std::fclose(fh);
+    paths.push_back(path);
+  }
+
+  std::vector<vllm::SafetensorsFile> files;
+  for (const std::string& p : paths) files.push_back(vllm::SafetensorsFile::Open(p));
+  const vllm::MiniMaxH3AudioVaeWeights w = vllm::LoadMiniMaxH3EncoderWeights(files);
+
+  // The fusion is byte-exact and IN ORDER: [q_all | k_all | v_all].
+  const std::vector<float>& qkv = w.Get("layers.0.self_attn.qkv_proj.weight");
+  const std::vector<float> q = MakeParam("enc." + lm + "self_attn.q_proj.weight", QD * H, 0.2);
+  const std::vector<float> k = MakeParam("enc." + lm + "self_attn.k_proj.weight", KVD * H, 0.2);
+  const std::vector<float> v = MakeParam("enc." + lm + "self_attn.v_proj.weight", KVD * H, 0.2);
+  REQUIRE(qkv.size() == q.size() + k.size() + v.size());
+  for (size_t i = 0; i < q.size(); ++i) CHECK(qkv[i] == q[i]);
+  for (size_t i = 0; i < k.size(); ++i) CHECK(qkv[q.size() + i] == k[i]);
+  for (size_t i = 0; i < v.size(); ++i) CHECK(qkv[q.size() + k.size() + i] == v[i]);
+
+  const std::vector<float>& gu = w.Get("layers.0.mlp.gate_up_proj.weight");
+  const std::vector<float> gate = MakeParam("enc." + lm + "mlp.gate_proj.weight", FF * H, 0.2);
+  const std::vector<float> up = MakeParam("enc." + lm + "mlp.up_proj.weight", FF * H, 0.2);
+  REQUIRE(gu.size() == gate.size() + up.size());
+  for (size_t i = 0; i < gate.size(); ++i) CHECK(gu[i] == gate[i]);
+  for (size_t i = 0; i < up.size(); ++i) CHECK(gu[gate.size() + i] == up[i]);
+
+  // The separate names must be GONE — leaving them would let a forward silently
+  // read an unfused tensor.
+  CHECK_FALSE(w.Has("layers.0.self_attn.q_proj.weight"));
+  CHECK_FALSE(w.Has("layers.0.mlp.gate_proj.weight"));
+
+  // Vision tower passes through, de-prefixed and unfused.
+  CHECK(w.Has("blocks.0.attn.qkv.weight"));
+  CHECK(w.Has("patch_embed.proj.bias"));
+  CHECK(w.Has("merger.norm.weight"));
+
+  // H3 deltas: NO final norm, no lm_head.
+  CHECK_FALSE(w.Has("norm.weight"));
+  CHECK_FALSE(w.Has("lm_head.weight"));
+
+  // Truncation: H3 keeps min(num_hidden_layers, 50); the file ships more.
+  CHECK(w.Has("layers.1.self_attn.qkv_proj.weight"));
+  const vllm::MiniMaxH3AudioVaeWeights trunc =
+      vllm::LoadMiniMaxH3EncoderWeights(files, /*max_layers=*/1);
+  CHECK(trunc.Has("layers.0.self_attn.qkv_proj.weight"));
+  CHECK_FALSE(trunc.Has("layers.1.self_attn.qkv_proj.weight"));
+}
+
+TEST_CASE("minimax_h3: the SHIPPED VAE config.json files parse into the decoders' configs") {
+  // Assembly needs the real configs, not hand-built ones — including the per-channel
+  // latents_mean/std the pipeline denormalizes with. Both files are embedded
+  // verbatim, so this gates the parsers against what the checkpoint ACTUALLY says.
+  const nlohmann::json audio_json = nlohmann::json::parse(vllm_test::kH3AudioVaeConfigJson);
+  vllm::MiniMaxH3LatentStats audio_stats;
+  const vllm::MiniMaxH3AudioVaeConfig audio =
+      vllm::ParseMiniMaxH3AudioVaeConfig(audio_json, &audio_stats);
+
+  // The subtlety: `latent_dim` (2048) is the MEL count BigVGAN consumes, while
+  // `latent_channels` (32) is the VAE latent width that dec_in_proj maps FROM.
+  // Reading the wrong one gives a decoder that is wrong by a factor of 64.
+  CHECK(audio.num_mels == 2048);
+  CHECK(audio.upsample_initial_channel == 1024);
+  CHECK(audio.upsample_rates == std::vector<int64_t>{5, 5, 2, 2, 2, 2, 2});
+  CHECK(audio.upsample_kernel_sizes == std::vector<int64_t>{9, 9, 4, 4, 4, 4, 4});
+  CHECK(audio.resblock_kernel_sizes == std::vector<int64_t>{3, 7, 11});
+  CHECK(audio.resblock_dilation_sizes.size() == 3);
+  // 7 upsample stages take 1024 channels down to 8, which is what conv_post reads
+  // (its real weight_v is [1, 8, 7]) — the config and the manifest agree.
+  int64_t ch = audio.upsample_initial_channel;
+  for (size_t i = 0; i < audio.upsample_rates.size(); ++i) ch /= 2;
+  CHECK(ch == 8);
+  CHECK(audio_stats.mean.size() == 32);  // per VAE latent channel
+  CHECK(audio_stats.std_dev.size() == 32);
+
+  const nlohmann::json video_json = nlohmann::json::parse(vllm_test::kH3VideoVaeConfigJson);
+  vllm::MiniMaxH3LatentStats video_stats;
+  const vllm::MiniMaxH3VideoVaeDecoderConfig video =
+      vllm::ParseMiniMaxH3VideoVaeDecoderConfig(video_json, &video_stats);
+  CHECK(video.num_layers == 36);
+  CHECK(video.in_channels == 24);
+  CHECK(video.out_channels == 3);
+  CHECK(video.num_register_tokens == 4);
+  CHECK(video.block.heads == 32);
+  CHECK(video.block.dim_head == 64);
+  CHECK(video.block.dim == 2048);
+  CHECK(video.block.ff_inner == 2048 * 4);
+  CHECK(video.rope_theta == doctest::Approx(100.0));
+  // rope_apply_dim = int(dim_head * rope_dim_ratio) = int(64 * 0.75).
+  CHECK(video.rope_apply_dim == 48);
+  CHECK(video_stats.mean.size() == 24);  // per video latent channel
+  CHECK(video_stats.std_dev.size() == 24);
+
+  // The parsed geometry must agree with the REAL manifest, not just with itself:
+  // x_embedder maps latent channels -> model dim.
+  for (int64_t i = 0; i < vllm_test::kH3VideoVaeTensorCount; ++i) {
+    if (std::string("decoder.x_embedder.weight") == vllm_test::kH3VideoVaeTensors[i].name) {
+      CHECK(vllm_test::kH3VideoVaeTensors[i].shape[0] == video.block.dim);
+      CHECK(vllm_test::kH3VideoVaeTensors[i].shape[1] == video.in_channels);
+    }
+  }
+}
+
+TEST_CASE("minimax_h3: the encoder GGUF loads KEEP-QUANT and fuses on QUANTIZED bytes") {
+  // The encoder is 32B, so f32 materialization (~128 GB) does not fit the box we
+  // test on; keeping the ggml blocks holds it at ~14.6 GB. The interesting claim is
+  // that the q/k/v and gate/up fusions can be done on the QUANTIZED bytes: ggml rows
+  // are independent block sequences, so concatenating whole rows yields a valid
+  // block-quant tensor — no dequantize/requantize round trip, and no precision lost
+  // to one. This asserts that byte-for-byte.
+  const int64_t H = 256;    // hidden (a whole number of Q8_0 blocks)
+  const int64_t QD = 128, KVD = 64, FF = 512;
+
+  gguf_test::GgufModelBuilder builder;
+  builder.AddKv(gguf_test::StrKv("general.architecture", "qwen3vl"));
+  std::map<std::string, std::string> raw;  // logical name -> the exact bytes written
+  auto add_q8 = [&](const std::string& name, int64_t out_dim, int64_t in_dim) {
+    const std::vector<float> values = MakeParam("encq." + name, out_dim * in_dim, 0.1);
+    const size_t row_bytes = vt::RowSizeBytes(vt::DType::kQ8_0, in_dim);
+    std::string bytes(static_cast<size_t>(out_dim) * row_bytes, '\0');
+    vt::cpu::FromFloatFn q = vt::cpu::BlockFromFloat(vt::DType::kQ8_0);
+    REQUIRE(q != nullptr);
+    for (int64_t r = 0; r < out_dim; ++r) {
+      q(values.data() + r * in_dim, bytes.data() + static_cast<size_t>(r) * row_bytes, in_dim);
+    }
+    raw[name] = bytes;
+    builder.AddTensor(name, {static_cast<uint64_t>(in_dim), static_cast<uint64_t>(out_dim)},
+                      /*ggml_type=*/8 /*Q8_0*/, bytes);
+  };
+  auto add_f32 = [&](const std::string& name, const std::vector<int64_t>& logical) {
+    int64_t n = 1;
+    for (int64_t d : logical) n *= d;
+    const std::vector<float> v = MakeParam("encq." + name, n, 0.1);
+    std::string bytes(reinterpret_cast<const char*>(v.data()), v.size() * sizeof(float));
+    std::vector<uint64_t> ne;
+    for (auto it = logical.rbegin(); it != logical.rend(); ++it) ne.push_back(uint64_t(*it));
+    builder.AddTensor(name, ne, /*ggml_type=*/0, bytes);
+  };
+
+  for (int layer = 0; layer < 2; ++layer) {
+    const std::string p = "model.layers." + std::to_string(layer) + ".";
+    add_f32(p + "input_layernorm.weight", {H});
+    add_f32(p + "post_attention_layernorm.weight", {H});
+    add_f32(p + "self_attn.q_norm.weight", {64});
+    add_f32(p + "self_attn.k_norm.weight", {64});
+    add_q8(p + "self_attn.q_proj.weight", QD, H);
+    add_q8(p + "self_attn.k_proj.weight", KVD, H);
+    add_q8(p + "self_attn.v_proj.weight", KVD, H);
+    add_q8(p + "self_attn.o_proj.weight", H, QD);
+    add_q8(p + "mlp.gate_proj.weight", FF, H);
+    add_q8(p + "mlp.up_proj.weight", FF, H);
+    add_q8(p + "mlp.down_proj.weight", H, FF);
+  }
+  add_q8("model.embed_tokens.weight", 512, H);
+  add_f32("model.norm.weight", {H});  // must NOT be bound (H3 reads unnormalized)
+
+  const std::string path = "/tmp/minimax_h3_enc_q.gguf";
+  {
+    const std::string bytes = builder.Build();
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    CHECK(std::fwrite(bytes.data(), 1, bytes.size(), fh) == bytes.size());
+    std::fclose(fh);
+  }
+
+  const vllm::GgufFile gguf = vllm::GgufFile::Open(path);
+  const vllm::MiniMaxH3EncoderQuantWeights w = vllm::LoadMiniMaxH3EncoderFromGguf(gguf);
+
+  // Projections stayed QUANTIZED.
+  CHECK(w.Get("layers.0.self_attn.qkv_proj.weight").dtype == vt::DType::kQ8_0);
+  CHECK(w.Get("layers.0.mlp.gate_up_proj.weight").dtype == vt::DType::kQ8_0);
+  CHECK(w.Get("layers.0.self_attn.o_proj.weight").dtype == vt::DType::kQ8_0);
+  CHECK(w.Get("embed_tokens.weight").dtype == vt::DType::kQ8_0);
+  // Norms are f32.
+  CHECK(w.Get("layers.0.input_layernorm.weight").dtype == vt::DType::kF32);
+
+  // THE CLAIM: the fused tensor's bytes are exactly q ++ k ++ v.
+  const std::string& q = raw["model.layers.0.self_attn.q_proj.weight"];
+  const std::string& k = raw["model.layers.0.self_attn.k_proj.weight"];
+  const std::string& v = raw["model.layers.0.self_attn.v_proj.weight"];
+  const vt::Tensor& fused = w.Get("layers.0.self_attn.qkv_proj.weight");
+  CHECK(fused.shape[0] == QD + 2 * KVD);
+  CHECK(fused.shape[1] == H);
+  const uint8_t* fb = static_cast<const uint8_t*>(fused.data);
+  const std::string want = q + k + v;
+  REQUIRE(vt::RowSizeBytes(vt::DType::kQ8_0, H) * (QD + 2 * KVD) == want.size());
+  bool same = true;
+  for (size_t i = 0; i < want.size(); ++i) {
+    if (fb[i] != static_cast<uint8_t>(want[i])) { same = false; break; }
+  }
+  CHECK(same);  // byte-for-byte, in [q|k|v] order
+
+  const std::string& gate = raw["model.layers.0.mlp.gate_proj.weight"];
+  const std::string& up = raw["model.layers.0.mlp.up_proj.weight"];
+  const vt::Tensor& gu = w.Get("layers.0.mlp.gate_up_proj.weight");
+  CHECK(gu.shape[0] == 2 * FF);
+  const uint8_t* gb = static_cast<const uint8_t*>(gu.data);
+  const std::string want2 = gate + up;
+  bool same2 = true;
+  for (size_t i = 0; i < want2.size(); ++i) {
+    if (gb[i] != static_cast<uint8_t>(want2[i])) { same2 = false; break; }
+  }
+  CHECK(same2);
+
+  // The separate names are gone, and H3's deltas hold.
+  CHECK_FALSE(w.Has("layers.0.self_attn.q_proj.weight"));
+  CHECK_FALSE(w.Has("norm.weight"));       // UNNORMALIZED output
+  CHECK_FALSE(w.Has("model.norm.weight"));
+
+  // Geometry recovered from the fused shapes alone.
+  CHECK(w.config.hidden_size == H);
+  CHECK(w.config.head_dim == 64);
+  CHECK(w.config.num_attention_heads == QD / 64);
+  CHECK(w.config.num_key_value_heads == KVD / 64);
+  CHECK(w.config.intermediate_size == FF);
+  CHECK(w.config.num_hidden_layers == 2);
+
+  // MIXED ENCODINGS. The SHIPPED Q4_K_M encoder stores v_proj as Q6_K while
+  // q_proj/k_proj are Q4_K (the usual K_M recipe of keeping V at higher precision),
+  // so that group CANNOT be byte-concatenated. The loader must keep the members
+  // SEPARATE rather than dequantize to force a fusion — which would throw away
+  // exactly the precision the recipe exists to keep.
+  {
+    gguf_test::GgufModelBuilder mixed;
+    mixed.AddKv(gguf_test::StrKv("general.architecture", "qwen3vl"));
+    // Only Q8_0 has a CPU quantizer, so the second encoding is written as
+    // correctly-SIZED arbitrary bytes. That is enough and it is honest: this test
+    // exercises the loader's ROUTING decision (mixed encodings => keep separate),
+    // and the loader copies bytes without interpreting them. Nothing here
+    // dequantizes, so no real Q4_0 payload is needed.
+    auto add_typed = [&](const std::string& name, int64_t out_dim, int64_t in_dim,
+                         vt::DType dt, uint32_t ggml_type) {
+      const size_t row_bytes = vt::RowSizeBytes(dt, in_dim);
+      std::string bytes(static_cast<size_t>(out_dim) * row_bytes, '\0');
+      vt::cpu::FromFloatFn q = vt::cpu::BlockFromFloat(dt);
+      if (q != nullptr) {
+        const std::vector<float> values = MakeParam("encm." + name, out_dim * in_dim, 0.1);
+        for (int64_t r = 0; r < out_dim; ++r) {
+          q(values.data() + r * in_dim, bytes.data() + static_cast<size_t>(r) * row_bytes, in_dim);
+        }
+      } else {
+        for (size_t i = 0; i < bytes.size(); ++i) {
+          bytes[i] = static_cast<char>((i * 31 + 7) & 0xFF);
+        }
+      }
+      mixed.AddTensor(name, {static_cast<uint64_t>(in_dim), static_cast<uint64_t>(out_dim)},
+                      ggml_type, bytes);
+    };
+    auto add_f32m = [&](const std::string& name, const std::vector<int64_t>& logical) {
+      int64_t n = 1;
+      for (int64_t d : logical) n *= d;
+      const std::vector<float> v = MakeParam("encm." + name, n, 0.1);
+      std::string bytes(reinterpret_cast<const char*>(v.data()), v.size() * sizeof(float));
+      std::vector<uint64_t> ne;
+      for (auto it = logical.rbegin(); it != logical.rend(); ++it) ne.push_back(uint64_t(*it));
+      mixed.AddTensor(name, ne, 0, bytes);
+    };
+    const std::string pm = "model.layers.0.";
+    add_f32m(pm + "input_layernorm.weight", {H});
+    add_f32m(pm + "post_attention_layernorm.weight", {H});
+    add_f32m(pm + "self_attn.q_norm.weight", {64});
+    add_f32m(pm + "self_attn.k_norm.weight", {64});
+    add_typed(pm + "self_attn.q_proj.weight", QD, H, vt::DType::kQ8_0, 8);
+    add_typed(pm + "self_attn.k_proj.weight", KVD, H, vt::DType::kQ8_0, 8);
+    add_typed(pm + "self_attn.v_proj.weight", KVD, H, vt::DType::kQ4_0, 2);  // the odd one
+    add_typed(pm + "self_attn.o_proj.weight", H, QD, vt::DType::kQ8_0, 8);
+    add_typed(pm + "mlp.gate_proj.weight", FF, H, vt::DType::kQ8_0, 8);
+    add_typed(pm + "mlp.up_proj.weight", FF, H, vt::DType::kQ8_0, 8);
+    add_typed(pm + "mlp.down_proj.weight", H, FF, vt::DType::kQ8_0, 8);
+
+    const std::string mpath = "/tmp/minimax_h3_enc_mixed.gguf";
+    const std::string mbytes = mixed.Build();
+    FILE* mf = std::fopen(mpath.c_str(), "wb");
+    REQUIRE(mf != nullptr);
+    CHECK(std::fwrite(mbytes.data(), 1, mbytes.size(), mf) == mbytes.size());
+    std::fclose(mf);
+
+    const vllm::GgufFile mg = vllm::GgufFile::Open(mpath);
+    const vllm::MiniMaxH3EncoderQuantWeights mw = vllm::LoadMiniMaxH3EncoderFromGguf(mg);
+    // qkv could NOT fuse: the members stay separate, each in its OWN encoding.
+    CHECK_FALSE(mw.Has("layers.0.self_attn.qkv_proj.weight"));
+    REQUIRE(mw.Has("layers.0.self_attn.q_proj.weight"));
+    REQUIRE(mw.Has("layers.0.self_attn.v_proj.weight"));
+    CHECK(mw.Get("layers.0.self_attn.q_proj.weight").dtype == vt::DType::kQ8_0);
+    CHECK(mw.Get("layers.0.self_attn.v_proj.weight").dtype == vt::DType::kQ4_0);
+    // gate/up ARE uniform, so they still fuse.
+    CHECK(mw.Has("layers.0.mlp.gate_up_proj.weight"));
+    // Geometry must still come out right from the UNFUSED shapes.
+    CHECK(mw.config.hidden_size == H);
+    CHECK(mw.config.num_attention_heads == QD / 64);
+    CHECK(mw.config.num_key_value_heads == KVD / 64);
+    CHECK(mw.config.intermediate_size == FF);
+  }
+
+  // Truncation, which is how H3 keeps min(num_hidden_layers, 50).
+  const vllm::MiniMaxH3EncoderQuantWeights t1 =
+      vllm::LoadMiniMaxH3EncoderFromGguf(gguf, /*max_layers=*/1);
+  CHECK(t1.Has("layers.0.self_attn.qkv_proj.weight"));
+  CHECK_FALSE(t1.Has("layers.1.self_attn.qkv_proj.weight"));
+  CHECK(t1.config.num_hidden_layers == 1);
+}
+
+TEST_CASE("minimax_h3: the DEVICE keep-quant encoder matches the host f32 reference") {
+  // The conditioning path end to end: a GGUF is loaded KEEP-QUANT, staged to a
+  // device, and its tower run through vt ops — against the gated host f32 reference
+  // over the SAME weights. The tolerance is Q8_0's, not f32's: the two paths differ
+  // by the quantization of the projections, which is the whole point of the arm.
+  const int64_t H = 128, HEADS = 4, KV = 2, HD = 32, FF = 256, SEQ = 6, LAYERS = 2;
+  REQUIRE(HEADS * HD == 128);
+
+  gguf_test::GgufModelBuilder builder;
+  builder.AddKv(gguf_test::StrKv("general.architecture", "qwen3vl"));
+  std::map<std::string, std::vector<float>> f32;  // the SAME values the host gets
+  auto add_q8 = [&](const std::string& gguf_name, const std::string& host_name, int64_t out_dim,
+                    int64_t in_dim) {
+    std::vector<float> values = MakeParam("encd." + gguf_name, out_dim * in_dim, 0.08);
+    const size_t row_bytes = vt::RowSizeBytes(vt::DType::kQ8_0, in_dim);
+    std::string bytes(static_cast<size_t>(out_dim) * row_bytes, '\0');
+    vt::cpu::FromFloatFn q = vt::cpu::BlockFromFloat(vt::DType::kQ8_0);
+    REQUIRE(q != nullptr);
+    for (int64_t r = 0; r < out_dim; ++r) {
+      q(values.data() + r * in_dim, bytes.data() + static_cast<size_t>(r) * row_bytes, in_dim);
+    }
+    // The host reference must see the DEQUANTIZED values, so the only difference
+    // between the two paths is where the quantization error enters — not the model.
+    f32[host_name] = vllm::DequantGgufRowToF32(8, reinterpret_cast<const uint8_t*>(bytes.data()),
+                                               out_dim * in_dim);
+    builder.AddTensor(gguf_name, {static_cast<uint64_t>(in_dim), static_cast<uint64_t>(out_dim)},
+                      8, bytes);
+  };
+  auto add_f32 = [&](const std::string& gguf_name, const std::string& host_name,
+                     const std::vector<int64_t>& logical) {
+    int64_t n = 1;
+    for (int64_t d : logical) n *= d;
+    std::vector<float> v = MakeParam("encd." + gguf_name, n, 0.1);
+    f32[host_name] = v;
+    std::string bytes(reinterpret_cast<const char*>(v.data()), v.size() * sizeof(float));
+    std::vector<uint64_t> ne;
+    for (auto it = logical.rbegin(); it != logical.rend(); ++it) ne.push_back(uint64_t(*it));
+    builder.AddTensor(gguf_name, ne, 0, bytes);
+  };
+
+  for (int64_t l = 0; l < LAYERS; ++l) {
+    const std::string g = "model.layers." + std::to_string(l) + ".";
+    const std::string hn = "layers." + std::to_string(l) + ".";
+    add_f32(g + "input_layernorm.weight", hn + "input_layernorm.weight", {H});
+    add_f32(g + "post_attention_layernorm.weight", hn + "post_attention_layernorm.weight", {H});
+    add_f32(g + "self_attn.q_norm.weight", hn + "self_attn.q_norm.weight", {HD});
+    add_f32(g + "self_attn.k_norm.weight", hn + "self_attn.k_norm.weight", {HD});
+    add_q8(g + "self_attn.q_proj.weight", "", HEADS * HD, H);
+    add_q8(g + "self_attn.k_proj.weight", "", KV * HD, H);
+    add_q8(g + "self_attn.v_proj.weight", "", KV * HD, H);
+    add_q8(g + "self_attn.o_proj.weight", hn + "self_attn.o_proj.weight", H, HEADS * HD);
+    add_q8(g + "mlp.gate_proj.weight", "", FF, H);
+    add_q8(g + "mlp.up_proj.weight", "", FF, H);
+    add_q8(g + "mlp.down_proj.weight", hn + "mlp.down_proj.weight", H, FF);
+  }
+
+  const std::string path = "/tmp/minimax_h3_enc_dev.gguf";
+  {
+    const std::string bytes = builder.Build();
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    CHECK(std::fwrite(bytes.data(), 1, bytes.size(), fh) == bytes.size());
+    std::fclose(fh);
+  }
+  const vllm::GgufFile gguf = vllm::GgufFile::Open(path);
+  const vllm::MiniMaxH3EncoderQuantWeights kq = vllm::LoadMiniMaxH3EncoderFromGguf(gguf);
+  REQUIRE(kq.config.hidden_size == H);
+  REQUIRE(kq.config.num_attention_heads == HEADS);
+  REQUIRE(kq.config.num_key_value_heads == KV);
+
+  // Build the HOST reference's weights from the loader's own (fused) tensors, so
+  // both paths see identical numbers — the fused qkv/gate_up are what the host
+  // forward reads.
+  vllm::MiniMaxH3AudioVaeWeights host;
+  for (const auto& kv : kq.views) {
+    const vt::Tensor& tt = kv.second;
+    if (vt::IsBlockQuant(tt.dtype)) {
+      host.tensors[kv.first] = vllm::DequantGgufRowToF32(
+          8, static_cast<const uint8_t*>(tt.data), tt.shape[0] * tt.shape[1]);
+    } else {
+      host.tensors[kv.first] =
+          std::vector<float>(tt.Ptr<float>(), tt.Ptr<float>() + tt.Numel());
+    }
+  }
+
+  vllm::MiniMaxH3EncoderConfig cfg = kq.config;
+  cfg.selected_layer = LAYERS;
+  cfg.mrope_section = {4, 3, 3};
+  cfg.rope_theta = 10000.0;
+
+  const std::vector<float> embeds = MakeParam("encd.embeds", SEQ * H, 1.0);
+  std::vector<int64_t> pos(static_cast<size_t>(3 * SEQ));
+  for (int64_t a = 0; a < 3; ++a) {
+    for (int64_t s = 0; s < SEQ; ++s) pos[static_cast<size_t>(a * SEQ + s)] = s;
+  }
+
+  const std::vector<float> want = vllm::MiniMaxH3EncoderTextForward(
+      cfg, host, embeds, pos.data(), SEQ, /*visual_pos_mask=*/nullptr, {});
+
+  vt::Queue q{Cpu(), nullptr};
+  const vllm::MiniMaxH3EncoderDeviceWeights staged =
+      vllm::StageMiniMaxH3EncoderWeights(q, kq);
+  const std::vector<float> got = vllm::MiniMaxH3EncoderTextForwardDevice(
+      q, cfg, staged, embeds, pos.data(), SEQ);
+
+  REQUIRE(got.size() == want.size());
+  double err = 0.0, mag = 0.0;
+  for (size_t i = 0; i < want.size(); ++i) {
+    err = std::max(err, std::abs(static_cast<double>(got[i] - want[i])));
+    mag = std::max(mag, std::abs(static_cast<double>(want[i])));
+  }
+  INFO("device keep-quant encoder vs host reference: max|diff| = " << err << " (scale " << mag << ")");
+  CHECK(err <= 2e-3);
+  CHECK(mag > 1e-3);  // the tower produced something, not zeros
+  for (float v : got) REQUIRE(std::isfinite(v));
+}
+
+TEST_CASE("minimax_h3: the embedding gather decodes ONLY the rows it needs, exactly") {
+  // The table is [151936, 5120] — ~1.5 GB even quantized — and a prompt touches a
+  // few dozen rows, so the gather decodes rows individually. That is only valid
+  // because ggml rows are independent block sequences; this asserts a row-wise
+  // gather is BIT-IDENTICAL to slicing a full-table dequant.
+  const int64_t VOCAB = 64, HID = 128;
+  const std::vector<float> values = MakeParam("emb.table", VOCAB * HID, 0.5);
+  const size_t row_bytes = vt::RowSizeBytes(vt::DType::kQ8_0, HID);
+  std::string bytes(static_cast<size_t>(VOCAB) * row_bytes, '\0');
+  vt::cpu::FromFloatFn q = vt::cpu::BlockFromFloat(vt::DType::kQ8_0);
+  REQUIRE(q != nullptr);
+  for (int64_t r = 0; r < VOCAB; ++r) {
+    q(values.data() + r * HID, bytes.data() + static_cast<size_t>(r) * row_bytes, HID);
+  }
+
+  gguf_test::GgufModelBuilder b;
+  b.AddKv(gguf_test::StrKv("general.architecture", "qwen3vl"));
+  b.AddTensor("model.embed_tokens.weight", {static_cast<uint64_t>(HID), static_cast<uint64_t>(VOCAB)},
+              8, bytes);
+  // One layer, so the loader has a tower to recover geometry from.
+  auto f32t = [&](const std::string& n, const std::vector<int64_t>& shape) {
+    int64_t nn = 1;
+    for (int64_t d : shape) nn *= d;
+    const std::vector<float> v = MakeParam("emb." + n, nn, 0.1);
+    std::string bb(reinterpret_cast<const char*>(v.data()), v.size() * sizeof(float));
+    std::vector<uint64_t> ne;
+    for (auto it = shape.rbegin(); it != shape.rend(); ++it) ne.push_back(uint64_t(*it));
+    b.AddTensor(n, ne, 0, bb);
+  };
+  auto q8t = [&](const std::string& n, int64_t o, int64_t i) {
+    const std::vector<float> v = MakeParam("emb." + n, o * i, 0.1);
+    const size_t rb = vt::RowSizeBytes(vt::DType::kQ8_0, i);
+    std::string bb(static_cast<size_t>(o) * rb, '\0');
+    for (int64_t r = 0; r < o; ++r) q(v.data() + r * i, bb.data() + static_cast<size_t>(r) * rb, i);
+    b.AddTensor(n, {static_cast<uint64_t>(i), static_cast<uint64_t>(o)}, 8, bb);
+  };
+  const std::string pl = "model.layers.0.";
+  f32t(pl + "input_layernorm.weight", {HID});
+  f32t(pl + "post_attention_layernorm.weight", {HID});
+  f32t(pl + "self_attn.q_norm.weight", {32});
+  f32t(pl + "self_attn.k_norm.weight", {32});
+  q8t(pl + "self_attn.q_proj.weight", 128, HID);
+  q8t(pl + "self_attn.k_proj.weight", 64, HID);
+  q8t(pl + "self_attn.v_proj.weight", 64, HID);
+  q8t(pl + "self_attn.o_proj.weight", HID, 128);
+  q8t(pl + "mlp.gate_proj.weight", 256, HID);
+  q8t(pl + "mlp.up_proj.weight", 256, HID);
+  q8t(pl + "mlp.down_proj.weight", HID, 256);
+
+  const std::string path = "/tmp/minimax_h3_emb.gguf";
+  {
+    const std::string blob = b.Build();
+    FILE* fh = std::fopen(path.c_str(), "wb");
+    REQUIRE(fh != nullptr);
+    CHECK(std::fwrite(blob.data(), 1, blob.size(), fh) == blob.size());
+    std::fclose(fh);
+  }
+  const vllm::GgufFile g = vllm::GgufFile::Open(path);
+  const vllm::MiniMaxH3EncoderQuantWeights w = vllm::LoadMiniMaxH3EncoderFromGguf(g);
+  REQUIRE(w.Has("embed_tokens.weight"));
+  CHECK(w.Get("embed_tokens.weight").dtype == vt::DType::kQ8_0);  // stayed quantized
+
+  // The oracle: dequantize the WHOLE table once, then slice.
+  const std::vector<float> full = vllm::DequantGgufRowToF32(
+      8, reinterpret_cast<const uint8_t*>(bytes.data()), VOCAB * HID);
+
+  const std::vector<int32_t> ids = {0, 7, 63, 7, 1};  // includes a repeat and both ends
+  const std::vector<float> got = vllm::MiniMaxH3EncoderEmbedTokens(w, ids);
+  REQUIRE(got.size() == ids.size() * static_cast<size_t>(HID));
+  for (size_t i = 0; i < ids.size(); ++i) {
+    for (int64_t c = 0; c < HID; ++c) {
+      // BIT-identical, not approximate: same bytes through the same decoder.
+      CHECK(got[i * HID + c] == full[static_cast<size_t>(ids[i]) * HID + c]);
+    }
+  }
+  // An out-of-range id must THROW rather than read past the table.
+  CHECK_THROWS(vllm::MiniMaxH3EncoderEmbedTokens(w, {VOCAB}));
+  CHECK_THROWS(vllm::MiniMaxH3EncoderEmbedTokens(w, {-1}));
+}
diff --git a/tests/vt/test_ops_dflash_block_attn.cpp b/tests/vt/test_ops_dflash_block_attn.cpp
index e28e923e8..c6e7f0800 100644
--- a/tests/vt/test_ops_dflash_block_attn.cpp
+++ b/tests/vt/test_ops_dflash_block_attn.cpp
@@ -8,6 +8,7 @@
 // that causal != non-causal so a wrong mask is CAUGHT.
 #include <doctest/doctest.h>
 
+#include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <vector>
@@ -279,4 +280,488 @@ TEST_CASE("dflash-block-attn CUDA matches CPU across the 5 semantic corners") {
   RunCudaParity(17, 8, 2, 32, 0.3f, /*causal=*/true, /*window=*/4, {0, 17}, 4444);
   // (5) GQA extreme (8 q-heads share 1 kv-head) + ragged multi-block causal.
   RunCudaParity(20, 8, 1, 16, 0.35f, /*causal=*/true, /*window=*/2048, {0, 6, 20}, 5555);
+  // (6) head_dim 96 -- MiniMax-H3's PRODUCTION shape (hidden 5376 / 56 heads), and
+  // the only head_dim that is a whole number of warp widths but NOT a power of two.
+  // Nothing in this file covered it before, so the CUDA fast path's head_dim/32 == 3
+  // instantiation shipped UNEXERCISED while the suite reported green -- and it is
+  // precisely the instantiation whose per-lane element partition differs from the
+  // 64/128 ones (strided rather than contiguous-vector, to keep loads coalesced).
+  RunCudaParity(17, 8, 2, 96, std::pow(96.0f, -0.5f), /*causal=*/false, 0, {0, 17}, 6666);
+  RunCudaParity(20, 8, 2, 96, std::pow(96.0f, -0.5f), /*causal=*/true, /*window=*/6,
+                {0, 6, 20}, 7777);
+}
+
+// The LONG non-causal single-document case, which is the only shape that reaches
+// the shared-memory tiled CUDA kernel (guarded to !causal, num_reqs == 1, no
+// window, seq >= 2048). Every other case in this file is far shorter, so without
+// this the tiled path ships UNEXERCISED while the suite reports green -- the exact
+// failure mode where a gate proves something other than what it appears to.
+//
+// Gated against the CPU reference over identical inputs. The tiled kernel keeps
+// the same key order and the same online-softmax recurrence as the untiled one, so
+// the bar is tight rather than merely "close".
+// H3's REAL packed shape: cu_seqlens {0, used, seq_len} -- content plus a padding
+// tail, i.e. TWO documents, not one. The first version of the tiled kernel was
+// guarded to num_reqs == 1 and therefore never ran on the very workload it was
+// written for, while the suite stayed green. This covers both branches: blocks
+// wholly inside one request take the shared-tile path, and the block straddling
+// the boundary takes the per-warp fallback.
+TEST_CASE("dflash-block-attn LONG multi-request matches the reference (H3 packed shape)") {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  const int64_t T = 3000, H = 2, D = 64;
+  const int32_t used = 2317;  // deliberately NOT a multiple of the 8-warp block
+  std::vector<float> q(static_cast<size_t>(T * H * D));
+  std::vector<float> k(q.size()), v(q.size());
+  uint64_t x = 0xD1B54A32D192ED03ULL;
+  auto rnd = [&]() {
+    x ^= x << 13; x ^= x >> 7; x ^= x << 17;
+    return static_cast<float>((x >> 40) / 16777216.0 - 0.5);
+  };
+  for (size_t i = 0; i < q.size(); ++i) { q[i] = rnd(); k[i] = rnd(); v[i] = rnd(); }
+  const int32_t cu[3] = {0, used, static_cast<int32_t>(T)};
+
+  std::vector<float> want(q.size(), 0.0f);
+  {
+    Queue cq = Q();
+    Tensor qt = F32(q, {T, H, D}), kt = F32(k, {T, H, D}), vt_ = F32(v, {T, H, D});
+    Tensor ot = F32(want, {T, H, D});
+    vt::DFlashBlockAttention(cq, ot, qt, kt, vt_, Args(cu, 2, /*causal=*/false, 0));
+  }
+
+  Queue gq = cuda->CreateQueue();
+  auto up = [&](const std::vector<float>& hv) {
+    void* p = cuda->Alloc(hv.size() * sizeof(float));
+    cuda->Copy(gq, p, hv.data(), hv.size() * sizeof(float));
+    return p;
+  };
+  void* dq = up(q); void* dk = up(k); void* dv = up(v);
+  void* dout = cuda->Alloc(q.size() * sizeof(float));
+  Device gd = gq.device;
+  Tensor gqt = Contig(dq, DType::kF32, gd, {T, H, D});
+  Tensor gkt = Contig(dk, DType::kF32, gd, {T, H, D});
+  Tensor gvt = Contig(dv, DType::kF32, gd, {T, H, D});
+  Tensor got = Contig(dout, DType::kF32, gd, {T, H, D});
+  vt::DFlashBlockAttention(gq, got, gqt, gkt, gvt, Args(cu, 2, /*causal=*/false, 0));
+  cuda->Synchronize(gq);
+  std::vector<float> got_host(q.size(), 0.0f);
+  cuda->Copy(gq, got_host.data(), dout, got_host.size() * sizeof(float));
+  cuda->Synchronize(gq);
+
+  double worst = 0.0;
+  for (size_t i = 0; i < want.size(); ++i) {
+    REQUIRE(std::isfinite(got_host[i]));
+    worst = std::max(worst, std::abs(static_cast<double>(got_host[i]) - want[i]));
+  }
+  INFO("tiled CUDA multi-request vs CPU reference, max|diff| = " << worst);
+  CHECK(worst <= 2e-5);
+  cuda->Free(dq); cuda->Free(dk); cuda->Free(dv); cuda->Free(dout);
+}
+
+TEST_CASE("dflash-block-attn LONG non-causal matches the reference (tiled CUDA path)") {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+
+  const int64_t T = 2560, H = 2, D = 64;  // T >= 2048 crosses the tiled threshold
+  std::vector<float> q(static_cast<size_t>(T * H * D));
+  std::vector<float> k(q.size()), v(q.size());
+  uint64_t x = 0x9E3779B97F4A7C15ULL;
+  auto rnd = [&]() {
+    x ^= x << 13; x ^= x >> 7; x ^= x << 17;
+    return static_cast<float>((x >> 40) / 16777216.0 - 0.5);
+  };
+  for (size_t i = 0; i < q.size(); ++i) { q[i] = rnd(); k[i] = rnd(); v[i] = rnd(); }
+
+  const int32_t cu[2] = {0, static_cast<int32_t>(T)};
+  std::vector<float> want(q.size(), 0.0f);
+  {
+    Queue cq = Q();
+    Tensor qt = F32(q, {T, H, D}), kt = F32(k, {T, H, D}), vt_ = F32(v, {T, H, D});
+    Tensor ot = F32(want, {T, H, D});
+    vt::DFlashBlockAttention(cq, ot, qt, kt, vt_, Args(cu, 1, /*causal=*/false, 0));
+  }
+
+  Queue gq = cuda->CreateQueue();
+  auto up = [&](const std::vector<float>& hostv) {
+    void* p = cuda->Alloc(hostv.size() * sizeof(float));
+    cuda->Copy(gq, p, hostv.data(), hostv.size() * sizeof(float));
+    return p;
+  };
+  void* dq = up(q);
+  void* dk = up(k);
+  void* dv = up(v);
+  void* dout = cuda->Alloc(q.size() * sizeof(float));
+  Device gdev = gq.device;
+  Tensor gqt = Contig(dq, DType::kF32, gdev, {T, H, D});
+  Tensor gkt = Contig(dk, DType::kF32, gdev, {T, H, D});
+  Tensor gvt = Contig(dv, DType::kF32, gdev, {T, H, D});
+  Tensor got = Contig(dout, DType::kF32, gdev, {T, H, D});
+  vt::DFlashBlockAttention(gq, got, gqt, gkt, gvt, Args(cu, 1, /*causal=*/false, 0));
+  cuda->Synchronize(gq);
+
+  std::vector<float> got_host(q.size(), 0.0f);
+  cuda->Copy(gq, got_host.data(), dout, got_host.size() * sizeof(float));
+  cuda->Synchronize(gq);
+
+  double worst = 0.0;
+  for (size_t i = 0; i < want.size(); ++i) {
+    REQUIRE(std::isfinite(got_host[i]));
+    worst = std::max(worst, std::abs(static_cast<double>(got_host[i]) - want[i]));
+  }
+  INFO("tiled CUDA vs CPU reference over " << T << " keys, max|diff| = " << worst);
+  CHECK(worst <= 2e-5);
+
+  cuda->Free(dq); cuda->Free(dk); cuda->Free(dv); cuda->Free(dout);
+}
+
+namespace {
+
+// LONG CUDA-vs-CPU parity over an arbitrary mask.
+//
+// Both LONG cases above are NON-CAUSAL SINGLE-DOCUMENT, which is the easiest mask
+// there is: every query sees exactly the same key range, so any kernel that gets
+// the range right ONCE is right for all of them. Nothing in this file previously
+// combined a long sequence with a mask that VARIES per query -- causal (jhi moves),
+// sliding-window (jlo moves too) or ragged multi-request (queries in one warp
+// belong to different documents). Those are where per-query bookkeeping and warp
+// scheduling can disagree, and where a long-sequence kernel is most likely to be
+// wrong in a way the short cases cannot see.
+//
+// These were added while evaluating the Q-blocked kernel (DFlashAttnQBlockKernel,
+// which walks the UNION of a warp's key ranges and skips per query -- exactly the
+// logic a non-causal single document cannot exercise). That kernel measured
+// NEGATIVE and is not dispatched, but the gaps these cases close are properties of
+// the OP, not of that experiment, so they stay.
+//
+// cu_seqlens must span [0,T] (vt::DFlashBlockAttention's precondition), so the
+// documents always tile the whole tensor; raggedness comes from the boundaries
+// sitting off any warp multiple.
+void RunLongParity(const char* what, int64_t T, int64_t H, int64_t D, float scale, bool causal,
+                   int64_t window, const std::vector<int32_t>& cu, uint64_t seed) {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  const int num_reqs = static_cast<int>(cu.size()) - 1;
+  std::vector<float> q(static_cast<size_t>(T * H * D));
+  std::vector<float> k(q.size()), v(q.size());
+  uint64_t x = seed;
+  auto rnd = [&]() {
+    x ^= x << 13; x ^= x >> 7; x ^= x << 17;
+    return static_cast<float>((x >> 40) / 16777216.0 - 0.5);
+  };
+  for (size_t i = 0; i < q.size(); ++i) { q[i] = rnd(); k[i] = rnd(); v[i] = rnd(); }
+
+  auto mk = [&]() {
+    DFlashBlockAttentionArgs a = Args(cu.data(), num_reqs, causal, window);
+    a.scale = scale;
+    return a;
+  };
+
+  std::vector<float> want(q.size(), 0.0f);
+  {
+    Queue cq = Q();
+    Tensor qt = F32(q, {T, H, D}), kt = F32(k, {T, H, D}), vt_ = F32(v, {T, H, D});
+    Tensor ot = F32(want, {T, H, D});
+    vt::DFlashBlockAttention(cq, ot, qt, kt, vt_, mk());
+  }
+
+  Queue gq = cuda->CreateQueue();
+  auto up = [&](const std::vector<float>& hv) {
+    void* p = cuda->Alloc(hv.size() * sizeof(float));
+    cuda->Copy(gq, p, hv.data(), hv.size() * sizeof(float));
+    return p;
+  };
+  void* dq = up(q); void* dk = up(k); void* dv = up(v);
+  void* dout = cuda->Alloc(q.size() * sizeof(float));
+  Device gd = gq.device;
+  Tensor gqt = Contig(dq, DType::kF32, gd, {T, H, D});
+  Tensor gkt = Contig(dk, DType::kF32, gd, {T, H, D});
+  Tensor gvt = Contig(dv, DType::kF32, gd, {T, H, D});
+  Tensor got = Contig(dout, DType::kF32, gd, {T, H, D});
+  vt::DFlashBlockAttention(gq, got, gqt, gkt, gvt, mk());
+  cuda->Synchronize(gq);
+  std::vector<float> got_host(q.size(), 0.0f);
+  cuda->Copy(gq, got_host.data(), dout, got_host.size() * sizeof(float));
+  cuda->Synchronize(gq);
+
+  double worst = 0.0;
+  size_t worst_at = 0;
+  for (size_t i = 0; i < want.size(); ++i) {
+    REQUIRE(std::isfinite(got_host[i]));
+    const double dif = std::abs(static_cast<double>(got_host[i]) - want[i]);
+    if (dif > worst) { worst = dif; worst_at = i; }
+  }
+  INFO(what << ": long CUDA vs CPU, T=" << T << " D=" << D << " causal=" << causal
+            << " window=" << window << " max|diff|=" << worst << " at " << worst_at);
+  CHECK(worst <= 2e-5);
+  cuda->Free(dq); cuda->Free(dk); cuda->Free(dv); cuda->Free(dout);
+}
+
+}  // namespace
+
+TEST_CASE("dflash-block-attn LONG CAUSAL matches the reference") {
+  // Plain causal over one long document: adjacent queries have DIFFERENT jhi, the
+  // simplest mask that varies per query, at a length nothing else here reaches.
+  RunLongParity("long causal", /*T=*/2560, /*H=*/2, /*D=*/64, 0.125f, /*causal=*/true,
+                /*window=*/0, /*cu=*/{0, 2560}, 0x243F6A8885A308D3ULL);
+}
+
+TEST_CASE("dflash-block-attn LONG causal SLIDING WINDOW matches the reference") {
+  // window=48 moves jlo as well as jhi, so the visible range slides rather than
+  // grows. D=128 also exercises the kPerLane=4 instantiation.
+  RunLongParity("long SWA", /*T=*/2048, /*H=*/2, /*D=*/128, 0.088388f, /*causal=*/true,
+                /*window=*/48, /*cu=*/{0, 2048}, 0x13198A2E03707344ULL);
+}
+
+TEST_CASE("dflash-block-attn LONG head_dim 96 matches the reference (H3 production shape)") {
+  // The real canvas runs head_dim 96 over thousands of keys. The short case above
+  // proves the mask bookkeeping; this one proves the long-sequence CHUNKING at the
+  // head_dim the model actually uses, in both masks.
+  RunLongParity("long d96 non-causal", /*T=*/2560, /*H=*/2, /*D=*/96, 0.102062f,
+                /*causal=*/false, /*window=*/0, /*cu=*/{0, 2560}, 0xBE5466CF34E90C6CULL);
+  RunLongParity("long d96 ragged causal", /*T=*/2185, /*H=*/2, /*D=*/96, 0.102062f,
+                /*causal=*/true, /*window=*/0, /*cu=*/{0, 501, 1503, 2185},
+                0xC0AC29B7C97C50DDULL);
+}
+
+TEST_CASE("dflash-block-attn LONG ragged multi-request CAUSAL matches the reference") {
+  // Three documents whose boundaries (501, 1503) land off every warp multiple, so
+  // warps straddle document boundaries under both masks.
+  RunLongParity("long ragged causal", /*T=*/2185, /*H=*/2, /*D=*/64, 0.125f, /*causal=*/true,
+                /*window=*/0, /*cu=*/{0, 501, 1503, 2185}, 0xA4093822299F31D0ULL);
+  RunLongParity("long ragged non-causal", /*T=*/2185, /*H=*/2, /*D=*/64, 0.125f,
+                /*causal=*/false, /*window=*/0, /*cu=*/{0, 501, 1503, 2185},
+                0x082EFA98EC4E6C89ULL);
+}
+
+// ---------------------------------------------------------------------------
+// bf16 CUDA parity — the TENSOR-CORE (mma.sync) path.
+//
+// Every CUDA case above uploads f32, so all of them land on the CUDA-core kernels
+// and NOT ONE of them would touch the bf16 tensor-core kernel. That is exactly the
+// failure mode this file has been bitten by before (a long-sequence kernel guarded
+// to num_reqs == 1 shipped never-executed while the suite stayed green), so the
+// bf16 path gets its own coverage of the same semantic corners.
+//
+// THE BAR. Q, K and V are bf16 on both sides here — the reference runs on the very
+// same rounded values — so the inputs contribute NOTHING. What differs is that the
+// tensor-core kernel rounds the softmax probabilities P to bf16 before the P·V
+// GEMM (as FlashAttention does), which is a bounded ~2^-9 relative perturbation of
+// a convex combination of the V rows. With |v| < 0.5 here that is ~1e-3 absolute,
+// so 5e-3 is the honest bf16 bound — the same one test_minimax_h3 uses for its
+// bf16 stream — and NOT a loosened f32 bound: the f32 cases above still gate at
+// 2e-5 and they still run the CUDA-core kernel.
+//
+// A tolerance alone cannot prove the kernel is right, because a wrong mask also
+// produces "small" numbers when the rows are similar. So each case ALSO checks the
+// RMS error against a much tighter statistical bound (random sign errors cancel;
+// a structurally wrong kernel does not), and the mask cases are separated from
+// their opposite mask by a margin far larger than 5e-3.
+namespace {
+
+std::vector<uint16_t> ToBf16(const std::vector<float>& f) {
+  std::vector<uint16_t> b(f.size());
+  for (size_t i = 0; i < f.size(); ++i) b[i] = vt::F32ToBF16(f[i]);
+  return b;
+}
+std::vector<float> FromBf16(const std::vector<uint16_t>& b) {
+  std::vector<float> f(b.size());
+  for (size_t i = 0; i < b.size(); ++i) f[i] = vt::BF16ToF32(b[i]);
+  return f;
+}
+
+// Runs one config with bf16 Q/K/V on CUDA against the f32 CPU reference over the
+// SAME (bf16-rounded) values. `bf16_out` also rounds the result, which is the
+// production stream's shape.
+void RunBf16Parity(const char* what, int64_t T, int64_t Hq, int64_t Hk, int64_t D, float scale,
+                   bool causal, int64_t window, const std::vector<int32_t>& cu, uint64_t seed,
+                   bool bf16_out, double tol, double rms_tol) {
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  const int num_reqs = static_cast<int>(cu.size()) - 1;
+  std::vector<float> q(static_cast<size_t>(T * Hq * D));
+  std::vector<float> k(static_cast<size_t>(T * Hk * D)), v(k.size());
+  uint64_t x = seed;
+  auto rnd = [&]() {
+    x ^= x << 13; x ^= x >> 7; x ^= x << 17;
+    return static_cast<float>((x >> 40) / 16777216.0 - 0.5);
+  };
+  for (size_t i = 0; i < q.size(); ++i) q[i] = rnd();
+  for (size_t i = 0; i < k.size(); ++i) { k[i] = rnd(); v[i] = rnd(); }
+
+  // Round ONCE; both sides then see identical numbers.
+  const std::vector<uint16_t> qb = ToBf16(q), kb = ToBf16(k), vb = ToBf16(v);
+  std::vector<float> qr = FromBf16(qb), kr = FromBf16(kb), vr = FromBf16(vb);
+
+  auto mk = [&]() {
+    DFlashBlockAttentionArgs a = Args(cu.data(), num_reqs, causal, window);
+    a.scale = scale;
+    return a;
+  };
+
+  std::vector<float> want(q.size(), 0.0f);
+  {
+    Queue cq = Q();
+    Tensor qt = F32(qr, {T, Hq, D}), kt = F32(kr, {T, Hk, D}), vt_ = F32(vr, {T, Hk, D});
+    Tensor ot = F32(want, {T, Hq, D});
+    vt::DFlashBlockAttention(cq, ot, qt, kt, vt_, mk());
+  }
+
+  Queue gq = cuda->CreateQueue();
+  auto up16 = [&](const std::vector<uint16_t>& hv) {
+    void* p = cuda->Alloc(hv.size() * sizeof(uint16_t));
+    cuda->Copy(gq, p, hv.data(), hv.size() * sizeof(uint16_t));
+    return p;
+  };
+  void* dq = up16(qb); void* dk = up16(kb); void* dv = up16(vb);
+  const size_t obytes = q.size() * (bf16_out ? sizeof(uint16_t) : sizeof(float));
+  void* dout = cuda->Alloc(obytes);
+  Device gd = gq.device;
+  Tensor gqt = Contig(dq, DType::kBF16, gd, {T, Hq, D});
+  Tensor gkt = Contig(dk, DType::kBF16, gd, {T, Hk, D});
+  Tensor gvt = Contig(dv, DType::kBF16, gd, {T, Hk, D});
+  Tensor got = Contig(dout, bf16_out ? DType::kBF16 : DType::kF32, gd, {T, Hq, D});
+  vt::DFlashBlockAttention(gq, got, gqt, gkt, gvt, mk());
+  cuda->Synchronize(gq);
+
+  std::vector<float> host(q.size(), 0.0f);
+  if (bf16_out) {
+    std::vector<uint16_t> h16(q.size(), 0);
+    cuda->Copy(gq, h16.data(), dout, obytes);
+    cuda->Synchronize(gq);
+    host = FromBf16(h16);
+  } else {
+    cuda->Copy(gq, host.data(), dout, obytes);
+    cuda->Synchronize(gq);
+  }
+
+  double worst = 0.0, sq = 0.0;
+  size_t worst_at = 0;
+  for (size_t i = 0; i < want.size(); ++i) {
+    REQUIRE(std::isfinite(host[i]));
+    const double dif = std::abs(static_cast<double>(host[i]) - want[i]);
+    sq += dif * dif;
+    if (dif > worst) { worst = dif; worst_at = i; }
+  }
+  const double rms = std::sqrt(sq / static_cast<double>(want.size()));
+  INFO(what << ": bf16 CUDA vs bf16-rounded CPU reference, T=" << T << " D=" << D
+            << " causal=" << causal << " window=" << window << " bf16_out=" << bf16_out
+            << " max|diff|=" << worst << " at " << worst_at << " rms=" << rms);
+  CHECK(worst <= tol);
+  CHECK(rms <= rms_tol);
+  cuda->Free(dq); cuda->Free(dk); cuda->Free(dv); cuda->Free(dout);
+}
+
+}  // namespace
+
+TEST_CASE("dflash-block-attn bf16 TENSOR-CORE path matches the reference (semantic corners)") {
+  // The same five corners the f32 CUDA case pins, plus head_dim 16 (the smallest
+  // shape the MMA serves, and the one test_minimax_h3's golden DiT uses) and 96.
+  RunBf16Parity("nc d128 gqa", 17, 32, 8, 128, std::pow(128.0f, -0.5f), false, 0, {0, 17},
+                0x243F6A8885A308D3ULL, false, 5e-3, 1e-3);
+  RunBf16Parity("causal d128", 17, 32, 8, 128, std::pow(128.0f, -0.5f), true, 2048, {0, 17},
+                0x13198A2E03707344ULL, false, 5e-3, 1e-3);
+  RunBf16Parity("blocks d64", 51, 16, 4, 64, 0.25f, false, 0, {0, 17, 34, 51},
+                0xA4093822299F31D0ULL, false, 5e-3, 1e-3);
+  RunBf16Parity("swa d32", 17, 8, 2, 32, 0.3f, true, 4, {0, 17}, 0x082EFA98EC4E6C89ULL, false,
+                5e-3, 1e-3);
+  RunBf16Parity("gqa-extreme ragged d16", 20, 8, 1, 16, 0.35f, true, 2048, {0, 6, 20},
+                0xBE5466CF34E90C6CULL, false, 5e-3, 1e-3);
+  RunBf16Parity("nc d96", 17, 8, 2, 96, std::pow(96.0f, -0.5f), false, 0, {0, 17},
+                0xC0AC29B7C97C50DDULL, false, 5e-3, 1e-3);
+  // bf16 OUTPUT too — the production stream's dtype, which adds one more rounding.
+  RunBf16Parity("nc d128 bf16-out", 17, 32, 8, 128, std::pow(128.0f, -0.5f), false, 0, {0, 17},
+                0x9E3779B97F4A7C15ULL, true, 8e-3, 2e-3);
+}
+
+TEST_CASE("dflash-block-attn bf16 TENSOR-CORE path is right at LENGTH (H3 packed shape)") {
+  // H3's real layout: cu_seqlens {0, used, seq_len} — TWO documents, the boundary
+  // deliberately off every tile multiple, at head_dim 128 (the production shape,
+  // 7168 attention inner / 56 heads) and at 96. Long sequences are where the
+  // online-softmax rescaling across many tiles can drift and where blocks straddle
+  // a document boundary.
+  RunBf16Parity("long two-doc d128", 3000, 2, 2, 128, std::pow(128.0f, -0.5f), false, 0,
+                {0, 2317, 3000}, 0xD1B54A32D192ED03ULL, false, 5e-3, 1e-3);
+  RunBf16Parity("long nc d96", 2560, 2, 2, 96, 0.102062f, false, 0, {0, 2560},
+                0x452821E638D01377ULL, false, 5e-3, 1e-3);
+  RunBf16Parity("long causal d64", 2560, 2, 2, 64, 0.125f, true, 0, {0, 2560},
+                0x3F84D5B5B5470917ULL, false, 5e-3, 1e-3);
+  RunBf16Parity("long SWA d128", 2048, 2, 2, 128, 0.088388f, true, 48, {0, 2048},
+                0x9216D5D98979FB1BULL, false, 5e-3, 1e-3);
+  RunBf16Parity("long ragged causal d64", 2185, 2, 2, 64, 0.125f, true, 0, {0, 501, 1503, 2185},
+                0xBA7C9045F12C7F99ULL, false, 5e-3, 1e-3);
+  RunBf16Parity("long ragged nc d96", 2185, 2, 2, 96, 0.102062f, false, 0, {0, 501, 1503, 2185},
+                0x24A19947B3916CF7ULL, false, 5e-3, 1e-3);
+}
+
+TEST_CASE("dflash-block-attn bf16 RED: the MASK is load-bearing on the tensor-core path") {
+  // A tolerance gate alone cannot tell "right kernel" from "wrong mask" — so pin
+  // the SEPARATION: running the same inputs causal must move the answer by orders
+  // of magnitude more than the 5e-3 bf16 bound the cases above allow.
+  vt::Backend* cuda = nullptr;
+  try {
+    cuda = &vt::GetBackend(DeviceType::kCUDA);
+  } catch (...) {
+    MESSAGE("SKIP: no CUDA backend registered");
+    return;
+  }
+  const int64_t T = 64, H = 2, D = 64;
+  std::vector<float> q(static_cast<size_t>(T * H * D)), k(q.size()), v(q.size());
+  uint64_t x = 0x2FFD72DBD01ADFB7ULL;
+  auto rnd = [&]() {
+    x ^= x << 13; x ^= x >> 7; x ^= x << 17;
+    return static_cast<float>((x >> 40) / 16777216.0 - 0.5);
+  };
+  for (size_t i = 0; i < q.size(); ++i) { q[i] = rnd(); k[i] = rnd(); v[i] = rnd() * 8.0f; }
+  const std::vector<uint16_t> qb = ToBf16(q), kb = ToBf16(k), vb = ToBf16(v);
+
+  Queue gq = cuda->CreateQueue();
+  auto up16 = [&](const std::vector<uint16_t>& hv) {
+    void* p = cuda->Alloc(hv.size() * sizeof(uint16_t));
+    cuda->Copy(gq, p, hv.data(), hv.size() * sizeof(uint16_t));
+    return p;
+  };
+  void* dq = up16(qb); void* dk = up16(kb); void* dv = up16(vb);
+  void* o_nc = cuda->Alloc(q.size() * sizeof(float));
+  void* o_c = cuda->Alloc(q.size() * sizeof(float));
+  Device gd = gq.device;
+  Tensor gqt = Contig(dq, DType::kBF16, gd, {T, H, D});
+  Tensor gkt = Contig(dk, DType::kBF16, gd, {T, H, D});
+  Tensor gvt = Contig(dv, DType::kBF16, gd, {T, H, D});
+  Tensor tnc = Contig(o_nc, DType::kF32, gd, {T, H, D});
+  Tensor tc = Contig(o_c, DType::kF32, gd, {T, H, D});
+  const int32_t cu[2] = {0, static_cast<int32_t>(T)};
+  vt::DFlashBlockAttention(gq, tnc, gqt, gkt, gvt, Args(cu, 1, /*causal=*/false, 0));
+  vt::DFlashBlockAttention(gq, tc, gqt, gkt, gvt, Args(cu, 1, /*causal=*/true, 0));
+  cuda->Synchronize(gq);
+  std::vector<float> hnc(q.size()), hc(q.size());
+  cuda->Copy(gq, hnc.data(), o_nc, hnc.size() * sizeof(float));
+  cuda->Copy(gq, hc.data(), o_c, hc.size() * sizeof(float));
+  cuda->Synchronize(gq);
+
+  double sep = 0.0;
+  for (size_t i = 0; i < hnc.size(); ++i)
+    sep = std::max(sep, std::abs(static_cast<double>(hnc[i]) - hc[i]));
+  INFO("causal vs non-causal separation on the bf16 tensor-core path = " << sep);
+  CHECK(sep > 0.5);  // ~100x the bf16 tolerance the parity cases allow
+  cuda->Free(dq); cuda->Free(dk); cuda->Free(dv); cuda->Free(o_nc); cuda->Free(o_c);
 }