diff --git a/.gitignore b/.gitignore
index 8604a05a..dad7e719 100755
--- a/.gitignore
+++ b/.gitignore
@@ -162,4 +162,10 @@ telefuser/_version.py
 !examples/data/lingbot_world_fast/image.jpg
 !examples/data/lingbot_world_fast/poses.npy
 !examples/data/lingbot_world_fast/intrinsics.npy
-.models
\ No newline at end of file
+# MiniMax H3 runnable example requests and frozen official reference inputs
+!examples/data/minimax-h3/fl2va-reference.png
+!examples/data/minimax-h3/ref2va-reference.mp4
+!examples/data/minimax-h3/ref2va-voice.mp3
+!examples/data/minimax-h3/ref2va.json
+!examples/data/minimax-h3/provenance.json
+.models
diff --git a/README.md b/README.md
index b81ab45b..c2f34b1d 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,11 @@ TeleFuser is a high-performance runtime for world model inference and multimodal
 
 ## News 📰
 
+- ✨ **2026-08-05**: Added [**MiniMax H3**](examples/minimax_h3/README.md) T2VA, FL2VA, and Ref2VA joint
+  audio-video generation with standard `telefuser serve` support. On the matched 768p, five-second, 50-step T2VA
+  benchmark after warmup, the resident **4 x H100 80 GB** profile matched pinned local SGLang SP2+TP2 performance
+  while using less GPU memory; see the
+  [reproducible validation and performance notes](examples/minimax_h3/README.md#measured-four-gpu-profile).
 - ✨ **2026-08-03**: Validated LingBot-World v2 target-side real-time generation on **4 x H100 80 GB** at
   832x480 and 16 FPS. The current 77-frame gate reached **17.14 steady compute FPS**; see the
   [reproducible benchmark](docs/en/benchmark_aiperf.md#current-four-h100-real-time-gate).
@@ -230,6 +235,7 @@ telefuser/
 | `WanVideo` (Wan2.1 / Wan2.2) | T2V, I2V, FL2V | Main video generation family, including async and service examples in [examples/wan_video/README.md](examples/wan_video/README.md) |
 | `HunyuanVideo` | T2V, I2V | Supported via [examples/hunyuan_video/README.md](examples/hunyuan_video/README.md) |
 | `LTX Video` | I2V + Audio | Unified audio-video generation via [examples/ltx_video/README.md](examples/ltx_video/README.md) |
+| `MiniMax H3` | T2VA, FL2VA, Ref2VA + Audio | Local 768p joint audio-video generation via [examples/minimax_h3/README.md](examples/minimax_h3/README.md) |
 | `LongCat-Video` | T2V, I2V, VC | Long-form generation and continuation via [examples/longcat_video/README.md](examples/longcat_video/README.md) |
 | **NEW** `LingBot-Video` | T2I, T2V, TI2V, MoE refiner | Dense/MoE generation with native CFG/SP and an in-memory base-to-refiner path; see [examples/lingbot_video/README.md](examples/lingbot_video/README.md) |
 
diff --git a/README_zh.md b/README_zh.md
index 09e238d4..fba20bfa 100644
--- a/README_zh.md
+++ b/README_zh.md
@@ -17,6 +17,11 @@ TeleFuser 是一个面向世界模型推理与多模态生成的高性能运行
 
 ## News 📰
 
+- ✨ **2026-08-05**：新增 [**MiniMax H3**](examples/minimax_h3/README.md) T2VA、FL2VA 和 Ref2VA 联合
+  音视频生成，并支持标准 `telefuser serve` 服务模式。在相同的 768p、5 秒、50 步 T2VA 请求和一次预热
+  条件下，常驻 **4 张 H100 80 GB** 配置的性能与固定版本的本地 SGLang SP2+TP2 对齐，同时使用更少
+  GPU 显存。复现条件和性能分析见
+  [MiniMax H3 示例文档](examples/minimax_h3/README.md#measured-four-gpu-profile)。
 - ✨ **2026-08-03**：LingBot-World v2 已在 **4 张 H100 80 GB** 上通过 832x480、16 FPS 的目标侧实时生成
   验证。当前 77 帧门禁达到 **17.14 steady compute FPS**，复现方法见
   [基准文档](docs/zh/benchmark_aiperf.md#当前-77-帧实时计算门禁)。
@@ -220,6 +225,7 @@ telefuser/
 | `WanVideo` (Wan2.1 / Wan2.2) | T2V, I2V, FL2V | 主力视频生成家族，含异步和服务示例，见 [examples/wan_video/README.md](examples/wan_video/README.md) |
 | `HunyuanVideo` | T2V, I2V | 见 [examples/hunyuan_video/README.md](examples/hunyuan_video/README.md) |
 | `LTX Video` | I2V + Audio | 统一音视频生成，见 [examples/ltx_video/README.md](examples/ltx_video/README.md) |
+| `MiniMax H3` | T2VA, FL2VA, Ref2VA + Audio | 本地 768p 联合音视频生成，见 [examples/minimax_h3/README.md](examples/minimax_h3/README.md) |
 | `LongCat-Video` | T2V, I2V, VC | 长视频生成与续写，见 [examples/longcat_video/README.md](examples/longcat_video/README.md) |
 | **NEW** `LingBot-Video` | T2I, T2V, TI2V, MoE refiner | 支持原生 CFG/SP 的 Dense/MoE 生成与内存直传 base-to-refiner，见 [examples/lingbot_video/README.md](examples/lingbot_video/README.md) |
 
diff --git a/docs/en/parallel.md b/docs/en/parallel.md
index 970eecb5..b3add92e 100644
--- a/docs/en/parallel.md
+++ b/docs/en/parallel.md
@@ -461,9 +461,8 @@ pool.
 # Device count must equal product of parallel degrees
 world_size = dp * cfg * sp_ring * sp_ulysses * pp * tp
 
-# SP and TP cannot be enabled simultaneously
-if sp_degree > 1 and tp_degree > 1:
-    raise ValueError("SP and TP are mutually exclusive")
+# SP and TP may be combined as independent mesh dimensions.
+# The selected pipeline must implement and validate the requested combination.
 ```
 
 ## Usage Examples
diff --git a/docs/en/testing.md b/docs/en/testing.md
index 307da604..b10687f3 100644
--- a/docs/en/testing.md
+++ b/docs/en/testing.md
@@ -365,6 +365,10 @@ If not set, defaults to `"model_zoo"` (relative to working directory).
 | prompt | str\|null | null | Override generation prompt |
 | input_image_path | str\|null | null | Input image for I2V/edit pipelines |
 | input_video_path | str\|null | null | Input video for VSR/continue pipelines |
+| target_video_length | float\|null | null | Override generated duration when the example accepts it |
+| use_run_with_file | bool | false | Use the standard file entrypoint to preserve container-level output such as audio tracks |
+| require_audio | bool | false | Require an audio stream and compare its contract and decoded waveform |
+| audio_cosine_min | float | 0.95 | Video audio: minimum decoded-waveform cosine similarity |
 | ppl_config_overrides | dict | {} | Override PPL_CONFIG keys |
 | psnr_min | float | 25.0 | Video: minimum PSNR vs baseline |
 | ssim_min | float | 0.85 | Video: minimum SSIM vs baseline |
@@ -407,7 +411,8 @@ Example: `20260402_120000_wan_video__wan21_1_3b_text_to_video_h100_1gpu.log`
 
 The runner compares outputs against baselines using:
 
-- **Video**: PSNR (Peak Signal-to-Noise Ratio) and SSIM (Structural Similarity)
+- **Video**: PSNR (Peak Signal-to-Noise Ratio) and SSIM (Structural Similarity); when `require_audio` is enabled, audio
+  stream presence, sample rate, channels, duration, and decoded-waveform cosine similarity
 - **Image**: Mean pixel difference
 
 #### Metrics Thresholds
@@ -417,6 +422,8 @@ Configure in YAML or per-pipeline:
 ```yaml
 psnr_min: 25.0      # Higher = stricter
 ssim_min: 0.85      # Range [0, 1], higher = stricter
+require_audio: true      # Require and compare the output audio stream
+audio_cosine_min: 0.95  # Higher = stricter
 pixel_diff_max: 0.02 # Range [0, 1], lower = stricter
 ```
 
diff --git a/docs/zh/parallel.md b/docs/zh/parallel.md
index 7898de33..1cb7cc26 100644
--- a/docs/zh/parallel.md
+++ b/docs/zh/parallel.md
@@ -456,9 +456,8 @@ stage 包含大量 CPU 计算时才需要提高该值；它不会修改父进程
 # 设备数必须等于各并行度乘积
 world_size = dp * cfg * sp_ring * sp_ulysses * pp * tp
 
-# SP 和 TP 不能同时启用
-if sp_degree > 1 and tp_degree > 1:
-    raise ValueError("SP and TP are mutually exclusive")
+# SP 和 TP 可以作为独立的 mesh 维度组合。
+# 所选 pipeline 必须实现并校验请求的组合。
 ```
 
 ## 使用示例
diff --git a/docs/zh/testing.md b/docs/zh/testing.md
index 10f68e44..e7bf09a2 100644
--- a/docs/zh/testing.md
+++ b/docs/zh/testing.md
@@ -365,6 +365,10 @@ python examples/run_examples.py --all
 | prompt | str\|null | null | 覆盖生成提示词 |
 | input_image_path | str\|null | null | I2V/编辑 pipeline 的输入图像 |
 | input_video_path | str\|null | null | VSR/续写 pipeline 的输入视频 |
+| target_video_length | float\|null | null | 示例支持时覆盖生成时长 |
+| use_run_with_file | bool | false | 使用标准文件入口，保留音轨等容器级输出 |
+| require_audio | bool | false | 要求输出包含音轨，并比较音频契约和解码波形 |
+| audio_cosine_min | float | 0.95 | 视频音频：解码波形余弦相似度下限 |
 | ppl_config_overrides | dict | {} | 覆盖 PPL_CONFIG 配置 |
 | psnr_min | float | 25.0 | 视频：最低 PSNR 阈值 |
 | ssim_min | float | 0.85 | 视频：最低 SSIM 阈值 |
@@ -407,7 +411,8 @@ work_dirs/example_outputs/
 
 Runner 使用以下指标对比 baseline：
 
-- **视频**：PSNR（峰值信噪比）和 SSIM（结构相似度）
+- **视频**：PSNR（峰值信噪比）和 SSIM（结构相似度）；启用 `require_audio` 时还会校验音轨存在性、采样率、声道数、
+  时长和解码波形余弦相似度
 - **图像**：平均像素差异
 
 #### 指标阈值
@@ -417,6 +422,8 @@ Runner 使用以下指标对比 baseline：
 ```yaml
 psnr_min: 25.0      # 越高越严格
 ssim_min: 0.85      # 范围 [0, 1]，越高越严格
+require_audio: true      # 要求并比较输出音轨
+audio_cosine_min: 0.95  # 越高越严格
 pixel_diff_max: 0.02 # 范围 [0, 1]，越低越严格
 ```
 
diff --git a/examples/data/minimax-h3/fl2va-reference.png b/examples/data/minimax-h3/fl2va-reference.png
new file mode 100644
index 00000000..8b3b0d18
Binary files /dev/null and b/examples/data/minimax-h3/fl2va-reference.png differ
diff --git a/examples/data/minimax-h3/provenance.json b/examples/data/minimax-h3/provenance.json
new file mode 100644
index 00000000..d50a63dd
--- /dev/null
+++ b/examples/data/minimax-h3/provenance.json
@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "source": "MiniMax H3 official reproducible request inputs frozen for TeleFuser parity validation",
+  "files": [
+    {
+      "path": "fl2va-reference.png",
+      "bytes": 1263485,
+      "sha256": "352e959e08b886406d3766cee25ebe7bbf679e6d53eeffbd1c607b8dc93e2068",
+      "original_uri": "https://cdn.hailuoai.com/prod/hailuo_demo/testsets/H3_AA_I2VA/gallery/sr_v17_variants_seed42_43_20260724/inputs/4a3a90bf9100_KDmcbkhzYo5sjjxr9FqcVmWVnzb.png"
+    },
+    {
+      "path": "ref2va-reference.mp4",
+      "bytes": 4396484,
+      "sha256": "d6edc20ac82aa980c9cbd0b05b371f60d12dc8d018492e571b42de0086819c41",
+      "original_uri": "https://cdn.hailuoai.com/prod/hailuo_demo/testsets/h3_promo_eval_ref2va/gallery/sr_v2p26_trio_seed42_20260724/inputs/297573323635_00_%E8%A7%86%E9%A2%911_YnyRbxEwio_video_20260525_163755_1927e9d3.mp4"
+    },
+    {
+      "path": "ref2va-voice.mp3",
+      "bytes": 204432,
+      "sha256": "2a48d447b343b38a2c504d5281a0c97c688db0ba87931ed9282c598bd6752454",
+      "original_uri": "https://cdn.hailuoai.com/prod/hailuo_demo/testsets/h3_promo_eval_ref2va/gallery/sr_v2p26_trio_seed42_20260724/inputs/f463d523c5ce_01_%E9%9F%B3%E9%A2%911_RSLcbpzJPo_6%E6%9C%885%E6%97%A5(1).mp3"
+    }
+  ]
+}
diff --git a/examples/data/minimax-h3/ref2va-reference.mp4 b/examples/data/minimax-h3/ref2va-reference.mp4
new file mode 100644
index 00000000..279f7d74
Binary files /dev/null and b/examples/data/minimax-h3/ref2va-reference.mp4 differ
diff --git a/examples/data/minimax-h3/ref2va-voice.mp3 b/examples/data/minimax-h3/ref2va-voice.mp3
new file mode 100644
index 00000000..17dbe9cc
Binary files /dev/null and b/examples/data/minimax-h3/ref2va-voice.mp3 differ
diff --git a/examples/data/minimax-h3/ref2va.json b/examples/data/minimax-h3/ref2va.json
new file mode 100644
index 00000000..739f5f84
--- /dev/null
+++ b/examples/data/minimax-h3/ref2va.json
@@ -0,0 +1,25 @@
+{
+  "task": "ref2va",
+  "prompt": "Preserve the subject, composition, motion, and soundtrack from <Video 1>. Use the calm male voice timbre from <Audio 2> for the spoken line: Follow the wind, live free.",
+  "conditions": [
+    {
+      "type": "video",
+      "uri": "ref2va-reference.mp4",
+      "role": "reference"
+    },
+    {
+      "type": "audio",
+      "uri": "ref2va-voice.mp3",
+      "role": "reference"
+    }
+  ],
+  "target": {
+    "short_edge": 768,
+    "aspect_ratio": "auto",
+    "duration_seconds": 5
+  },
+  "seed": 0,
+  "flow_shift": 12.0,
+  "audio_flow_shift": 3.0,
+  "num_inference_steps": 50
+}
diff --git a/examples/example_config.yaml b/examples/example_config.yaml
index 106e4827..c51b5bce 100644
--- a/examples/example_config.yaml
+++ b/examples/example_config.yaml
@@ -101,6 +101,23 @@ pipelines:
     ppl_config_overrides:
       attn_impl: TORCH_SDPA
 
+  # ============================================================
+  # minimax_h3 — Joint Audio-Video Generation
+  # ============================================================
+
+  minimax_h3_t2va_4gpu:
+    script: minimax_h3/minimax_h3_fl2va_h100.py
+    gpu_count: 4
+    output_type: video
+    timeout_seconds: 1800
+    seed: 0
+    resolution: "768p"
+    target_video_length: 5
+    use_run_with_file: true
+    require_audio: true
+    ppl_config_overrides:
+      num_inference_steps: 50
+
   # ============================================================
   # lingbot_world_fast - Image to Video
   # ============================================================
diff --git a/examples/minimax_h3/README.md b/examples/minimax_h3/README.md
new file mode 100644
index 00000000..f51a45b7
--- /dev/null
+++ b/examples/minimax_h3/README.md
@@ -0,0 +1,272 @@
+# MiniMax H3
+
+These examples run the local MiniMax H3 Base release from its original FL2VA and Ref2VA partitions. They generate
+24 FPS video with synchronized 32 kHz stereo audio. The local path supports 768p-class output; hosted Context-IR and
+Regenerate-2K services are not implemented or implied.
+
+## Requirements
+
+- Linux with ffmpeg and ffprobe.
+- One NVIDIA H100 80GB for sequential stage offload, or two/four H100 80GB GPUs for resident multi-GPU execution.
+- Enough host memory for the approximately 63 GB encoder and 62 GB DiT partitions.
+- The repository development environment and the unmodified model directory at
+  `/hhb-data/aigc/model_zoo/MiniMaxAI_MiniMax-H3`.
+
+Run commands from the repository root. The examples load original checkpoint shards through `ModuleManager`. A
+one-GPU run uses stage-level model CPU offload. Multi-GPU runs keep the stages resident: two GPUs use Ulysses2 for
+the DiT, TP2 for the text encoder, and TP2 video-VAE tiling; four GPUs use DiT Ulysses2 x TP2, text TP4, and TP4
+video-VAE tiling. The audio VAE remains on GPU 0. The encoder and DiT use BF16; both VAEs remain FP32, with the
+reference FP16 autocast boundary applied only to CUDA video decode.
+
+The source-controlled default inputs live in `examples/data/minimax-h3/`. They are the exact inputs frozen for the
+official SGLang parity runs; `provenance.json` records their original URLs, byte sizes, and SHA-256 hashes.
+
+## T2VA And FL2VA
+
+Use the explicit mode names when demonstrating a particular task. T2VA has no reference input:
+
+```bash
+python examples/minimax_h3/minimax_h3_fl2va_h100.py \
+  --mode t2va \
+  --prompt "A cinematic coastal landscape with synchronized ambient sound." \
+  --duration 5 \
+  --output outputs/minimax_h3_t2va.mp4
+```
+
+First-frame FL2VA uses the bundled reference image when `--image` is omitted:
+
+```bash
+python examples/minimax_h3/minimax_h3_fl2va_h100.py \
+  --mode first-frame \
+  --prompt "Steam rises from the ramen while the family talks in the background." \
+  --duration 8 \
+  --output outputs/minimax_h3_first_frame.mp4
+```
+
+Last-frame-only FL2VA accepts either `--last-image` or the bundled image:
+
+```bash
+python examples/minimax_h3/minimax_h3_fl2va_h100.py \
+  --mode last-frame \
+  --prompt "The camera settles on a warm family dinner at the final frame." \
+  --output outputs/minimax_h3_last_frame.mp4
+```
+
+First-and-last-frame FL2VA accepts two images. When both are omitted, the bundled image is used at both endpoints;
+that default is useful for a contract smoke run, while meaningful motion requires distinct endpoint images.
+
+```bash
+python examples/minimax_h3/minimax_h3_fl2va_h100.py \
+  --mode first-last \
+  --image /path/to/first.png \
+  --last-image /path/to/last.png \
+  --prompt "Move smoothly from the first composition to the last composition." \
+  --output outputs/minimax_h3_first_last.mp4
+```
+
+For compatibility, omitting `--mode` infers T2VA, first-frame, last-frame, or first-last from `--image` and
+`--last-image`. Explicit modes are preferable in reproducible commands.
+
+## Ref2VA
+
+With no material arguments, the simple Ref2VA script uses the bundled reference video followed by the bundled voice
+reference:
+
+```bash
+python examples/minimax_h3/minimax_h3_ref2va_h100.py \
+  --prompt "Preserve the source identity and motion, and use the reference voice for the dialogue." \
+  --duration 5 \
+  --output outputs/minimax_h3_ref2va.mp4
+```
+
+Custom material paths may be repeated:
+
+```bash
+python examples/minimax_h3/minimax_h3_ref2va_h100.py \
+  --image /path/to/subject.png \
+  --video /path/to/motion.mp4 \
+  --audio /path/to/voice.wav \
+  --prompt "Keep the subject identity and follow the reference motion." \
+  --duration 5 \
+  --output outputs/minimax_h3_ref2va_custom.mp4
+```
+
+The convenience CLI groups repeated arguments as images, videos, then audio. Use the JSON request runner whenever
+heterogeneous ordering is semantic. It defaults to `examples/data/minimax-h3/ref2va.json`; relative material URIs
+are resolved from the request file's directory.
+
+```bash
+python examples/minimax_h3/minimax_h3_request_h100.py \
+  --request examples/data/minimax-h3/ref2va.json \
+  --output outputs/minimax_h3_ordered_request.mp4
+```
+
+The JSON `conditions` array is passed in its original order. Each entry accepts `type` (`image`, `video`,
+`video_audio`, or `audio`), `role: "reference"`, `uri`, and optional `start_time_seconds` for video inputs.
+`video_audio` requires both tracks; `video` uses its original soundtrack when one is present. For example:
+
+```json
+{
+  "task": "ref2va",
+  "prompt": "Use <Image 1>, then <Audio 1>, then the motion and soundtrack from <Video 1>.",
+  "conditions": [
+    {"type": "image", "role": "reference", "uri": "subject.png"},
+    {"type": "audio", "role": "reference", "uri": "voice.wav"},
+    {
+      "type": "video_audio",
+      "role": "reference",
+      "uri": "motion.mp4",
+      "start_time_seconds": 1.5
+    }
+  ],
+  "target": {"short_edge": 768, "aspect_ratio": "16:9", "duration_seconds": 5},
+  "seed": 0,
+  "flow_shift": 12.0,
+  "audio_flow_shift": 3.0,
+  "num_inference_steps": 50
+}
+```
+
+Ref2VA may omit `target.duration_seconds` when exactly one audio-bearing condition supplies the duration. With
+multiple audio-bearing conditions, duration must be explicit. Published limits are enforced before model execution:
+at most 9 images, 3 videos, 3 audio-bearing inputs, and 12 files total; each audio/video clip must be 2-15 seconds,
+total video and total audio duration must each be at most 15 seconds, and audio requires an image or video reference.
+
+## Standard Python And Serve Entrypoints
+
+All three executable modules expose `PPL_CONFIG`, `get_pipeline`, `run`, and `run_with_file`. The two fixed-partition
+generation modules also expose `PIPELINE_MANIFEST` for serving. `get_pipeline(parallelism, model_root)` interprets
+`parallelism` as the total GPU count and selects the corresponding profile below. `run` returns the in-memory
+`MiniMaxH3Generation`; `run_with_file` writes the synchronized MP4 and returns its `output_path`.
+
+```python
+from examples.minimax_h3.minimax_h3_fl2va_h100 import get_pipeline, run_with_file
+
+pipeline = get_pipeline(4, "/path/to/MiniMaxAI_MiniMax-H3")
+try:
+    artifact = run_with_file(
+        pipeline,
+        task="i2v",
+        prompt="Steam rises from the ramen while the family talks.",
+        first_image_path="examples/data/minimax-h3/fl2va-reference.png",
+        output_path="outputs/minimax_h3_i2v.mp4",
+    )
+finally:
+    pipeline.stop()
+```
+
+Serve T2VA, first-frame I2VA, and first-and-last-frame FL2VA from the shared FL2VA checkpoint partition:
+
+```bash
+telefuser serve examples/minimax_h3/minimax_h3_fl2va_h100.py --gpu-num 4 --port 8000
+```
+
+The service contract advertises `t2v`, `i2v`, and `fl2v`. Submit `first_image_path` for `i2v`, and both
+`first_image_path` and `last_image_path` for `fl2v`. Output duration must be between 4 and 15 seconds:
+
+```bash
+curl -X POST http://127.0.0.1:8000/v1/tasks/create \
+  -H "Content-Type: application/json" \
+  -d "{\"task\":\"i2v\",\"prompt\":\"Animate this dinner scene with synchronized dialogue.\",\"first_image_path\":\"https://example.com/first.png\",\"resolution\":\"768p\",\"aspect_ratio\":\"16:9\",\"target_video_length\":5}"
+```
+
+Ref2VA uses its own checkpoint partition and advertises the standard `s2v` service task, which maps to the
+model-specific Ref2VA task. Its required `conditions` parameter is the same ordered array accepted by the local
+pipeline, so heterogeneous image, video, `video_audio`, and audio references are not reordered by the example.
+Output duration must also be between 4 and 15 seconds:
+
+```bash
+telefuser serve examples/minimax_h3/minimax_h3_ref2va_h100.py --task s2v --gpu-num 4 --port 8001
+
+curl -X POST http://127.0.0.1:8001/v1/tasks/create \
+  -H "Content-Type: application/json" \
+  -d "{\"task\":\"s2v\",\"prompt\":\"Use <Video 1>, then <Audio 2>.\",\"conditions\":[{\"type\":\"video\",\"role\":\"reference\",\"uri\":\"https://example.com/motion.mp4\"},{\"type\":\"audio\",\"role\":\"reference\",\"uri\":\"https://example.com/voice.mp3\"}],\"resolution\":\"768p\",\"aspect_ratio\":\"16:9\",\"target_video_length\":5}"
+```
+
+Use `/v1/service/metadata` to inspect the active task contract. The JSON request runner remains the convenient local
+entrypoint for request files and resolves relative material paths beside the JSON file.
+
+## Generation And Parallel Options
+
+The simple CLIs expose `--steps`, `--seed`, `--duration`, `--aspect-ratio`, `--flow-shift`, and
+`--audio-flow-shift`. Supported explicit aspect ratios are `21:9`, `16:9`, `4:3`, `1:1`, `3:4`, and `9:16`;
+`auto` follows the task policy or first FL2VA keyframe.
+
+`--gpu-num` selects the total worker count. `--ulysses-degree` remains a compatibility alias for the same CLI option;
+it no longer means that every selected GPU is necessarily an Ulysses rank.
+
+| `--gpu-num` | DiT | Text encoder | Video VAE | Residency |
+|---:|---|---|---|---|
+| 1 | single GPU | single GPU | single GPU | sequential model CPU offload |
+| 2 | Ulysses2 | TP2 | TP2 tiling | resident |
+| 4 | Ulysses2 x TP2 | TP4 | TP4 tiling | resident |
+
+The Ulysses degree must divide 56 attention heads. Scripts must run from their guarded entry points so worker
+processes can spawn safely. H100 examples request packed FlashAttention 4 and fall back to packed PyTorch SDPA when
+FlashAttention 4 is unavailable.
+
+For multi-GPU resident profiles, `WorkerTensorChannel` transports text conditioning, visual condition rows, and the
+final video latent directly between worker groups. CUDA intermediates therefore do not stage through the parent
+process or CPU. The pipeline reports media, text, condition VAE, denoising, video/audio decode, allocator peak, and
+DiT communication timings in `MiniMaxH3Generation.runtime_metrics`.
+
+H3 also uses eager BF16 Triton paths for Q/K RMSNorm plus partial NeoX RoPE, indexed modulation, SwiGLU, and Ulysses
+relayout when their input contracts match. Compatible `tf-kernel` builds may accelerate public RMSNorm, SwiGLU, and
+RoPE operations. All public ops retain native PyTorch fallbacks for unsupported devices, dtypes, and compile mode.
+
+FSDP2 remains available for an SP-only DiT profile and cannot be combined with DiT TP. The standard CLI can select
+it explicitly for a two-GPU Ulysses run:
+
+```bash
+python examples/minimax_h3/minimax_h3_request_h100.py \
+  --ulysses-degree 2 \
+  --enable-fsdp \
+  --output outputs/minimax_h3_ref2va_fsdp.mp4
+```
+
+The standard four-GPU profile already uses Ulysses2 x TP2 and therefore leaves FSDP disabled. Use
+`load_minimax_h3_pipeline` directly to construct another supported combination; the product of Ulysses and TP degrees
+must be 1, 2, or 4.
+
+Ring attention, CFG parallelism, pipeline parallelism, sparse attention, quantization, and `torch.compile` are not
+enabled for H3. Video-VAE parallelism is spatial tiling over the existing TP process group, not parameter tensor
+parallelism. The dedicated service manifests expose the pipeline without adding framework-level configuration fields
+or changing the shared request schema.
+
+## Four-GPU Regression
+
+The example regression registry includes `minimax_h3_t2va_4gpu`, a 768p, five-second, 50-step T2VA request with seed
+0. It reserves four GPUs and uses the resident Ulysses2 x TP2 profile. Regression runs force packed PyTorch SDPA,
+matching the repository-wide deterministic regression policy; ordinary example and service execution still defaults
+to packed FlashAttention 4. The standard file entrypoint preserves synchronized video and audio in the baseline MP4;
+regression additionally validates the audio stream contract, duration, and decoded waveform similarity.
+
+Initialize or intentionally replace the local ignored baseline:
+
+```bash
+TF_MODEL_ZOO_PATH=/path/to/model_zoo \
+python examples/run_examples.py \
+  --pipeline minimax_h3_t2va_4gpu \
+  --gpus 0,1,2,3 \
+  --update-baseline
+```
+
+Run the regression against that baseline:
+
+```bash
+TF_MODEL_ZOO_PATH=/path/to/model_zoo \
+python examples/run_examples.py \
+  --pipeline minimax_h3_t2va_4gpu \
+  --gpus 0,1,2,3
+```
+
+## Measured Four-GPU Profile
+
+On the frozen 768p, five-second, 50-step T2VA request, after one warmup, the resident four-H100 profile measured
+79.34 seconds wall time. The matched local SGLang SP2+TP2 run measured 79.37 seconds. Sampled peak GPU 0 memory was
+62.7 GiB for TeleFuser and 67.8 GiB for SGLang. The TeleFuser DiT denoising phase took 76.41 seconds, including
+4.12 seconds recorded in SP/TP communication.
+
+These numbers establish parity for this request and environment, not a general performance guarantee. Direct stage
+tensor transport removes CPU/parent staging but does not materially change the 50-step wall time because DiT compute
+and per-layer TP/SP collectives dominate.
diff --git a/examples/minimax_h3/common.py b/examples/minimax_h3/common.py
new file mode 100644
index 00000000..92e51621
--- /dev/null
+++ b/examples/minimax_h3/common.py
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Compatibility exports for MiniMax H3 example helpers."""
+
+from telefuser.pipelines.minimax_h3.example_utils import (
+    MINIMAX_H3_DEFAULT_FL2VA_IMAGE,
+    MINIMAX_H3_DEFAULT_REF2VA_AUDIO,
+    MINIMAX_H3_DEFAULT_REF2VA_VIDEO,
+    MINIMAX_H3_DEFAULT_REQUEST,
+    load_minimax_h3_pipeline,
+    load_minimax_h3_request,
+    partition_for_minimax_h3_request,
+    save_generation,
+)
+
+__all__ = [
+    "MINIMAX_H3_DEFAULT_FL2VA_IMAGE",
+    "MINIMAX_H3_DEFAULT_REF2VA_AUDIO",
+    "MINIMAX_H3_DEFAULT_REF2VA_VIDEO",
+    "MINIMAX_H3_DEFAULT_REQUEST",
+    "load_minimax_h3_pipeline",
+    "load_minimax_h3_request",
+    "partition_for_minimax_h3_request",
+    "save_generation",
+]
diff --git a/examples/minimax_h3/minimax_h3_fl2va_h100.py b/examples/minimax_h3/minimax_h3_fl2va_h100.py
new file mode 100644
index 00000000..ce94844b
--- /dev/null
+++ b/examples/minimax_h3/minimax_h3_fl2va_h100.py
@@ -0,0 +1,303 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+from typing import Any
+
+from telefuser.core.config import AttnImplType
+from telefuser.pipelines.minimax_h3.example_utils import (
+    MINIMAX_H3_DEFAULT_FL2VA_IMAGE,
+    load_minimax_h3_pipeline,
+    save_generation,
+)
+from telefuser.pipelines.minimax_h3.pipeline import MiniMaxH3Generation, MiniMaxH3Pipeline
+from telefuser.service.core.contract_templates import build_pipeline_manifest, build_task_contract_template
+
+TF_MODEL_ZOO_PATH = os.environ.get("TF_MODEL_ZOO_PATH", "/hhb-data/aigc/model_zoo")
+PPL_CONFIG: dict[str, Any] = {
+    "name": "minimax_h3_fl2va_h100",
+    "model_root": TF_MODEL_ZOO_PATH + "/MiniMaxAI_MiniMax-H3",
+    "partition": "FL2VA",
+    "prompt": "Steam rises from the ramen while the family talks in the background.",
+    "num_inference_steps": 50,
+    "short_edge": 768,
+    "resolution": "768p",
+    "aspect_ratio": "16:9",
+    "cli_aspect_ratio": "auto",
+    "target_video_length": 8,
+    "seed": 0,
+    "flow_shift": None,
+    "audio_flow_shift": None,
+    "device": "cuda:0",
+    "enable_fsdp": None,
+    "attn_impl": AttnImplType.FLASH_ATTN_4,
+}
+
+
+def _task_contract(task: str) -> dict[str, Any]:
+    return build_task_contract_template(
+        task,
+        parameter_overrides={
+            "prompt": {
+                "default": PPL_CONFIG["prompt"],
+                "description": "Positive prompt for MiniMax H3 audio-video generation.",
+            },
+            "seed": {"default": PPL_CONFIG["seed"]},
+            "resolution": {
+                "default": PPL_CONFIG["resolution"],
+                "enum": [PPL_CONFIG["resolution"]],
+                "description": "MiniMax H3 local checkpoints support 768p-class output.",
+            },
+            "aspect_ratio": {
+                "default": PPL_CONFIG["aspect_ratio"],
+                "enum": ["16:9", "4:3", "1:1", "3:4", "9:16"],
+            },
+            "target_video_length": {
+                "default": PPL_CONFIG["target_video_length"],
+                "description": "Output duration in seconds; MiniMax H3 supports values from 4 through 15.",
+            },
+        },
+        excluded_parameters=("negative_prompt",),
+    )
+
+
+PIPELINE_MANIFEST = build_pipeline_manifest(
+    pipeline_name=PPL_CONFIG["name"],
+    supported_tasks=("t2v", "i2v", "fl2v"),
+    task_contracts={task: _task_contract(task) for task in ("t2v", "i2v", "fl2v")},
+)
+
+
+def get_pipeline(
+    parallelism: int = 1,
+    model_root: str = PPL_CONFIG["model_root"],
+    *,
+    device: str = PPL_CONFIG["device"],
+    num_inference_steps: int = PPL_CONFIG["num_inference_steps"],
+    enable_fsdp: bool | None = PPL_CONFIG["enable_fsdp"],
+    attn_impl: AttnImplType | str = PPL_CONFIG["attn_impl"],
+) -> MiniMaxH3Pipeline:
+    """Load the FL2VA checkpoint partition for one, two, or four GPUs."""
+    tp_degree = 2 if parallelism == 4 else 1
+    return load_minimax_h3_pipeline(
+        model_root,
+        partition=PPL_CONFIG["partition"],
+        device=device,
+        num_inference_steps=num_inference_steps,
+        ulysses_degree=parallelism // tp_degree,
+        tp_degree=tp_degree,
+        text_encoder_tp_degree=parallelism,
+        enable_fsdp=enable_fsdp,
+        attn_impl=attn_impl,
+    )
+
+
+def build_fl2va_conditions(
+    *,
+    mode: str | None,
+    image: str | None,
+    last_image: str | None,
+) -> list[dict[str, object]]:
+    """Build the three supported FL2VA keyframe signatures, preserving legacy inference."""
+    if mode is None:
+        if image and last_image:
+            mode = "first-last"
+        elif image:
+            mode = "first-frame"
+        elif last_image:
+            mode = "last-frame"
+        else:
+            mode = "t2va"
+    if mode == "t2va":
+        if image or last_image:
+            raise ValueError("--mode t2va does not accept --image or --last-image")
+        return []
+
+    default_image = str(MINIMAX_H3_DEFAULT_FL2VA_IMAGE)
+    if mode == "first-frame":
+        return [{"type": "image", "role": "keyframe", "uri": image or default_image, "frame_index": 0}]
+    if mode == "last-frame":
+        return [
+            {
+                "type": "image",
+                "role": "keyframe",
+                "uri": last_image or image or default_image,
+                "frame_index": -1,
+            }
+        ]
+    if mode == "first-last":
+        first = image or default_image
+        last = last_image or image or default_image
+        return [
+            {"type": "image", "role": "keyframe", "uri": first, "frame_index": 0},
+            {"type": "image", "role": "keyframe", "uri": last, "frame_index": -1},
+        ]
+    raise ValueError(f"unsupported FL2VA mode {mode!r}")
+
+
+def _mode_for_service_task(task: str) -> str:
+    modes = {"t2v": "t2va", "i2v": "first-frame", "fl2v": "first-last"}
+    try:
+        return modes[task]
+    except KeyError as exc:
+        raise ValueError(f"unsupported MiniMax H3 FL2VA service task: {task}") from exc
+
+
+def run(
+    pipeline: MiniMaxH3Pipeline,
+    prompt: str = PPL_CONFIG["prompt"],
+    seed: int = PPL_CONFIG["seed"],
+    resolution: str = PPL_CONFIG["resolution"],
+    aspect_ratio: str = PPL_CONFIG["aspect_ratio"],
+    target_video_length: float = PPL_CONFIG["target_video_length"],
+    task: str = "t2v",
+    first_image_path: str = "",
+    last_image_path: str = "",
+    *,
+    mode: str | None = None,
+    flow_shift: float | None = PPL_CONFIG["flow_shift"],
+    audio_flow_shift: float | None = PPL_CONFIG["audio_flow_shift"],
+) -> MiniMaxH3Generation:
+    """Run T2VA or a supported FL2VA keyframe signature."""
+    if resolution != PPL_CONFIG["resolution"]:
+        expected = PPL_CONFIG["resolution"]
+        raise ValueError(f"MiniMax H3 only supports resolution={expected!r}")
+    resolved_mode = mode or _mode_for_service_task(task)
+    if mode is None and task == "i2v" and not first_image_path:
+        raise ValueError("MiniMax H3 i2v requires first_image_path")
+    if mode is None and task == "fl2v" and (not first_image_path or not last_image_path):
+        raise ValueError("MiniMax H3 fl2v requires first_image_path and last_image_path")
+    conditions = build_fl2va_conditions(
+        mode=resolved_mode,
+        image=first_image_path or None,
+        last_image=last_image_path or None,
+    )
+    return pipeline(
+        task="fl2va" if conditions else "t2va",
+        prompt=prompt,
+        conditions=conditions,
+        target={
+            "short_edge": PPL_CONFIG["short_edge"],
+            "aspect_ratio": aspect_ratio,
+            "duration_seconds": target_video_length,
+        },
+        seed=seed,
+        flow_shift=flow_shift,
+        audio_flow_shift=audio_flow_shift,
+    )
+
+
+def run_with_file(
+    pipeline: MiniMaxH3Pipeline,
+    prompt: str = PPL_CONFIG["prompt"],
+    seed: int = PPL_CONFIG["seed"],
+    output_path: str = "minimax_h3_fl2va.mp4",
+    resolution: str = PPL_CONFIG["resolution"],
+    aspect_ratio: str = PPL_CONFIG["aspect_ratio"],
+    target_video_length: float = PPL_CONFIG["target_video_length"],
+    task: str = "t2v",
+    first_image_path: str = "",
+    last_image_path: str = "",
+    mode: str | None = None,
+    flow_shift: float | None = PPL_CONFIG["flow_shift"],
+    audio_flow_shift: float | None = PPL_CONFIG["audio_flow_shift"],
+    **_: object,
+) -> dict[str, str]:
+    """Run MiniMax H3 FL2VA and save its synchronized audio-video output."""
+    result = run(
+        pipeline,
+        prompt,
+        seed,
+        resolution,
+        aspect_ratio,
+        target_video_length,
+        task,
+        first_image_path,
+        last_image_path,
+        mode=mode,
+        flow_shift=flow_shift,
+        audio_flow_shift=audio_flow_shift,
+    )
+    save_generation(result, output_path)
+    return {"output_path": str(Path(output_path))}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate MiniMax H3 T2VA/FL2VA audio-video on H100 GPUs")
+    parser.add_argument("--model-root", default=PPL_CONFIG["model_root"])
+    parser.add_argument("--mode", choices=("t2va", "first-frame", "last-frame", "first-last"))
+    parser.add_argument("--image", dest="first_image_path", default="")
+    parser.add_argument("--last-image", dest="last_image_path", default="")
+    parser.add_argument("--prompt", default=PPL_CONFIG["prompt"])
+    parser.add_argument(
+        "--target-video-length",
+        "--duration",
+        dest="target_video_length",
+        type=float,
+        default=PPL_CONFIG["target_video_length"],
+    )
+    parser.add_argument("--seed", type=int, default=PPL_CONFIG["seed"])
+    parser.add_argument("--steps", type=int, default=PPL_CONFIG["num_inference_steps"])
+    parser.add_argument(
+        "--aspect-ratio",
+        choices=("auto", "21:9", "16:9", "4:3", "1:1", "3:4", "9:16"),
+        default=PPL_CONFIG["cli_aspect_ratio"],
+    )
+    parser.add_argument("--flow-shift", type=float, default=PPL_CONFIG["flow_shift"])
+    parser.add_argument("--audio-flow-shift", type=float, default=PPL_CONFIG["audio_flow_shift"])
+    parser.add_argument("--device", default=PPL_CONFIG["device"])
+    parser.add_argument("--gpu-num", "--ulysses-degree", dest="gpu_num", type=int, choices=(1, 2, 4), default=1)
+    fsdp_group = parser.add_mutually_exclusive_group()
+    fsdp_group.add_argument("--enable-fsdp", dest="enable_fsdp", action="store_true")
+    fsdp_group.add_argument("--disable-fsdp", dest="enable_fsdp", action="store_false")
+    parser.set_defaults(enable_fsdp=PPL_CONFIG["enable_fsdp"])
+    parser.add_argument("--output-path", "--output", dest="output_path", default="minimax_h3_fl2va.mp4")
+    args = parser.parse_args()
+
+    resolved_mode = args.mode
+    if resolved_mode is None:
+        if args.first_image_path and args.last_image_path:
+            resolved_mode = "first-last"
+        elif args.first_image_path:
+            resolved_mode = "first-frame"
+        elif args.last_image_path:
+            resolved_mode = "last-frame"
+        else:
+            resolved_mode = "t2va"
+    try:
+        build_fl2va_conditions(
+            mode=resolved_mode, image=args.first_image_path or None, last_image=args.last_image_path or None
+        )
+    except ValueError as exc:
+        parser.error(str(exc))
+
+    pipeline = get_pipeline(
+        args.gpu_num,
+        args.model_root,
+        device=args.device,
+        num_inference_steps=args.steps,
+        enable_fsdp=args.enable_fsdp,
+    )
+    try:
+        result = run_with_file(
+            pipeline,
+            prompt=args.prompt,
+            seed=args.seed,
+            output_path=args.output_path,
+            aspect_ratio=args.aspect_ratio,
+            target_video_length=args.target_video_length,
+            first_image_path=args.first_image_path,
+            last_image_path=args.last_image_path,
+            mode=resolved_mode,
+            flow_shift=args.flow_shift,
+            audio_flow_shift=args.audio_flow_shift,
+        )
+        print("Output saved to {}".format(result["output_path"]))
+    finally:
+        pipeline.stop()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/minimax_h3/minimax_h3_ref2va_h100.py b/examples/minimax_h3/minimax_h3_ref2va_h100.py
new file mode 100644
index 00000000..a001266b
--- /dev/null
+++ b/examples/minimax_h3/minimax_h3_ref2va_h100.py
@@ -0,0 +1,245 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+from typing import Any
+
+from telefuser.pipelines.minimax_h3.example_utils import (
+    MINIMAX_H3_DEFAULT_REF2VA_AUDIO,
+    MINIMAX_H3_DEFAULT_REF2VA_VIDEO,
+    load_minimax_h3_pipeline,
+    save_generation,
+)
+from telefuser.pipelines.minimax_h3.pipeline import MiniMaxH3Generation, MiniMaxH3Pipeline
+from telefuser.service.core.contract_templates import build_pipeline_manifest, build_task_contract_template
+
+TF_MODEL_ZOO_PATH = os.environ.get("TF_MODEL_ZOO_PATH", "/hhb-data/aigc/model_zoo")
+PPL_CONFIG: dict[str, Any] = {
+    "name": "minimax_h3_ref2va_h100",
+    "model_root": TF_MODEL_ZOO_PATH + "/MiniMaxAI_MiniMax-H3",
+    "partition": "Ref2VA",
+    "prompt": "Preserve the source identity and motion, and use the reference voice for the dialogue.",
+    "num_inference_steps": 50,
+    "short_edge": 768,
+    "resolution": "768p",
+    "aspect_ratio": "16:9",
+    "cli_aspect_ratio": "auto",
+    "target_video_length": 5,
+    "seed": 0,
+    "flow_shift": None,
+    "audio_flow_shift": None,
+    "device": "cuda:0",
+    "enable_fsdp": None,
+}
+
+PIPELINE_MANIFEST = build_pipeline_manifest(
+    pipeline_name=PPL_CONFIG["name"],
+    supported_tasks=("s2v",),
+    task_contracts={
+        "s2v": build_task_contract_template(
+            "s2v",
+            media_type="video",
+            excluded_parameters=("negative_prompt",),
+            parameter_overrides={
+                "prompt": {
+                    "type": "string",
+                    "required": True,
+                    "default": PPL_CONFIG["prompt"],
+                    "description": "Positive prompt referencing ordered MiniMax H3 materials.",
+                },
+                "conditions": {
+                    "type": "array",
+                    "required": True,
+                    "description": "Ordered image, video, video_audio, and audio reference materials.",
+                },
+                "seed": {"type": "integer", "default": PPL_CONFIG["seed"]},
+                "resolution": {
+                    "type": "string",
+                    "default": PPL_CONFIG["resolution"],
+                    "enum": [PPL_CONFIG["resolution"]],
+                },
+                "aspect_ratio": {
+                    "type": "string",
+                    "default": PPL_CONFIG["aspect_ratio"],
+                    "enum": ["16:9", "4:3", "1:1", "3:4", "9:16"],
+                },
+                "target_video_length": {
+                    "type": "integer",
+                    "default": PPL_CONFIG["target_video_length"],
+                    "description": "Output duration in seconds; MiniMax H3 supports values from 4 through 15.",
+                },
+                "flow_shift": {"type": "number", "default": PPL_CONFIG["flow_shift"]},
+                "audio_flow_shift": {"type": "number", "default": PPL_CONFIG["audio_flow_shift"]},
+                "output_path": {"type": "string", "default": ""},
+            },
+        )
+    },
+)
+
+
+def get_pipeline(
+    parallelism: int = 1,
+    model_root: str = PPL_CONFIG["model_root"],
+    *,
+    device: str = PPL_CONFIG["device"],
+    num_inference_steps: int = PPL_CONFIG["num_inference_steps"],
+    enable_fsdp: bool | None = PPL_CONFIG["enable_fsdp"],
+) -> MiniMaxH3Pipeline:
+    """Load the Ref2VA checkpoint partition for one, two, or four GPUs."""
+    tp_degree = 2 if parallelism == 4 else 1
+    return load_minimax_h3_pipeline(
+        model_root,
+        partition=PPL_CONFIG["partition"],
+        device=device,
+        num_inference_steps=num_inference_steps,
+        ulysses_degree=parallelism // tp_degree,
+        tp_degree=tp_degree,
+        text_encoder_tp_degree=parallelism,
+        enable_fsdp=enable_fsdp,
+    )
+
+
+def default_ref2va_conditions() -> list[dict[str, str]]:
+    """Return the frozen video-then-audio reference order used by the example."""
+    return [
+        {"type": "video", "role": "reference", "uri": str(MINIMAX_H3_DEFAULT_REF2VA_VIDEO)},
+        {"type": "audio", "role": "reference", "uri": str(MINIMAX_H3_DEFAULT_REF2VA_AUDIO)},
+    ]
+
+
+def build_ref2va_conditions(*, images: list[str], videos: list[str], audios: list[str]) -> list[dict[str, str]]:
+    """Build the convenience CLI order: images, videos, then audio."""
+    return [
+        *({"type": "image", "role": "reference", "uri": path} for path in images),
+        *({"type": "video", "role": "reference", "uri": path} for path in videos),
+        *({"type": "audio", "role": "reference", "uri": path} for path in audios),
+    ]
+
+
+def run(
+    pipeline: MiniMaxH3Pipeline,
+    prompt: str = PPL_CONFIG["prompt"],
+    conditions: list[dict[str, Any]] | None = None,
+    seed: int = PPL_CONFIG["seed"],
+    resolution: str = PPL_CONFIG["resolution"],
+    aspect_ratio: str = PPL_CONFIG["aspect_ratio"],
+    target_video_length: float | None = PPL_CONFIG["target_video_length"],
+    task: str = "s2v",
+    *,
+    flow_shift: float | None = PPL_CONFIG["flow_shift"],
+    audio_flow_shift: float | None = PPL_CONFIG["audio_flow_shift"],
+) -> MiniMaxH3Generation:
+    """Run Ref2VA with an ordered heterogeneous condition list."""
+    if task != "s2v":
+        raise ValueError(f"unsupported MiniMax H3 Ref2VA service task: {task}")
+    if resolution != PPL_CONFIG["resolution"]:
+        expected = PPL_CONFIG["resolution"]
+        raise ValueError(f"MiniMax H3 only supports resolution={expected!r}")
+    resolved_conditions = default_ref2va_conditions() if conditions is None else conditions
+    return pipeline(
+        task="ref2va",
+        prompt=prompt,
+        conditions=resolved_conditions,
+        target={
+            "short_edge": PPL_CONFIG["short_edge"],
+            "aspect_ratio": aspect_ratio,
+            "duration_seconds": target_video_length,
+        },
+        seed=seed,
+        flow_shift=flow_shift,
+        audio_flow_shift=audio_flow_shift,
+    )
+
+
+def run_with_file(
+    pipeline: MiniMaxH3Pipeline,
+    prompt: str = PPL_CONFIG["prompt"],
+    conditions: list[dict[str, Any]] | None = None,
+    seed: int = PPL_CONFIG["seed"],
+    output_path: str = "minimax_h3_ref2va.mp4",
+    resolution: str = PPL_CONFIG["resolution"],
+    aspect_ratio: str = PPL_CONFIG["aspect_ratio"],
+    target_video_length: float | None = PPL_CONFIG["target_video_length"],
+    task: str = "s2v",
+    flow_shift: float | None = PPL_CONFIG["flow_shift"],
+    audio_flow_shift: float | None = PPL_CONFIG["audio_flow_shift"],
+    **_: object,
+) -> dict[str, str]:
+    """Run MiniMax H3 Ref2VA and save its synchronized audio-video output."""
+    result = run(
+        pipeline,
+        prompt,
+        conditions,
+        seed,
+        resolution,
+        aspect_ratio,
+        target_video_length,
+        task,
+        flow_shift=flow_shift,
+        audio_flow_shift=audio_flow_shift,
+    )
+    save_generation(result, output_path)
+    return {"output_path": str(Path(output_path))}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate MiniMax H3 Ref2VA audio-video on H100 GPUs")
+    parser.add_argument("--model-root", default=PPL_CONFIG["model_root"])
+    parser.add_argument("--image", action="append", default=[])
+    parser.add_argument("--video", action="append", default=[])
+    parser.add_argument("--audio", action="append", default=[])
+    parser.add_argument("--prompt", default=PPL_CONFIG["prompt"])
+    parser.add_argument(
+        "--target-video-length",
+        "--duration",
+        dest="target_video_length",
+        type=float,
+        default=PPL_CONFIG["target_video_length"],
+    )
+    parser.add_argument("--seed", type=int, default=PPL_CONFIG["seed"])
+    parser.add_argument("--steps", type=int, default=PPL_CONFIG["num_inference_steps"])
+    parser.add_argument(
+        "--aspect-ratio",
+        choices=("auto", "21:9", "16:9", "4:3", "1:1", "3:4", "9:16"),
+        default=PPL_CONFIG["cli_aspect_ratio"],
+    )
+    parser.add_argument("--flow-shift", type=float, default=PPL_CONFIG["flow_shift"])
+    parser.add_argument("--audio-flow-shift", type=float, default=PPL_CONFIG["audio_flow_shift"])
+    parser.add_argument("--device", default=PPL_CONFIG["device"])
+    parser.add_argument("--gpu-num", "--ulysses-degree", dest="gpu_num", type=int, choices=(1, 2, 4), default=1)
+    fsdp_group = parser.add_mutually_exclusive_group()
+    fsdp_group.add_argument("--enable-fsdp", dest="enable_fsdp", action="store_true")
+    fsdp_group.add_argument("--disable-fsdp", dest="enable_fsdp", action="store_false")
+    parser.set_defaults(enable_fsdp=PPL_CONFIG["enable_fsdp"])
+    parser.add_argument("--output-path", "--output", dest="output_path", default="minimax_h3_ref2va.mp4")
+    args = parser.parse_args()
+
+    conditions = build_ref2va_conditions(images=args.image, videos=args.video, audios=args.audio)
+    pipeline = get_pipeline(
+        args.gpu_num,
+        args.model_root,
+        device=args.device,
+        num_inference_steps=args.steps,
+        enable_fsdp=args.enable_fsdp,
+    )
+    try:
+        result = run_with_file(
+            pipeline,
+            prompt=args.prompt,
+            conditions=conditions or None,
+            seed=args.seed,
+            output_path=args.output_path,
+            aspect_ratio=args.aspect_ratio,
+            target_video_length=args.target_video_length,
+            flow_shift=args.flow_shift,
+            audio_flow_shift=args.audio_flow_shift,
+        )
+        print("Output saved to {}".format(result["output_path"]))
+    finally:
+        pipeline.stop()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/minimax_h3/minimax_h3_request_h100.py b/examples/minimax_h3/minimax_h3_request_h100.py
new file mode 100644
index 00000000..e71f0de2
--- /dev/null
+++ b/examples/minimax_h3/minimax_h3_request_h100.py
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+from typing import Any
+
+from telefuser.pipelines.minimax_h3.example_utils import (
+    MINIMAX_H3_DEFAULT_REQUEST,
+    load_minimax_h3_pipeline,
+    load_minimax_h3_request,
+    partition_for_minimax_h3_request,
+    save_generation,
+)
+from telefuser.pipelines.minimax_h3.pipeline import MiniMaxH3Generation, MiniMaxH3Pipeline
+
+TF_MODEL_ZOO_PATH = os.environ.get("TF_MODEL_ZOO_PATH", "/hhb-data/aigc/model_zoo")
+PPL_CONFIG: dict[str, Any] = {
+    "name": "minimax_h3_request_h100",
+    "model_root": TF_MODEL_ZOO_PATH + "/MiniMaxAI_MiniMax-H3",
+    "request_path": str(MINIMAX_H3_DEFAULT_REQUEST),
+    "num_inference_steps": None,
+    "device": "cuda:0",
+    "enable_fsdp": None,
+}
+
+
+def _load_request(request_path: str, num_inference_steps: int | None) -> dict[str, Any]:
+    request = load_minimax_h3_request(request_path)
+    if num_inference_steps is not None:
+        request["num_inference_steps"] = num_inference_steps
+    return request
+
+
+def get_pipeline(
+    parallelism: int = 1,
+    model_root: str = PPL_CONFIG["model_root"],
+    *,
+    request_path: str = PPL_CONFIG["request_path"],
+    device: str = PPL_CONFIG["device"],
+    num_inference_steps: int | None = PPL_CONFIG["num_inference_steps"],
+    enable_fsdp: bool | None = PPL_CONFIG["enable_fsdp"],
+) -> MiniMaxH3Pipeline:
+    """Load the checkpoint partition required by a local JSON request."""
+    request = _load_request(request_path, num_inference_steps)
+    configured_steps = int(request.get("num_inference_steps", 50))
+    tp_degree = 2 if parallelism == 4 else 1
+    return load_minimax_h3_pipeline(
+        model_root,
+        partition=partition_for_minimax_h3_request(request),
+        device=device,
+        num_inference_steps=configured_steps,
+        ulysses_degree=parallelism // tp_degree,
+        tp_degree=tp_degree,
+        text_encoder_tp_degree=parallelism,
+        enable_fsdp=enable_fsdp,
+    )
+
+
+def run(
+    pipeline: MiniMaxH3Pipeline,
+    request_path: str = PPL_CONFIG["request_path"],
+    num_inference_steps: int | None = PPL_CONFIG["num_inference_steps"],
+) -> MiniMaxH3Generation:
+    """Run a complete JSON request without changing its condition order."""
+    return pipeline(**_load_request(request_path, num_inference_steps))
+
+
+def run_with_file(
+    pipeline: MiniMaxH3Pipeline,
+    request_path: str = PPL_CONFIG["request_path"],
+    output_path: str = "minimax_h3_request.mp4",
+    num_inference_steps: int | None = PPL_CONFIG["num_inference_steps"],
+    **_: object,
+) -> dict[str, str]:
+    """Run a complete JSON request and save its synchronized MP4."""
+    result = run(pipeline, request_path, num_inference_steps)
+    save_generation(result, output_path)
+    return {"output_path": str(Path(output_path))}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run a complete ordered MiniMax H3 JSON request on H100 GPUs")
+    parser.add_argument("--request", dest="request_path", default=PPL_CONFIG["request_path"])
+    parser.add_argument("--model-root", default=PPL_CONFIG["model_root"])
+    parser.add_argument("--steps", type=int, default=PPL_CONFIG["num_inference_steps"])
+    parser.add_argument("--device", default=PPL_CONFIG["device"])
+    parser.add_argument("--gpu-num", "--ulysses-degree", dest="gpu_num", type=int, choices=(1, 2, 4), default=1)
+    fsdp_group = parser.add_mutually_exclusive_group()
+    fsdp_group.add_argument("--enable-fsdp", dest="enable_fsdp", action="store_true")
+    fsdp_group.add_argument("--disable-fsdp", dest="enable_fsdp", action="store_false")
+    parser.set_defaults(enable_fsdp=PPL_CONFIG["enable_fsdp"])
+    parser.add_argument("--output-path", "--output", dest="output_path", default="minimax_h3_request.mp4")
+    args = parser.parse_args()
+
+    pipeline = get_pipeline(
+        args.gpu_num,
+        args.model_root,
+        request_path=args.request_path,
+        device=args.device,
+        num_inference_steps=args.steps,
+        enable_fsdp=args.enable_fsdp,
+    )
+    try:
+        result = run_with_file(
+            pipeline,
+            request_path=args.request_path,
+            output_path=args.output_path,
+            num_inference_steps=args.steps,
+        )
+        print("Output saved to {}".format(result["output_path"]))
+    finally:
+        pipeline.stop()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/run_examples.py b/examples/run_examples.py
index 051b7587..6548fd1a 100644
--- a/examples/run_examples.py
+++ b/examples/run_examples.py
@@ -583,6 +583,8 @@ def _process_completed_job(self, job: RunningJob) -> Result:
                 job.ppl_cfg.ssim_min,
                 job.ppl_cfg.pixel_diff_max,
                 self.update_baseline,
+                require_audio=job.ppl_cfg.require_audio,
+                audio_cosine_min=job.ppl_cfg.audio_cosine_min,
             )
             result.regression_metrics = cmp.get("metrics", {})
             result.note = cmp["message"]
@@ -698,10 +700,14 @@ class PipelineConfig:
     first_image_path: str | None = None
     last_image_path: str | None = None
     input_video_path: str | None = None
+    target_video_length: float | None = None
+    use_run_with_file: bool = False
+    require_audio: bool = False
     ppl_config_overrides: dict = field(default_factory=dict)
     # Regression thresholds
     psnr_min: float = 25.0
     ssim_min: float = 0.85
+    audio_cosine_min: float = 0.95
     pixel_diff_max: float = 0.02
     # Performance thresholds (None = disabled)
     max_elapsed_seconds: float | None = None
@@ -863,9 +869,15 @@ def _call_get_pipeline(module: ModuleType, config: dict) -> object:
     return func(**kwargs)
 
 
-def _call_run(module: ModuleType, pipeline: object, config: dict) -> object:
-    """Call run() with arguments matched by signature inspection."""
-    func = module.run
+def _call_run(
+    module: ModuleType,
+    pipeline: object,
+    config: dict,
+    *,
+    entrypoint: str = "run",
+) -> object:
+    """Call an example run entrypoint with arguments matched by signature inspection."""
+    func = getattr(module, entrypoint)
     params = list(inspect.signature(func).parameters.keys())
     kwargs: dict = {"pipeline": pipeline}
 
@@ -1007,6 +1019,19 @@ def _save_output(
     if output is None:
         return None, None, None
 
+    if isinstance(output, dict) and isinstance(output.get("output_path"), (str, os.PathLike)):
+        output_path = os.fspath(output["output_path"])
+        if not os.path.isfile(output_path):
+            raise FileNotFoundError(f"Example file entrypoint did not produce {output_path}")
+        if output_type == "video":
+            from telefuser.utils.video import VideoData
+
+            video = VideoData(video_file=output_path)
+            return output_path, len(video), f"{video.width}x{video.height}"
+        if output_type == "image":
+            with Image.open(output_path) as image:
+                return output_path, 1, f"{image.width}x{image.height}"
+
     # Use custom filename or default
     default_name = f"output.{('mp4' if output_type == 'video' else 'png')}"
     output_filename = filename or default_name
@@ -1133,6 +1158,7 @@ def _run_single(pipeline_key: str, config_path: str | None, output_dir: str | No
         "first_image_path": ppl_cfg.first_image_path,
         "last_image_path": ppl_cfg.last_image_path,
         "input_video_path": ppl_cfg.input_video_path,
+        "target_video_length": ppl_cfg.target_video_length,
         "ppl_config_overrides": ppl_config_overrides,
         "script": ppl_cfg.script,  # Pass script for filename generation
     }
@@ -1142,6 +1168,7 @@ def _run_single(pipeline_key: str, config_path: str | None, output_dir: str | No
     pipeline = None
     gpu_mem_peak = 0.0
     start = time.time()
+    temp_dir = os.path.join(output_root, "temp", timestamp)
 
     # Phase 1: Model Loading
     try:
@@ -1169,7 +1196,15 @@ def _run_single(pipeline_key: str, config_path: str | None, output_dir: str | No
                 torch.cuda.synchronize()
                 torch.cuda.reset_peak_memory_stats()
 
-            output = _call_run(module, pipeline, runner_config)
+            if ppl_cfg.use_run_with_file:
+                if not callable(getattr(module, "run_with_file", None)):
+                    raise AttributeError(f"{ppl_cfg.script} does not expose run_with_file()")
+                extension = "mp4" if ppl_cfg.output_type == "video" else "png"
+                os.makedirs(temp_dir, exist_ok=True)
+                runner_config["output_path"] = os.path.join(temp_dir, f"output.{extension}")
+                output = _call_run(module, pipeline, runner_config, entrypoint="run_with_file")
+            else:
+                output = _call_run(module, pipeline, runner_config)
 
             if torch.cuda.is_available():
                 torch.cuda.synchronize()
@@ -1200,7 +1235,6 @@ def _run_single(pipeline_key: str, config_path: str | None, output_dir: str | No
         output_fps = ppl_config.get("target_fps", ppl_config.get("fps", 15))
 
         # First save to temp location to get resolution
-        temp_dir = os.path.join(output_root, "temp", timestamp)
         try:
             temp_path, num_frames, resolution = _save_output(output, temp_dir, ppl_cfg.output_type, fps=output_fps)
         except Exception as e:
@@ -1266,8 +1300,119 @@ def _run_single(pipeline_key: str, config_path: str | None, output_dir: str | No
 # =============================================================================
 
 
-def compute_video_metrics(baseline_path: str, current_path: str) -> dict[str, float]:
-    """Compute PSNR and SSIM between two videos using streaming frame comparison."""
+def _probe_audio_stream(path: str) -> dict[str, int | float] | None:
+    """Return first-audio-stream facts without decoding video frames."""
+    result = subprocess.run(
+        [
+            "ffprobe",
+            "-v",
+            "error",
+            "-select_streams",
+            "a:0",
+            "-show_entries",
+            "stream=sample_rate,channels,duration:format=duration",
+            "-of",
+            "json",
+            path,
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    payload = json.loads(result.stdout)
+    streams = payload.get("streams") or []
+    if not streams:
+        return None
+    stream = streams[0]
+    sample_rate = int(stream.get("sample_rate") or 0)
+    channels = int(stream.get("channels") or 0)
+    duration = float(stream.get("duration") or (payload.get("format") or {}).get("duration") or 0.0)
+    if sample_rate <= 0 or channels <= 0 or duration <= 0:
+        raise ValueError(f"Audio stream metadata is incomplete: {path}")
+    return {"sample_rate": sample_rate, "channels": channels, "duration": duration}
+
+
+def _decode_audio(path: str, *, sample_rate: int, channels: int) -> np.ndarray:
+    """Decode the first audio stream to interleaved float32 PCM."""
+    result = subprocess.run(
+        [
+            "ffmpeg",
+            "-v",
+            "error",
+            "-i",
+            path,
+            "-map",
+            "0:a:0",
+            "-ar",
+            str(sample_rate),
+            "-ac",
+            str(channels),
+            "-f",
+            "f32le",
+            "-acodec",
+            "pcm_f32le",
+            "pipe:1",
+        ],
+        check=True,
+        capture_output=True,
+        timeout=120,
+    )
+    return np.frombuffer(result.stdout, dtype="<f4")
+
+
+def _compute_audio_metrics(baseline_path: str, current_path: str, *, required: bool) -> dict[str, float]:
+    baseline_info = _probe_audio_stream(baseline_path)
+    current_info = _probe_audio_stream(current_path)
+    if baseline_info is None and current_info is None and not required:
+        return {}
+    if baseline_info is None:
+        raise ValueError("Baseline video has no audio stream")
+    if current_info is None:
+        raise ValueError("Current video has no audio stream")
+
+    for audio_field in ("sample_rate", "channels"):
+        if baseline_info[audio_field] != current_info[audio_field]:
+            raise ValueError(
+                f"Audio {audio_field} mismatch: baseline={baseline_info[audio_field]}, current={current_info[audio_field]}"
+            )
+    duration_delta = abs(float(baseline_info["duration"]) - float(current_info["duration"]))
+    duration_tolerance = max(0.05, 2048 / int(baseline_info["sample_rate"]))
+    if duration_delta > duration_tolerance:
+        raise ValueError(
+            "Audio duration mismatch: "
+            f"baseline={baseline_info['duration']:.6f}s, current={current_info['duration']:.6f}s"
+        )
+
+    decode_kwargs = {
+        "sample_rate": int(baseline_info["sample_rate"]),
+        "channels": int(baseline_info["channels"]),
+    }
+    baseline_audio = _decode_audio(baseline_path, **decode_kwargs)
+    current_audio = _decode_audio(current_path, **decode_kwargs)
+    sample_tolerance = 2048 * decode_kwargs["channels"]
+    if abs(baseline_audio.size - current_audio.size) > sample_tolerance:
+        raise ValueError(f"Audio sample count mismatch: baseline={baseline_audio.size}, current={current_audio.size}")
+    sample_count = min(baseline_audio.size, current_audio.size)
+    if sample_count == 0:
+        raise ValueError("Audio stream decodes to no samples")
+    baseline_audio = baseline_audio[:sample_count].astype(np.float64, copy=False)
+    current_audio = current_audio[:sample_count].astype(np.float64, copy=False)
+    baseline_norm = float(np.linalg.norm(baseline_audio))
+    current_norm = float(np.linalg.norm(current_audio))
+    if baseline_norm == 0.0 or current_norm == 0.0:
+        raise ValueError("Audio stream decodes to silence")
+    cosine = float(np.dot(baseline_audio, current_audio) / (baseline_norm * current_norm))
+    return {"audio_cosine": cosine, "audio_duration_delta": duration_delta}
+
+
+def compute_video_metrics(
+    baseline_path: str,
+    current_path: str,
+    *,
+    require_audio: bool = False,
+) -> dict[str, float]:
+    """Compute video-frame metrics and optional decoded-audio similarity."""
     from skimage.metrics import peak_signal_noise_ratio, structural_similarity
 
     from telefuser.utils.video import VideoData
@@ -1299,7 +1444,10 @@ def compute_video_metrics(baseline_path: str, current_path: str) -> dict[str, fl
 
     del video_true, video_test
 
-    return {"psnr": psnr_sum / n, "ssim": ssim_sum / n}
+    metrics = {"psnr": psnr_sum / n, "ssim": ssim_sum / n}
+    if require_audio:
+        metrics.update(_compute_audio_metrics(baseline_path, current_path, required=True))
+    return metrics
 
 
 def compute_image_diff(baseline_path: str, current_path: str) -> float | None:
@@ -1430,14 +1578,32 @@ def compare_against_baseline(
     ssim_min: float,
     pixel_diff_max: float,
     update_baseline: bool = False,
+    *,
+    require_audio: bool = False,
+    audio_cosine_min: float = 0.95,
 ) -> dict:
     """Compare current output against baseline. Returns dict with passed, metrics, message."""
     baseline_path = _get_baseline_path(output_root, script, gpu_count, output_type)
 
     if baseline_path is None:
         if update_baseline and current_path and os.path.exists(current_path):
-            saved = _update_baseline(output_root, current_path)
-            return {"passed": True, "baseline_exists": False, "metrics": {}, "message": f"Saved as baseline: {saved}"}
+            try:
+                if output_type == "video" and require_audio:
+                    _compute_audio_metrics(current_path, current_path, required=True)
+                saved = _update_baseline(output_root, current_path)
+                return {
+                    "passed": True,
+                    "baseline_exists": False,
+                    "metrics": {},
+                    "message": f"Saved as baseline: {saved}",
+                }
+            except Exception as e:
+                return {
+                    "passed": False,
+                    "baseline_exists": False,
+                    "metrics": {},
+                    "message": f"Invalid baseline: {e}",
+                }
         return {
             "passed": False,
             "baseline_exists": False,
@@ -1450,7 +1616,7 @@ def compare_against_baseline(
 
     try:
         if output_type == "video":
-            m = compute_video_metrics(baseline_path, current_path)
+            m = compute_video_metrics(baseline_path, current_path, require_audio=require_audio)
             psnr, ssim = m.get("psnr"), m.get("ssim")
             if not isinstance(psnr, (int, float)) or not isinstance(ssim, (int, float)):
                 return {
@@ -1459,15 +1625,31 @@ def compare_against_baseline(
                     "metrics": m,
                     "message": "Video comparison produced no PSNR/SSIM metrics",
                 }
+            audio_cosine = m.get("audio_cosine")
+            if require_audio and not isinstance(audio_cosine, (int, float)):
+                return {
+                    "passed": False,
+                    "baseline_exists": True,
+                    "metrics": m,
+                    "message": "Required audio comparison produced no cosine metric",
+                }
             passed = True
             msgs = []
             if psnr is not None and psnr < psnr_min:
                 passed = False
                 msgs.append(f"PSNR {psnr:.2f} < {psnr_min}")
+            if audio_cosine is not None and audio_cosine < audio_cosine_min:
+                passed = False
+                msgs.append(f"audio cosine {audio_cosine:.4f} < {audio_cosine_min:.4f}")
             if ssim is not None and ssim < ssim_min:
                 passed = False
                 msgs.append(f"SSIM {ssim:.4f} < {ssim_min}")
-            msg = "; ".join(msgs) if msgs else f"PSNR={psnr:.2f}, SSIM={ssim:.4f}"
+            if msgs:
+                msg = "; ".join(msgs)
+            else:
+                msg = f"PSNR={psnr:.2f}, SSIM={ssim:.4f}"
+                if audio_cosine is not None:
+                    msg += f", audio cosine={audio_cosine:.4f}"
             return {"passed": passed, "baseline_exists": True, "metrics": m, "message": msg}
         else:
             diff = compute_image_diff(baseline_path, current_path)
@@ -1748,6 +1930,8 @@ def run_pipeline(
             ppl_cfg.ssim_min,
             ppl_cfg.pixel_diff_max,
             update_baseline,
+            require_audio=ppl_cfg.require_audio,
+            audio_cosine_min=ppl_cfg.audio_cosine_min,
         )
         result.regression_metrics = cmp.get("metrics", {})
         result.note = cmp["message"]
diff --git a/telefuser/distributed/device_mesh.py b/telefuser/distributed/device_mesh.py
index ce46a54b..8281327e 100644
--- a/telefuser/distributed/device_mesh.py
+++ b/telefuser/distributed/device_mesh.py
@@ -87,17 +87,10 @@ def _validate_parallel_config(parallel_config: ParallelConfig) -> None:
     """Validate parallel configuration constraints.
 
     Raises:
-        ValueError: If SP and TP are both enabled, or if world_size doesn't match expected value.
+        ValueError: If world_size doesn't match the configured parallel degrees.
     """
     sp_degree = parallel_config.sp_ulysses_degree * parallel_config.sp_ring_degree
 
-    # SP and TP are mutually exclusive
-    if sp_degree > 1 and parallel_config.tp_degree > 1:
-        raise ValueError(
-            f"Not allowed to enable sequence parallel and tensor parallel together. "
-            f"sp_degree={sp_degree}, tp_degree={parallel_config.tp_degree}"
-        )
-
     # Verify world_size matches expected total
     expected_world_size = (
         parallel_config.cfg_degree
diff --git a/telefuser/distributed/ulysses_comm.py b/telefuser/distributed/ulysses_comm.py
index faf58332..364d27fb 100644
--- a/telefuser/distributed/ulysses_comm.py
+++ b/telefuser/distributed/ulysses_comm.py
@@ -107,3 +107,80 @@ def wait() -> torch.Tensor:
             return result.flatten(0, 1).permute(1, 2, 0, 3)
 
     return wait
+
+
+def _can_use_destination_major_kernel(*tensors: torch.Tensor) -> bool:
+    return (
+        bool(tensors)
+        and all(tensor.is_cuda for tensor in tensors)
+        and all(tensor.dtype in (torch.float16, torch.bfloat16) for tensor in tensors)
+        and all(tensor.dtype == tensors[0].dtype for tensor in tensors)
+        and all(tensor.stride(-1) == 1 for tensor in tensors)
+        and not torch.compiler.is_compiling()
+    )
+
+
+def ulysses_scatter_qkv(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    process_group: dist.ProcessGroup,
+) -> Callable[[], tuple[torch.Tensor, torch.Tensor, torch.Tensor]]:
+    """Scatter Q/K/V with one destination-major collective and no intermediate concat."""
+    if query.shape != key.shape or query.shape != value.shape or query.ndim != 4:
+        raise ValueError("Ulysses Q/K/V scatter requires matching 4D tensors")
+    _, world_size = _get_distributed_info(process_group)
+    batch, local_seq_len, num_heads, head_dim = query.shape
+    local_heads = _local_head_count(num_heads, world_size)
+    if batch != 1 or not _can_use_destination_major_kernel(query, key, value):
+        combined_wait = ulysses_scatter_heads(torch.cat((query, key, value), dim=-1), process_group)
+
+        def fallback_wait() -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+            return combined_wait().chunk(3, dim=-1)
+
+        return fallback_wait
+
+    from telefuser.kernel.triton.ulysses_relayout import pack_qkv_destination_major
+
+    packed = pack_qkv_destination_major(query[0], key[0], value[0], world_size)
+    output = torch.empty_like(packed.flatten())
+    dist.all_to_all_single(output, packed.flatten(), group=process_group)
+
+    def wait() -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        result = output.reshape(world_size * local_seq_len, local_heads, 3 * head_dim).unsqueeze(0)
+        return result.chunk(3, dim=-1)
+
+    return wait
+
+
+def ulysses_gather_heads_destination_major(
+    tensor: torch.Tensor,
+    process_group: dist.ProcessGroup,
+    *,
+    num_heads: int,
+) -> Callable[[], torch.Tensor]:
+    """Gather heads using sequence-major NCCL input and one fused output relayout."""
+    if tensor.ndim != 4:
+        raise ValueError("Ulysses head gather requires a 4D tensor")
+    _, world_size = _get_distributed_info(process_group)
+    batch, global_seq_len, local_heads, head_dim = tensor.shape
+    if global_seq_len % world_size:
+        raise ValueError(f"Ulysses sequence length ({global_seq_len}) must be divisible by world_size ({world_size})")
+    expected_local_heads = _local_head_count(num_heads, world_size)
+    if local_heads != expected_local_heads:
+        raise ValueError(f"Ulysses local head count must be {expected_local_heads}, got {local_heads}")
+    if not _can_use_destination_major_kernel(tensor):
+        return ulysses_gather_heads(tensor, process_group, num_heads=num_heads)
+
+    from telefuser.kernel.triton.ulysses_relayout import merge_ulysses_heads
+
+    local_seq_len = global_seq_len // world_size
+    packed = tensor.permute(1, 0, 2, 3).contiguous()
+    output = torch.empty_like(packed.flatten())
+    dist.all_to_all_single(output, packed.flatten(), group=process_group)
+
+    def wait() -> torch.Tensor:
+        received = output.reshape(world_size, local_seq_len, batch, local_heads, head_dim)
+        return merge_ulysses_heads(received).flatten(2, 3)
+
+    return wait
diff --git a/telefuser/kernel/triton/__init__.py b/telefuser/kernel/triton/__init__.py
index 80d7e60a..586795fc 100644
--- a/telefuser/kernel/triton/__init__.py
+++ b/telefuser/kernel/triton/__init__.py
@@ -10,6 +10,7 @@
 Note: All functions in this module require triton to be installed.
 """
 
+from .indexed_modulation import indexed_gate_bf16_, indexed_scale_shift_bf16_
 from .merge_attn_states import fused_merge_attn_states
 from .norm import (
     fused_add_rms_norm,
@@ -17,6 +18,7 @@
     norm_infer,
     triton_one_pass_rms_norm,
 )
+from .qknorm_rope import qknorm_rope_neox_bf16_
 from .quant import per_token_dequant_fp8, per_token_quant_fp8
 from .rotary import apply_rotary_embedding
 from .scale_shift import (
@@ -27,6 +29,8 @@
     fused_scale_shift,
     fused_scale_shift_gate_select,
 )
+from .silu_mul import silu_and_mul_bf16_input_inplace_
+from .ulysses_relayout import merge_ulysses_heads, pack_qkv_destination_major
 
 __all__ = [
     "layer_norm_fn",
@@ -42,6 +46,12 @@
     "fused_layernorm_scale_shift_gate_select01",
     "fused_residual_layernorm_scale_shift_gate_select01",
     "fused_merge_attn_states",
+    "indexed_gate_bf16_",
+    "indexed_scale_shift_bf16_",
+    "qknorm_rope_neox_bf16_",
     "per_token_quant_fp8",
     "per_token_dequant_fp8",
+    "pack_qkv_destination_major",
+    "merge_ulysses_heads",
+    "silu_and_mul_bf16_input_inplace_",
 ]
diff --git a/telefuser/kernel/triton/indexed_modulation.py b/telefuser/kernel/triton/indexed_modulation.py
new file mode 100644
index 00000000..10cfafbf
--- /dev/null
+++ b/telefuser/kernel/triton/indexed_modulation.py
@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: Apache-2.0
+"""In-place indexed modulation kernels for packed diffusion sequences."""
+
+from __future__ import annotations
+
+import torch
+import triton
+import triton.language as tl
+
+
+@triton.jit
+def _round_bf16_to_fp32(value):
+    bits = value.to(tl.int32, bitcast=True)
+    rounding_bias = 0x7FFF + ((bits >> 16) & 1)
+    rounded_bits = (bits + rounding_bias) & -65536
+    return rounded_bits.to(tl.float32, bitcast=True)
+
+
+@triton.jit
+def _indexed_scale_shift_bf16_kernel(
+    output_ptr,
+    x_ptr,
+    shift_ptr,
+    scale_ptr,
+    indices_ptr,
+    hidden_size,
+    parameter_rows,
+    stride_x_row,
+    stride_shift_row,
+    stride_scale_row,
+    stride_indices,
+    BLOCK_N: tl.constexpr,
+):
+    row = tl.program_id(0)
+    columns = tl.arange(0, BLOCK_N)
+    mask = columns < hidden_size
+    index = tl.load(indices_ptr + row * stride_indices)
+    index_mask = mask & (index >= 0) & (index < parameter_rows)
+    x = tl.load(x_ptr + row * stride_x_row + columns, mask=mask, other=0.0).to(tl.float32)
+    shift = tl.load(shift_ptr + index * stride_shift_row + columns, mask=index_mask, other=0.0).to(tl.float32)
+    scale = tl.load(scale_ptr + index * stride_scale_row + columns, mask=index_mask, other=0.0).to(tl.float32)
+    one_plus_scale = _round_bf16_to_fp32(1.0 + scale)
+    scaled = _round_bf16_to_fp32(x * one_plus_scale)
+    tl.store(output_ptr + row * stride_x_row + columns, scaled + shift, mask=mask)
+
+
+@triton.jit
+def _indexed_gate_bf16_kernel(
+    output_ptr,
+    x_ptr,
+    gate_ptr,
+    other_ptr,
+    indices_ptr,
+    hidden_size,
+    parameter_rows,
+    stride_x_row,
+    stride_gate_row,
+    stride_other_row,
+    stride_indices,
+    BLOCK_N: tl.constexpr,
+):
+    row = tl.program_id(0)
+    columns = tl.arange(0, BLOCK_N)
+    mask = columns < hidden_size
+    index = tl.load(indices_ptr + row * stride_indices)
+    index_mask = mask & (index >= 0) & (index < parameter_rows)
+    x = tl.load(x_ptr + row * stride_x_row + columns, mask=mask, other=0.0).to(tl.float32)
+    gate = tl.load(gate_ptr + index * stride_gate_row + columns, mask=index_mask, other=0.0).to(tl.float32)
+    other = tl.load(other_ptr + row * stride_other_row + columns, mask=mask, other=0.0).to(tl.float32)
+    gated = _round_bf16_to_fp32(gate * other)
+    tl.store(output_ptr + row * stride_x_row + columns, x + gated, mask=mask)
+
+
+def indexed_scale_shift_bf16_(
+    x: torch.Tensor,
+    shift: torch.Tensor,
+    scale: torch.Tensor,
+    indices: torch.Tensor,
+) -> torch.Tensor:
+    """Apply indexed scale/shift in place to a contiguous BF16 matrix."""
+    rows, hidden_size = x.shape
+    if rows == 0:
+        return x
+    _indexed_scale_shift_bf16_kernel[(rows,)](
+        x,
+        x,
+        shift,
+        scale,
+        indices,
+        hidden_size,
+        shift.shape[0],
+        x.stride(0),
+        shift.stride(0),
+        scale.stride(0),
+        indices.stride(0),
+        BLOCK_N=triton.next_power_of_2(hidden_size),
+        num_warps=8,
+    )
+    return x
+
+
+def indexed_gate_bf16_(
+    x: torch.Tensor,
+    gate: torch.Tensor,
+    other: torch.Tensor,
+    indices: torch.Tensor,
+) -> torch.Tensor:
+    """Apply an indexed gated residual in place to a contiguous BF16 matrix."""
+    rows, hidden_size = x.shape
+    if rows == 0:
+        return x
+    _indexed_gate_bf16_kernel[(rows,)](
+        x,
+        x,
+        gate,
+        other,
+        indices,
+        hidden_size,
+        gate.shape[0],
+        x.stride(0),
+        gate.stride(0),
+        other.stride(0),
+        indices.stride(0),
+        BLOCK_N=triton.next_power_of_2(hidden_size),
+        num_warps=8,
+    )
+    return x
diff --git a/telefuser/kernel/triton/qknorm_rope.py b/telefuser/kernel/triton/qknorm_rope.py
new file mode 100644
index 00000000..f3fd9910
--- /dev/null
+++ b/telefuser/kernel/triton/qknorm_rope.py
@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Fused in-place Q/K RMSNorm and partial NeoX RoPE."""
+
+from __future__ import annotations
+
+import torch
+import triton
+import triton.language as tl
+
+
+@triton.jit
+def _round_bf16_to_fp32(value):
+    bits = value.to(tl.int32, bitcast=True)
+    rounding_bias = 0x7FFF + ((bits >> 16) & 1)
+    rounded_bits = (bits + rounding_bias) & -65536
+    return rounded_bits.to(tl.float32, bitcast=True)
+
+
+@triton.jit
+def _qknorm_rope_neox_bf16_kernel(
+    query_ptr,
+    key_ptr,
+    q_weight_ptr,
+    k_weight_ptr,
+    cache_ptr,
+    heads,
+    head_dim,
+    rope_dim,
+    eps,
+    stride_q_row,
+    stride_q_head,
+    stride_k_row,
+    stride_k_head,
+    stride_cache_row,
+    BLOCK_N: tl.constexpr,
+):
+    program = tl.program_id(0)
+    row = program // heads
+    head = program - row * heads
+    columns = tl.arange(0, BLOCK_N)
+    mask = columns < head_dim
+    q_base = query_ptr + row * stride_q_row + head * stride_q_head
+    k_base = key_ptr + row * stride_k_row + head * stride_k_head
+    query = tl.load(q_base + columns, mask=mask, other=0.0).to(tl.float32)
+    key = tl.load(k_base + columns, mask=mask, other=0.0).to(tl.float32)
+    q_weight = tl.load(q_weight_ptr + columns, mask=mask, other=0.0).to(tl.float32)
+    k_weight = tl.load(k_weight_ptr + columns, mask=mask, other=0.0).to(tl.float32)
+    q_inv_rms = tl.rsqrt(tl.sum(query * query, axis=0) / head_dim + eps)
+    k_inv_rms = tl.rsqrt(tl.sum(key * key, axis=0) / head_dim + eps)
+    query = _round_bf16_to_fp32(query * q_inv_rms * q_weight)
+    key = _round_bf16_to_fp32(key * k_inv_rms * k_weight)
+
+    rope_half = rope_dim // 2
+    rotary_mask = columns < rope_dim
+    partner_columns = tl.where(columns < rope_half, columns + rope_half, columns - rope_half)
+    q_partner = tl.load(q_base + partner_columns, mask=rotary_mask, other=0.0).to(tl.float32)
+    k_partner = tl.load(k_base + partner_columns, mask=rotary_mask, other=0.0).to(tl.float32)
+    q_partner_weight = tl.load(q_weight_ptr + partner_columns, mask=rotary_mask, other=0.0).to(tl.float32)
+    k_partner_weight = tl.load(k_weight_ptr + partner_columns, mask=rotary_mask, other=0.0).to(tl.float32)
+    q_partner = _round_bf16_to_fp32(q_partner * q_inv_rms * q_partner_weight)
+    k_partner = _round_bf16_to_fp32(k_partner * k_inv_rms * k_partner_weight)
+    frequency_column = columns % rope_half
+    cosine = tl.load(cache_ptr + row * stride_cache_row + frequency_column, mask=rotary_mask, other=1.0).to(tl.float32)
+    sine = tl.load(cache_ptr + row * stride_cache_row + rope_half + frequency_column, mask=rotary_mask, other=0.0).to(
+        tl.float32
+    )
+    q_rotated = tl.where(
+        columns < rope_half,
+        query * cosine - q_partner * sine,
+        query * cosine + q_partner * sine,
+    )
+    k_rotated = tl.where(
+        columns < rope_half,
+        key * cosine - k_partner * sine,
+        key * cosine + k_partner * sine,
+    )
+    tl.store(q_base + columns, tl.where(rotary_mask, q_rotated, query), mask=mask)
+    tl.store(k_base + columns, tl.where(rotary_mask, k_rotated, key), mask=mask)
+
+
+def qknorm_rope_neox_bf16_(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    q_weight: torch.Tensor,
+    k_weight: torch.Tensor,
+    cos_sin_cache: torch.Tensor,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Normalize and rotate head-contiguous BF16 Q/K tensors in place."""
+    rows, heads, head_dim = query.shape
+    rope_dim = cos_sin_cache.shape[-1]
+    block_n = triton.next_power_of_2(head_dim)
+    _qknorm_rope_neox_bf16_kernel[(rows * heads,)](
+        query,
+        key,
+        q_weight,
+        k_weight,
+        cos_sin_cache,
+        heads,
+        head_dim,
+        rope_dim,
+        eps,
+        query.stride(0),
+        query.stride(1),
+        key.stride(0),
+        key.stride(1),
+        cos_sin_cache.stride(0),
+        BLOCK_N=block_n,
+        num_warps=1,
+    )
+    return query, key
diff --git a/telefuser/kernel/triton/silu_mul.py b/telefuser/kernel/triton/silu_mul.py
new file mode 100644
index 00000000..4dcf9188
--- /dev/null
+++ b/telefuser/kernel/triton/silu_mul.py
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+"""In-place BF16 SiLU-gated multiplication."""
+
+from __future__ import annotations
+
+import torch
+import triton
+import triton.language as tl
+
+
+@triton.jit
+def _silu_and_mul_bf16_input_inplace_kernel(
+    input_ptr,
+    total_vectors,
+    hidden_vectors,
+    input_width_vectors,
+    VECTOR_SIZE: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    vector_ids = tl.program_id(0) * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+    channels = tl.arange(0, VECTOR_SIZE)
+    mask = vector_ids < total_vectors
+    row = vector_ids // hidden_vectors
+    column_vector = vector_ids - row * hidden_vectors
+    gate_offsets = (row * input_width_vectors + column_vector) * VECTOR_SIZE + channels[:, None]
+    gate = tl.load(input_ptr + gate_offsets, mask=mask[None, :]).to(tl.float32)
+    up = tl.load(input_ptr + gate_offsets + hidden_vectors * VECTOR_SIZE, mask=mask[None, :]).to(tl.float32)
+    activated = gate / (1.0 + tl.exp(-gate))
+    activated = activated.to(tl.bfloat16).to(tl.float32)
+    tl.store(input_ptr + gate_offsets, activated * up, mask=mask[None, :])
+
+
+def silu_and_mul_bf16_input_inplace_(input_tensor: torch.Tensor) -> torch.Tensor:
+    """Write rounded ``silu(gate) * up`` into the gate half and return that view."""
+    hidden_size = input_tensor.shape[-1] // 2
+    output_elements = input_tensor.numel() // 2
+    if output_elements:
+        vector_size = 8
+        hidden_vectors = hidden_size // vector_size
+        total_vectors = output_elements // vector_size
+        block_size = 256
+        _silu_and_mul_bf16_input_inplace_kernel[(triton.cdiv(total_vectors, block_size),)](
+            input_tensor,
+            total_vectors,
+            hidden_vectors,
+            input_tensor.shape[-1] // vector_size,
+            VECTOR_SIZE=vector_size,
+            BLOCK_SIZE=block_size,
+            num_warps=8,
+        )
+    return input_tensor[..., :hidden_size]
diff --git a/telefuser/kernel/triton/ulysses_relayout.py b/telefuser/kernel/triton/ulysses_relayout.py
new file mode 100644
index 00000000..ce266d93
--- /dev/null
+++ b/telefuser/kernel/triton/ulysses_relayout.py
@@ -0,0 +1,164 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Destination-major Ulysses input and output relayout kernels."""
+
+from __future__ import annotations
+
+import torch
+import triton
+import triton.language as tl
+
+
+@triton.jit
+def _pack_qkv_destination_major_kernel(
+    output_ptr,
+    query_ptr,
+    key_ptr,
+    value_ptr,
+    total_elements,
+    rows,
+    local_heads,
+    head_dim,
+    stride_query_row,
+    stride_query_head,
+    stride_key_row,
+    stride_key_head,
+    stride_value_row,
+    stride_value_head,
+    BLOCK_SIZE: tl.constexpr,
+):
+    offsets = tl.program_id(0) * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+    mask = offsets < total_elements
+    channel = offsets % head_dim
+    head_slot = offsets // head_dim
+    local_head = head_slot % local_heads
+    row_slot = head_slot // local_heads
+    row = row_slot % rows
+    destination = row_slot // rows
+    global_head = destination * local_heads + local_head
+
+    query = tl.load(
+        query_ptr + row * stride_query_row + global_head * stride_query_head + channel,
+        mask=mask,
+    )
+    key = tl.load(
+        key_ptr + row * stride_key_row + global_head * stride_key_head + channel,
+        mask=mask,
+    )
+    value = tl.load(
+        value_ptr + row * stride_value_row + global_head * stride_value_head + channel,
+        mask=mask,
+    )
+    output_base = head_slot * (3 * head_dim) + channel
+    tl.store(output_ptr + output_base, query, mask=mask)
+    tl.store(output_ptr + output_base + head_dim, key, mask=mask)
+    tl.store(output_ptr + output_base + 2 * head_dim, value, mask=mask)
+
+
+@triton.jit
+def _merge_ulysses_heads_kernel(
+    output_ptr,
+    input_ptr,
+    total_vectors,
+    batch,
+    sequence,
+    world_size: tl.constexpr,
+    local_heads: tl.constexpr,
+    head_dim: tl.constexpr,
+    VECTOR_SIZE: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    vector_ids = tl.program_id(0) * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+    channels = tl.arange(0, VECTOR_SIZE)
+    mask = vector_ids < total_vectors
+    channel_vector = vector_ids % (head_dim // VECTOR_SIZE)
+    rest = vector_ids // (head_dim // VECTOR_SIZE)
+    local_head = rest % local_heads
+    rest //= local_heads
+    destination = rest % world_size
+    rest //= world_size
+    row = rest % sequence
+    batch_index = rest // sequence
+    source = (
+        (((destination * sequence + row) * batch + batch_index) * local_heads + local_head) * head_dim
+    ) + channel_vector * VECTOR_SIZE
+    values = tl.load(input_ptr + source[:, None] + channels[None, :], mask=mask[:, None])
+    tl.store(
+        output_ptr + vector_ids[:, None] * VECTOR_SIZE + channels[None, :],
+        values,
+        mask=mask[:, None],
+    )
+
+
+def pack_qkv_destination_major(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    world_size: int,
+) -> torch.Tensor:
+    """Pack 3D Q/K/V directly as ``[destination, row, local_head, 3 * dim]``."""
+    rows, global_heads, head_dim = query.shape
+    local_heads = global_heads // world_size
+    output = torch.empty(
+        world_size,
+        rows,
+        local_heads,
+        3 * head_dim,
+        dtype=query.dtype,
+        device=query.device,
+    )
+    total_elements = rows * global_heads * head_dim
+    if total_elements == 0:
+        return output
+    block_size = 1024
+    _pack_qkv_destination_major_kernel[(triton.cdiv(total_elements, block_size),)](
+        output,
+        query,
+        key,
+        value,
+        total_elements,
+        rows,
+        local_heads,
+        head_dim,
+        query.stride(0),
+        query.stride(1),
+        key.stride(0),
+        key.stride(1),
+        value.stride(0),
+        value.stride(1),
+        BLOCK_SIZE=block_size,
+        num_warps=8,
+    )
+    return output
+
+
+def merge_ulysses_heads(tensor: torch.Tensor) -> torch.Tensor:
+    """Relayout ``[world, sequence, batch, local_head, dim]`` to destination-last order."""
+    world_size, sequence, batch, local_heads, head_dim = tensor.shape
+    output = torch.empty(
+        batch,
+        sequence,
+        world_size,
+        local_heads,
+        head_dim,
+        dtype=tensor.dtype,
+        device=tensor.device,
+    )
+    if tensor.numel() == 0:
+        return output
+    vector_size = 8 if head_dim % 8 == 0 else 1
+    total_vectors = tensor.numel() // vector_size
+    block_size = 256
+    _merge_ulysses_heads_kernel[(triton.cdiv(total_vectors, block_size),)](
+        output,
+        tensor,
+        total_vectors,
+        batch,
+        sequence,
+        world_size=world_size,
+        local_heads=local_heads,
+        head_dim=head_dim,
+        VECTOR_SIZE=vector_size,
+        BLOCK_SIZE=block_size,
+        num_warps=8,
+    )
+    return output
diff --git a/telefuser/models/minimax_h3_audio/__init__.py b/telefuser/models/minimax_h3_audio/__init__.py
new file mode 100644
index 00000000..9c1905a4
--- /dev/null
+++ b/telefuser/models/minimax_h3_audio/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 audio VAE implementation."""
+
+from .audio_vae import DacAudioVAE
+
+__all__ = ["DacAudioVAE"]
diff --git a/telefuser/models/minimax_h3_audio/alias_free.py b/telefuser/models/minimax_h3_audio/alias_free.py
new file mode 100644
index 00000000..e7b82c12
--- /dev/null
+++ b/telefuser/models/minimax_h3_audio/alias_free.py
@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: Apache-2.0
+# Adapted from https://github.com/junjun3518/alias-free-torch under the Apache License 2.0
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "sinc" in dir(torch):
+    sinc = torch.sinc
+else:
+    # This code is adopted from adefossez's julius.core.sinc under the MIT License
+    # https://adefossez.github.io/julius/julius/core.html
+    def sinc(x: torch.Tensor):
+        """
+        Implementation of sinc, i.e. sin(pi * x) / (pi * x)
+        __Warning__: Different to julius.sinc, the input is multiplied by `pi`!
+        """
+        return torch.where(
+            x == 0,
+            torch.tensor(1.0, device=x.device, dtype=x.dtype),
+            torch.sin(math.pi * x) / math.pi / x,
+        )
+
+
+# This code is adopted from adefossez's julius.lowpass.LowPassFilters under the MIT License
+# https://adefossez.github.io/julius/julius/lowpass.html
+def kaiser_sinc_filter1d(cutoff, half_width, kernel_size):  # return filter [1,1,kernel_size]
+    even = kernel_size % 2 == 0
+    half_size = kernel_size // 2
+
+    # For kaiser window
+    delta_f = 4 * half_width
+    A = 2.285 * (half_size - 1) * math.pi * delta_f + 7.95
+    if A > 50.0:
+        beta = 0.1102 * (A - 8.7)
+    elif A >= 21.0:
+        beta = 0.5842 * (A - 21) ** 0.4 + 0.07886 * (A - 21.0)
+    else:
+        beta = 0.0
+    window = torch.kaiser_window(kernel_size, beta=beta, periodic=False)
+
+    # ratio = 0.5/cutoff -> 2 * cutoff = 1 / ratio
+    if even:
+        time = torch.arange(-half_size, half_size) + 0.5
+    else:
+        time = torch.arange(kernel_size) - half_size
+    if cutoff == 0:
+        filter_ = torch.zeros_like(time)
+    else:
+        filter_ = 2 * cutoff * window * sinc(2 * cutoff * time)
+        """
+        Normalize the filter to avoid leaking the constant component.
+        """
+        filter_ /= filter_.sum()
+        filter = filter_.view(1, 1, kernel_size)
+
+    return filter
+
+
+class LowPassFilter1d(nn.Module):
+    def __init__(
+        self,
+        cutoff=0.5,
+        half_width=0.6,
+        stride: int = 1,
+        padding: bool = True,
+        padding_mode: str = "replicate",
+        kernel_size: int = 12,
+    ):
+        """
+        kernel_size should be even number for stylegan3 setup, in this implementation, odd number is also possible.
+        """
+        super().__init__()
+        if cutoff < -0.0:
+            raise ValueError("Minimum cutoff must be larger than zero.")
+        if cutoff > 0.5:
+            raise ValueError("A cutoff above 0.5 does not make sense.")
+        self.kernel_size = kernel_size
+        self.even = kernel_size % 2 == 0
+        self.pad_left = kernel_size // 2 - int(self.even)
+        self.pad_right = kernel_size // 2
+        self.stride = stride
+        self.padding = padding
+        self.padding_mode = padding_mode
+        filter = kaiser_sinc_filter1d(cutoff, half_width, kernel_size)
+        self.register_buffer("filter", filter)
+
+    # Input [B, C, T]
+    def forward(self, x):
+        _, C, _ = x.shape
+
+        if self.padding:
+            x = F.pad(x, (self.pad_left, self.pad_right), mode=self.padding_mode)
+        out = F.conv1d(x, self.filter.expand(C, -1, -1), stride=self.stride, groups=C)
+
+        return out
+
+
+class UpSample1d(nn.Module):
+    def __init__(self, ratio=2, kernel_size=None):
+        super().__init__()
+        self.ratio = ratio
+        self.kernel_size = int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
+        self.stride = ratio
+        self.pad = self.kernel_size // ratio - 1
+        self.pad_left = self.pad * self.stride + (self.kernel_size - self.stride) // 2
+        self.pad_right = self.pad * self.stride + (self.kernel_size - self.stride + 1) // 2
+        filter = kaiser_sinc_filter1d(
+            cutoff=0.5 / ratio,
+            half_width=0.6 / ratio,
+            kernel_size=self.kernel_size,
+        )
+        self.register_buffer("filter", filter)
+
+    def forward(self, x):
+        _, C, _ = x.shape
+
+        x = F.pad(x, (self.pad, self.pad), mode="replicate")
+        x = F.conv_transpose1d(x, self.filter.expand(C, -1, -1), stride=self.stride, groups=C)
+        x.mul_(self.ratio)
+        x = x[..., self.pad_left : -self.pad_right]
+
+        return x
+
+
+class DownSample1d(nn.Module):
+    def __init__(self, ratio=2, kernel_size=None):
+        super().__init__()
+        self.ratio = ratio
+        self.kernel_size = int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
+        self.lowpass = LowPassFilter1d(
+            cutoff=0.5 / ratio,
+            half_width=0.6 / ratio,
+            stride=ratio,
+            kernel_size=self.kernel_size,
+        )
+
+    def forward(self, x):
+        xx = self.lowpass(x)
+
+        return xx
+
+
+class Activation1d(nn.Module):
+    def __init__(
+        self,
+        activation,
+        up_ratio: int = 2,
+        down_ratio: int = 2,
+        up_kernel_size: int = 12,
+        down_kernel_size: int = 12,
+    ):
+        super().__init__()
+        self.up_ratio = up_ratio
+        self.down_ratio = down_ratio
+        self.act = activation
+        self.upsample = UpSample1d(up_ratio, up_kernel_size)
+        self.downsample = DownSample1d(down_ratio, down_kernel_size)
+
+    def forward(self, x):
+        x = self.upsample(x)
+        x = self.act(x)
+        x = self.downsample(x)
+
+        return x
diff --git a/telefuser/models/minimax_h3_audio/audio_vae.py b/telefuser/models/minimax_h3_audio/audio_vae.py
new file mode 100644
index 00000000..4a682134
--- /dev/null
+++ b/telefuser/models/minimax_h3_audio/audio_vae.py
@@ -0,0 +1,308 @@
+# SPDX-License-Identifier: Apache-2.0
+# DAC-lineage audio VAE: waveform encoder + BigVGAN decoder (inference-only bundle).
+import math
+from typing import List
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+from torch.nn.utils.parametrizations import weight_norm
+
+from telefuser.ops.attention import attention
+
+from .bigvgan import AttrDict, BigVGAN
+
+
+class GeGluMlp(nn.Module):
+    def __init__(self, in_features, hidden_features):
+        super().__init__()
+        self.norm = nn.LayerNorm(in_features)
+        self.act = nn.GELU(approximate="tanh")
+        self.w0 = nn.Linear(in_features, hidden_features)
+        self.w1 = nn.Linear(in_features, hidden_features)
+        self.w2 = nn.Linear(hidden_features, in_features)
+
+    def forward(self, x):
+        x = self.norm(x)
+        x = self.act(self.w0(x)).mul_(self.w1(x))
+        x = self.w2(x)
+        return x
+
+
+class CausalAttention(nn.Module):
+    def __init__(self, in_dim, out_dim, num_heads):
+        super().__init__()
+        if in_dim > out_dim:
+            # assert in_dim // num_heads == out_dim
+            self.head_dim = in_dim // num_heads
+            self.qkv = nn.Linear(in_dim, in_dim * 3, bias=False)
+            self.q_bias = nn.Parameter(torch.zeros(in_dim))
+            self.v_bias = nn.Parameter(torch.zeros(in_dim))
+            self.register_buffer("zero_k_bias", torch.zeros(in_dim))
+        else:
+            # assert out_dim // num_heads == in_dim
+            self.head_dim = out_dim // num_heads
+            self.qkv = nn.Linear(in_dim, out_dim * 3, bias=False)
+            self.q_bias = nn.Parameter(torch.zeros(out_dim))
+            self.v_bias = nn.Parameter(torch.zeros(out_dim))
+            self.register_buffer("zero_k_bias", torch.zeros(out_dim))
+
+        self.in_dim = in_dim
+        self.out_dim = out_dim
+        self.num_heads = num_heads
+        self.scale = self.head_dim**-0.5
+        self.proj = nn.Linear(out_dim, out_dim)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        B, N, C = x.shape
+        qkv = F.linear(
+            input=x,
+            weight=self.qkv.weight,
+            bias=torch.cat((self.q_bias, self.zero_k_bias, self.v_bias)),
+        )
+        q, k, v = qkv.reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4).unbind(0)
+
+        x = attention(
+            q,
+            k,
+            v,
+            input_layout="BNSD",
+            output_layout="BNSD",
+            is_causal=True,
+            scale=self.scale,
+        )
+
+        if self.in_dim > self.out_dim:
+            x = torch.mean(x, dim=1)
+            if self.in_dim // self.num_heads != self.out_dim:
+                x = nn.functional.adaptive_avg_pool1d(x, self.out_dim)
+        else:
+            x = x.transpose(1, 2).reshape(B, N, -1)
+        x = self.proj(x)
+        return x
+
+
+class AttnProjection(nn.Module):
+    def __init__(self, in_dim, out_dim, num_heads, norm_layer=nn.LayerNorm, mlp_ratio=2):
+        super().__init__()
+        assert out_dim % in_dim == 0 or in_dim % out_dim == 0
+        self.in_dim = in_dim
+        self.out_dim = out_dim
+        self.norm1 = norm_layer(in_dim)
+        self.attn = CausalAttention(in_dim, out_dim, num_heads)
+        self.proj = nn.Linear(in_dim, out_dim)
+        self.norm3 = norm_layer(in_dim)
+
+        self.norm2 = norm_layer(out_dim)
+        hidden_dim = int(out_dim * mlp_ratio)
+        self.mlp = GeGluMlp(in_features=out_dim, hidden_features=hidden_dim)
+        # self.mlp = FeedForward(out_dim, out_dim)
+
+    def forward(self, x):
+        x = self.proj(self.norm3(x)).add_(self.attn(self.norm1(x)))
+        return self.mlp(self.norm2(x)).add_(x)
+
+
+def WNConv1d(*args, **kwargs):
+    return weight_norm(nn.Conv1d(*args, **kwargs))
+
+
+@torch.jit.script
+def snake(x, alpha):
+    shape = x.shape
+    x = x.reshape(shape[0], shape[1], -1)
+    x = x + (alpha + 1e-9).reciprocal() * torch.sin(alpha * x).pow(2)
+    x = x.reshape(shape)
+    return x
+
+
+class Snake1d(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.alpha = nn.Parameter(torch.ones(1, channels, 1))
+
+    def forward(self, x):
+        return snake(x, self.alpha)
+
+
+class ResidualUnit(nn.Module):
+    def __init__(self, dim: int = 16, dilation: int = 1):
+        super().__init__()
+        pad = ((7 - 1) * dilation) // 2
+        self.block = nn.Sequential(
+            Snake1d(dim),
+            WNConv1d(dim, dim, kernel_size=7, dilation=dilation, padding=pad),
+            Snake1d(dim),
+            WNConv1d(dim, dim, kernel_size=1),
+        )
+
+    def forward(self, x):
+        y = self.block(x)
+        pad = (x.shape[-1] - y.shape[-1]) // 2
+        if pad > 0:
+            x = x[..., pad:-pad]
+        return x + y
+
+
+class EncoderBlock(nn.Module):
+    def __init__(self, dim: int = 16, stride: int = 1):
+        super().__init__()
+        self.block = nn.Sequential(
+            ResidualUnit(dim // 2, dilation=1),
+            ResidualUnit(dim // 2, dilation=3),
+            ResidualUnit(dim // 2, dilation=9),
+            Snake1d(dim // 2),
+            WNConv1d(
+                dim // 2,
+                dim,
+                kernel_size=2 * stride,
+                stride=stride,
+                padding=math.ceil(stride / 2),
+            ),
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class Encoder(nn.Module):
+    def __init__(
+        self,
+        d_model: int = 64,
+        strides: list = [2, 4, 8, 8],
+        d_latent: int = 64,
+    ):
+        super().__init__()
+        # Create first convolution
+        self.block = [WNConv1d(1, d_model, kernel_size=7, padding=3)]
+
+        # Create EncoderBlocks that double channels as they downsample by `stride`
+        for stride in strides:
+            d_model *= 2
+            self.block += [EncoderBlock(d_model, stride=stride)]
+
+        # Create last convolution
+        self.block += [
+            Snake1d(d_model),
+            WNConv1d(d_model, d_latent, kernel_size=3, padding=1),
+        ]
+
+        # Wrap black into nn.Sequential
+        self.block = nn.Sequential(*self.block)
+        self.enc_dim = d_model
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class DacAudioVAE(nn.Module):
+    def __init__(
+        self,
+        encoder_dim: int = 64,
+        encoder_rates: List[int] = [2, 4, 8, 8],
+        latent_dim: int = None,
+        decoder_dim: int = 1536,
+        decoder_rates: List[int] = [8, 8, 4, 2],
+        sample_rate: int = 44100,
+        vae_latent_channels: int = 64,
+        attn_proj: bool = False,
+        decoder_type: str = "bigvgan",
+    ):
+        super().__init__()
+
+        self.encoder_dim = encoder_dim
+        self.encoder_rates = encoder_rates
+        self.decoder_dim = decoder_dim
+        self.decoder_rates = decoder_rates
+        self.sample_rate = sample_rate
+        self.attn_proj = attn_proj
+        self.decoder_type = decoder_type
+
+        if latent_dim is None:
+            latent_dim = encoder_dim * (2 ** len(encoder_rates))
+
+        self.latent_dim = latent_dim
+
+        self.hop_length = np.prod(encoder_rates)
+        self.encoder = Encoder(encoder_dim, encoder_rates, latent_dim)
+
+        if latent_dim % vae_latent_channels == 0:
+            self.attn_proj_dim = vae_latent_channels
+        else:
+            # smallest power of two >= vae_latent_channels
+            self.attn_proj_dim = 2 ** int(np.ceil(np.log2(vae_latent_channels)))
+
+        self.mean_proj = nn.Conv1d(self.attn_proj_dim, vae_latent_channels, 1)
+        self.logs_proj = nn.Conv1d(self.attn_proj_dim, vae_latent_channels, 1)
+
+        self.dec_in_proj = nn.Conv1d(vae_latent_channels, latent_dim, 1)
+
+        if self.decoder_type == "bigvgan":
+            if sample_rate == 16000:
+                bigvgan_conf = {
+                    "resblock": "1",
+                    "num_mels": latent_dim,
+                    "upsample_rates": [5, 5, 2, 2, 2, 2],
+                    "upsample_kernel_sizes": [9, 9, 4, 4, 4, 4],
+                    "upsample_initial_channel": decoder_dim,
+                    "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,
+                }
+            elif sample_rate == 32000:
+                bigvgan_conf = {
+                    "resblock": "1",
+                    "num_mels": latent_dim,
+                    "upsample_rates": [5, 5, 2, 2, 2, 2, 2],
+                    "upsample_kernel_sizes": [9, 9, 4, 4, 4, 4, 4],
+                    "upsample_initial_channel": decoder_dim,
+                    "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,
+                }
+            else:
+                raise ValueError(f"Invalid sample_rate: {sample_rate}")
+
+            h = AttrDict(**bigvgan_conf)
+            self.decoder = BigVGAN(h)
+        else:
+            raise ValueError(f"Invalid decoder type: {self.decoder_type}")
+
+        if self.attn_proj:
+            self.pre_block = AttnProjection(latent_dim, self.attn_proj_dim, num_heads=8)
+
+        self.sample_rate = sample_rate
+
+    def preprocess(self, audio_data, sample_rate):
+        if sample_rate is None:
+            sample_rate = self.sample_rate
+
+        length = audio_data.shape[-1]
+        right_pad = math.ceil(length / self.hop_length) * self.hop_length - length
+        if right_pad:
+            audio_data = nn.functional.pad(audio_data, (0, right_pad))
+
+        return audio_data
+
+    def decode(self, z: torch.Tensor):
+        """Decode given latent codes and return audio data
+
+        Parameters
+        ----------
+        z : Tensor[B x D x T]
+            Continuous latent representation
+
+        Returns
+        -------
+        Tensor[B x 1 x length]
+            Decoded audio data.
+        """
+        z = self.dec_in_proj(z)
+        return self.decoder(z)
diff --git a/telefuser/models/minimax_h3_audio/bigvgan.py b/telefuser/models/minimax_h3_audio/bigvgan.py
new file mode 100644
index 00000000..fb55863e
--- /dev/null
+++ b/telefuser/models/minimax_h3_audio/bigvgan.py
@@ -0,0 +1,239 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2024 NVIDIA CORPORATION.
+#   Licensed under the MIT license.
+
+# Adapted from https://github.com/jik876/hifi-gan under the MIT license.
+
+import torch
+import torch.nn as nn
+from torch.nn import Conv1d, ConvTranspose1d, Parameter
+from torch.nn.utils.parametrizations import weight_norm
+
+from .alias_free import Activation1d
+
+
+def get_padding(kernel_size, dilation=1):
+    return int((kernel_size * dilation - dilation) / 2)
+
+
+# Adapted from https://github.com/EdwardDixon/snake under the MIT license.
+@torch.jit.script
+def snakebeta(x, alpha, beta):
+    shape = x.shape
+    x = x.reshape(shape[0], shape[1], -1)
+    x = x + (beta + 1e-9).reciprocal() * torch.sin(alpha * x).pow(2)
+    x = x.reshape(shape)
+    return x
+
+
+class SnakeBeta(nn.Module):
+    def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
+        super(SnakeBeta, self).__init__()
+        self.in_features = in_features
+
+        self.alpha_logscale = alpha_logscale
+        if self.alpha_logscale:
+            self.alpha = Parameter(torch.zeros(in_features) * alpha)
+            self.beta = Parameter(torch.zeros(in_features) * alpha)
+        else:
+            self.alpha = Parameter(torch.ones(in_features) * alpha)
+            self.beta = Parameter(torch.ones(in_features) * alpha)
+
+        self.alpha.requires_grad = alpha_trainable
+        self.beta.requires_grad = alpha_trainable
+        self.no_div_by_zero = 0.000000001
+
+    def forward(self, x):
+        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)
+        beta = self.beta.unsqueeze(0).unsqueeze(-1)
+        if self.alpha_logscale:
+            alpha = torch.exp(alpha)
+            beta = torch.exp(beta)
+        x = snakebeta(x, alpha, beta)
+        return x
+
+
+class AttrDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
+
+
+class AMPBlock1(torch.nn.Module):
+    """
+    AMPBlock applies trainable SnakeBeta periodic activations.
+    AMPBlock1 follows every dilated convolution with a fixed-dilation Conv1d.
+
+    Args:
+        h (AttrDict): Hyperparameters.
+        channels (int): Number of convolution channels.
+        kernel_size (int): Size of the convolution kernel. Default is 3.
+        dilation (tuple): Dilation rates. Each layer has two convolutions.
+        activation (str): Activation function type. Must be 'snakebeta'.
+    """
+
+    def __init__(
+        self,
+        h: AttrDict,
+        channels: int,
+        kernel_size: int = 3,
+        dilation: tuple = (1, 3, 5),
+        activation: str = None,
+    ):
+        super().__init__()
+
+        self.h = h
+
+        self.convs1 = nn.ModuleList(
+            [
+                weight_norm(
+                    Conv1d(
+                        channels,
+                        channels,
+                        kernel_size,
+                        stride=1,
+                        dilation=d,
+                        padding=get_padding(kernel_size, d),
+                    )
+                )
+                for d in dilation
+            ]
+        )
+
+        self.convs2 = nn.ModuleList(
+            [
+                weight_norm(
+                    Conv1d(
+                        channels,
+                        channels,
+                        kernel_size,
+                        stride=1,
+                        dilation=1,
+                        padding=get_padding(kernel_size, 1),
+                    )
+                )
+                for _ in range(len(dilation))
+            ]
+        )
+
+        self.num_layers = len(self.convs1) + len(self.convs2)  # Total number of conv layers
+
+        if activation == "snakebeta":
+            self.activations = nn.ModuleList(
+                [
+                    Activation1d(activation=SnakeBeta(channels, alpha_logscale=h.snake_logscale))
+                    for _ in range(self.num_layers)
+                ]
+            )
+        else:
+            raise NotImplementedError(
+                "activation incorrectly specified. check the config file and look for 'activation'."
+            )
+
+    def forward(self, x):
+        activation_iter = iter(self.activations)
+        for c1, c2 in zip(self.convs1, self.convs2):
+            a1 = next(activation_iter)
+            a2 = next(activation_iter)
+            xt = a1(x)
+            xt = c1(xt)
+            xt = a2(xt)
+            xt = c2(xt)
+            x = xt.add_(x)
+
+        return x
+
+
+class BigVGAN(torch.nn.Module):
+    """
+    BigVGAN is a neural vocoder model that applies anti-aliased periodic activation for residual blocks (resblocks).
+
+    Args:
+        h (AttrDict): Hyperparameters.
+    """
+
+    def __init__(self, h: AttrDict):
+        super().__init__()
+        self.h = h
+
+        self.num_kernels = len(h.resblock_kernel_sizes)
+        self.num_upsamples = len(h.upsample_rates)
+
+        # Pre-conv
+        self.conv_pre = weight_norm(Conv1d(h.num_mels, h.upsample_initial_channel, 7, 1, padding=3))
+
+        # Define which AMPBlock to use. BigVGAN uses AMPBlock1 as default
+        if h.resblock == "1":
+            resblock_class = AMPBlock1
+        else:
+            raise ValueError(f"Incorrect resblock class specified in hyperparameters. Got {h.resblock}")
+
+        # Transposed conv-based upsamplers. does not apply anti-aliasing
+        self.ups = nn.ModuleList()
+        for i, (u, k) in enumerate(zip(h.upsample_rates, h.upsample_kernel_sizes)):
+            self.ups.append(
+                nn.ModuleList(
+                    [
+                        weight_norm(
+                            ConvTranspose1d(
+                                h.upsample_initial_channel // (2**i),
+                                h.upsample_initial_channel // (2 ** (i + 1)),
+                                k,
+                                u,
+                                padding=(k - u) // 2,
+                            )
+                        )
+                    ]
+                )
+            )
+
+        # Residual blocks using anti-aliased multi-periodicity composition modules (AMP)
+        self.resblocks = nn.ModuleList()
+        for i in range(len(self.ups)):
+            ch = h.upsample_initial_channel // (2 ** (i + 1))
+            for j, (k, d) in enumerate(zip(h.resblock_kernel_sizes, h.resblock_dilation_sizes)):
+                self.resblocks.append(resblock_class(h, ch, k, d, activation=h.activation))
+
+        # Post-conv
+        if h.activation != "snakebeta":
+            raise NotImplementedError(
+                "activation incorrectly specified. check the config file and look for 'activation'."
+            )
+        activation_post = SnakeBeta(ch, alpha_logscale=h.snake_logscale)
+
+        self.activation_post = Activation1d(activation=activation_post)
+
+        # Whether to use bias for the final conv_post. Default to True for backward compatibility
+        self.use_bias_at_final = h.get("use_bias_at_final", True)
+        self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, padding=3, bias=self.use_bias_at_final))
+
+        # Final tanh activation. Defaults to True for backward compatibility
+        self.use_tanh_at_final = h.get("use_tanh_at_final", True)
+
+    def forward(self, x):
+        # Pre-conv
+        x = self.conv_pre(x)
+
+        for i in range(self.num_upsamples):
+            # Upsampling
+            for i_up in range(len(self.ups[i])):
+                x = self.ups[i][i_up](x)
+            # AMP blocks
+            xs = None
+            for j in range(self.num_kernels):
+                if xs is None:
+                    xs = self.resblocks[i * self.num_kernels + j](x)
+                else:
+                    xs += self.resblocks[i * self.num_kernels + j](x)
+            x = xs.div_(self.num_kernels)
+
+        # Post-conv
+        x = self.activation_post(x)
+        x = self.conv_post(x)
+        # Final tanh activation
+        if self.use_tanh_at_final:
+            x.tanh_()
+        else:
+            x.clamp_(min=-1.0, max=1.0)  # Bound the output to [-1, 1]
+
+        return x
diff --git a/telefuser/models/minimax_h3_audio_vae.py b/telefuser/models/minimax_h3_audio_vae.py
new file mode 100644
index 00000000..b5692c48
--- /dev/null
+++ b/telefuser/models/minimax_h3_audio_vae.py
@@ -0,0 +1,147 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 32 kHz stereo audio VAE."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+
+from telefuser.core.base_model import BaseModel
+
+from .minimax_h3_audio import DacAudioVAE
+
+
+@dataclass(frozen=True)
+class MiniMaxH3AudioVAEConfig:
+    encoder_dim: int
+    encoder_rates: tuple[int, ...]
+    latent_dim: int
+    decoder_dim: int
+    decoder_rates: tuple[int, ...]
+    sample_rate: int
+    latent_channels: int
+    output_channels: int
+    attn_proj: bool
+    decoder_type: str
+    latents_mean: tuple[float, ...]
+    latents_std: tuple[float, ...]
+
+    @classmethod
+    def from_path(cls, path: str | Path) -> MiniMaxH3AudioVAEConfig:
+        component_dir = Path(path)
+        if component_dir.is_file():
+            component_dir = component_dir.parent
+        component = json.loads((component_dir / "config.json").read_text(encoding="utf-8"))
+        metadata_path = component_dir / component["source_metadata_path"]
+        metadata = json.loads(metadata_path.read_text(encoding="utf-8"))["metadata"]["kwargs"]
+        config = cls(
+            encoder_dim=int(metadata["encoder_dim"]),
+            encoder_rates=tuple(int(rate) for rate in metadata["encoder_rates"]),
+            latent_dim=int(metadata["latent_dim"]),
+            decoder_dim=int(metadata["decoder_dim"]),
+            decoder_rates=tuple(int(rate) for rate in metadata["decoder_rates"]),
+            sample_rate=int(metadata["sample_rate"]),
+            latent_channels=int(metadata["vae_latent_channels"]),
+            output_channels=int(component["output_channel"]),
+            attn_proj=bool(metadata["attn_proj"]),
+            decoder_type=str(metadata["decoder_type"]),
+            latents_mean=tuple(float(value) for value in component["latents_mean"]),
+            latents_std=tuple(float(value) for value in component["latents_std"]),
+        )
+        config.validate()
+        return config
+
+    def validate(self) -> None:
+        if self.sample_rate != 32_000:
+            raise ValueError(f"MiniMax H3 audio VAE requires 32000 Hz, got {self.sample_rate}")
+        if self.latent_channels != 32:
+            raise ValueError(f"MiniMax H3 audio VAE requires 32 latent channels, got {self.latent_channels}")
+        if self.output_channels != 2:
+            raise ValueError(f"MiniMax H3 output requires stereo audio, got {self.output_channels} channels")
+        if len(self.latents_mean) != self.latent_channels or len(self.latents_std) != self.latent_channels:
+            raise ValueError("audio VAE latent statistics must contain one value per latent channel")
+        if any(value <= 0 for value in self.latents_std):
+            raise ValueError("audio VAE latent standard deviations must be positive")
+
+
+class MiniMaxH3AudioVAE(DacAudioVAE, BaseModel):
+    """DAC-lineage waveform encoder and BigVGAN decoder used by MiniMax H3."""
+
+    def __init__(self, config: MiniMaxH3AudioVAEConfig) -> None:
+        config.validate()
+        super().__init__(
+            encoder_dim=config.encoder_dim,
+            encoder_rates=list(config.encoder_rates),
+            latent_dim=config.latent_dim,
+            decoder_dim=config.decoder_dim,
+            decoder_rates=list(config.decoder_rates),
+            sample_rate=config.sample_rate,
+            vae_latent_channels=config.latent_channels,
+            attn_proj=config.attn_proj,
+            decoder_type=config.decoder_type,
+        )
+        self.config = config
+        self.layer_name_list = ["encoder", "decoder"]
+
+    @torch.no_grad()
+    def encode_mean(self, waveform: torch.Tensor, sample_rate: int | None = None) -> torch.Tensor:
+        """Encode independent waveform channels to deterministic normalized latents."""
+        if waveform.ndim != 3 or waveform.shape[1] != 1:
+            raise ValueError("waveform must be [channels, 1, samples]")
+        waveform = self.preprocess(waveform, sample_rate)
+        parameter = next(self.parameters())
+        waveform = waveform.to(device=parameter.device, dtype=parameter.dtype)
+        hidden = self.encoder(waveform)
+        if self.attn_proj:
+            hidden = self.pre_block(hidden.transpose(1, 2)).transpose(1, 2)
+        latent = self.mean_proj(hidden)
+        mean = latent.new_tensor(self.config.latents_mean).view(1, -1, 1)
+        std = latent.new_tensor(self.config.latents_std).view(1, -1, 1)
+        return latent.sub(mean).div(std)
+
+    @torch.no_grad()
+    def decode_normalized(self, latent: torch.Tensor) -> torch.Tensor:
+        """Decode normalized [2, 32, T] latents to [1, 2, samples] stereo."""
+        if latent.ndim != 3 or latent.shape[0] != self.config.output_channels:
+            raise ValueError("audio latent must be [2, 32, T]")
+        if latent.shape[1] != self.config.latent_channels:
+            raise ValueError(f"audio latent channel dimension must be {self.config.latent_channels}")
+        parameter = next(self.parameters())
+        latent = latent.to(device=parameter.device, dtype=parameter.dtype)
+        mean = latent.new_tensor(self.config.latents_mean).view(1, -1, 1)
+        std = latent.new_tensor(self.config.latents_std).view(1, -1, 1)
+        waveform = self.decode(latent.mul(std).add(mean))
+        return waveform.transpose(0, 1).contiguous()
+
+    @staticmethod
+    def state_dict_converter(config_path: str | Path) -> MiniMaxH3AudioVAEStateDictConverter:
+        return MiniMaxH3AudioVAEStateDictConverter(config_path)
+
+
+class MiniMaxH3AudioVAEStateDictConverter:
+    def __init__(self, config_path: str | Path) -> None:
+        self.config = MiniMaxH3AudioVAEConfig.from_path(config_path)
+
+    def from_official(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        converted: dict[str, torch.Tensor] = {}
+        for name, value in state_dict.items():
+            if name.endswith(".weight_g"):
+                name = name.removesuffix(".weight_g") + ".parametrizations.weight.original0"
+            elif name.endswith(".weight_v"):
+                name = name.removesuffix(".weight_v") + ".parametrizations.weight.original1"
+            converted[name] = value
+        return converted, {"config": self.config}
+
+    def from_diffusers(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        return self.from_official(state_dict)
+
+
+__all__ = [
+    "MiniMaxH3AudioVAE",
+    "MiniMaxH3AudioVAEConfig",
+    "MiniMaxH3AudioVAEStateDictConverter",
+]
diff --git a/telefuser/models/minimax_h3_dit.py b/telefuser/models/minimax_h3_dit.py
new file mode 100644
index 00000000..213e7200
--- /dev/null
+++ b/telefuser/models/minimax_h3_dit.py
@@ -0,0 +1,931 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 packed multimodal DiT."""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+
+from telefuser.core.base_model import BaseModel
+from telefuser.core.config import AttentionConfig
+from telefuser.distributed.collectives import all_gather_cat, all_reduce_sum_
+from telefuser.distributed.device_mesh import (
+    get_tp_group,
+    get_tp_rank,
+    get_tp_world_size,
+    get_ulysses_group,
+    get_ulysses_world_size,
+)
+from telefuser.distributed.parallel_shard import sequence_parallel_shard, sequence_parallel_unshard
+from telefuser.distributed.ulysses_comm import ulysses_gather_heads_destination_major, ulysses_scatter_qkv
+from telefuser.ops import RMSNorm, apply_qk_norm_rope_neox, indexed_gate, indexed_scale_shift, silu_and_mul_reuse_input
+from telefuser.ops.attention import attention
+from telefuser.ops.rotary import apply_rotary_emb_neox
+
+MINIMAX_H3_ADALN_MODALITY_NUM = 3
+MINIMAX_H3_FP32_PARAM_NAMES = frozenset(
+    {
+        "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",
+    }
+)
+MINIMAX_H3_FP32_BUFFER_NAMES = frozenset({"rope.inv_freq"})
+
+
+@dataclass(frozen=True)
+class MiniMaxH3DiTConfig:
+    hidden_size: int = 5376
+    num_layers: int = 50
+    token_refiner_num_layers: int = 2
+    num_attention_heads: int = 56
+    attention_head_dim: int = 128
+    ffn_hidden_size: int = 14336
+    latents_dim: int = 24
+    audio_latents_dim: int = 32
+    patch_size: tuple[int, int, int] = (1, 2, 2)
+    text_dim: int = 5120
+    timestep_input_dim: int = 256
+    time_embed_hidden_size: int = 5376
+    time_embed_dim: int = 2688
+    rope_inv_freq_len: int = 16
+    norm_eps: float = 1e-5
+    qk_norm_eps: float = 1e-5
+    final_norm_eps: float = 1e-5
+
+    @classmethod
+    def from_json(cls, path: str | Path) -> MiniMaxH3DiTConfig:
+        payload = json.loads(Path(path).read_text(encoding="utf-8"))
+        fields = cls.__dataclass_fields__
+        values = {key: payload[key] for key in fields if key in payload}
+        if "patch_size" in values:
+            values["patch_size"] = tuple(int(value) for value in values["patch_size"])
+        return cls(**values)
+
+    def __post_init__(self) -> None:
+        if self.hidden_size <= 0 or self.num_layers <= 0:
+            raise ValueError("MiniMax H3 hidden_size and num_layers must be positive")
+        if self.num_attention_heads <= 0 or self.attention_head_dim <= 0:
+            raise ValueError("MiniMax H3 attention dimensions must be positive")
+        if len(self.patch_size) != 3 or any(value <= 0 for value in self.patch_size):
+            raise ValueError("MiniMax H3 patch_size must contain three positive integers")
+        if 6 * self.rope_inv_freq_len > self.attention_head_dim:
+            raise ValueError("MiniMax H3 rotary dimensions must fit inside attention_head_dim")
+
+    @property
+    def inner_dim(self) -> int:
+        return self.num_attention_heads * self.attention_head_dim
+
+    @property
+    def video_patch_dim(self) -> int:
+        return self.latents_dim * math.prod(self.patch_size)
+
+    @property
+    def adaln_out_features(self) -> int:
+        return 18 * self.hidden_size
+
+    @property
+    def final_adaln_out_features(self) -> int:
+        return 2 * self.hidden_size
+
+
+def _rms_norm(size: int, eps: float) -> RMSNorm:
+    return RMSNorm(size, eps=eps, dtype=torch.bfloat16)
+
+
+def _reorder_grouped_qkv_to_qkv(
+    weight: torch.Tensor,
+    *,
+    num_query_groups: int,
+    heads_per_group: int,
+    head_dim: int,
+) -> torch.Tensor:
+    per_group = (heads_per_group + 2) * head_dim
+    if weight.shape[0] != num_query_groups * per_group:
+        raise ValueError("MiniMax H3 grouped QKV weight has an incompatible output dimension")
+    rest = weight.shape[1:]
+    grouped = weight.reshape(num_query_groups, per_group, *rest)
+    q, k, v = torch.split(grouped, [heads_per_group * head_dim, head_dim, head_dim], dim=1)
+    return torch.cat(
+        (
+            q.reshape(num_query_groups * heads_per_group * head_dim, *rest),
+            k.reshape(num_query_groups * head_dim, *rest),
+            v.reshape(num_query_groups * head_dim, *rest),
+        ),
+        dim=0,
+    )
+
+
+def _replace_parameter(module: nn.Module, name: str, value: torch.Tensor) -> None:
+    parameter = module.get_parameter(name)
+    setattr(module, name, nn.Parameter(value.contiguous(), requires_grad=parameter.requires_grad))
+
+
+def _shard_linear_output(
+    linear: nn.Linear,
+    *,
+    rank: int,
+    world_size: int,
+    sections: tuple[int, ...] | None = None,
+) -> None:
+    sections = sections or (linear.out_features,)
+    if sum(sections) != linear.out_features or any(size % world_size for size in sections):
+        raise ValueError(
+            f"linear output sections {sections} must sum to {linear.out_features} and divide TP degree {world_size}"
+        )
+    weight_sections = linear.weight.split(sections, dim=0)
+    local_weight = torch.cat(tuple(section.chunk(world_size, dim=0)[rank] for section in weight_sections), dim=0)
+    _replace_parameter(linear, "weight", local_weight)
+    if linear.bias is not None:
+        bias_sections = linear.bias.split(sections, dim=0)
+        local_bias = torch.cat(tuple(section.chunk(world_size, dim=0)[rank] for section in bias_sections), dim=0)
+        _replace_parameter(linear, "bias", local_bias)
+    linear.out_features //= world_size
+
+
+def _shard_linear_input(linear: nn.Linear, *, rank: int, world_size: int) -> None:
+    if linear.in_features % world_size:
+        raise ValueError(f"linear input size {linear.in_features} must divide TP degree {world_size}")
+    _replace_parameter(linear, "weight", linear.weight.chunk(world_size, dim=1)[rank])
+    linear.in_features //= world_size
+
+
+class MiniMaxH3Rope(nn.Module):
+    def __init__(self, inv_freq_len: int) -> None:
+        super().__init__()
+        inv_freq = 10000.0 ** (-torch.arange(inv_freq_len, dtype=torch.float32) / inv_freq_len)
+        self.register_buffer("inv_freq", inv_freq, persistent=True)
+
+    def forward(self, position_ids: torch.Tensor) -> torch.Tensor:
+        if position_ids.ndim != 3 or position_ids.shape[0] != 1 or position_ids.shape[-1] != 3:
+            raise ValueError("MiniMax H3 position_ids must have shape [1, sequence, 3]")
+        per_axis = position_ids[0].float().unsqueeze(-1) * self.inv_freq.view(1, 1, -1)
+        half = torch.cat(tuple(per_axis.unbind(dim=1)), dim=-1)
+        return torch.cat((half, half), dim=-1)
+
+
+class MiniMaxH3TimeEmbedder(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.frequency_embedding_size = config.timestep_input_dim
+        self.proj_in = nn.Linear(
+            config.timestep_input_dim,
+            config.time_embed_hidden_size,
+            dtype=torch.float32,
+        )
+        self.proj_out = nn.Linear(
+            config.time_embed_hidden_size,
+            config.time_embed_dim,
+            dtype=torch.float32,
+        )
+        self._frequency_cache: dict[torch.device, torch.Tensor] = {}
+
+    def forward(self, timestep: torch.Tensor) -> torch.Tensor:
+        half = self.frequency_embedding_size // 2
+        frequencies = self._frequency_cache.get(timestep.device)
+        if frequencies is None:
+            frequencies = torch.exp(
+                -math.log(10000.0) * torch.arange(half, dtype=torch.float32, device=timestep.device) / half
+            )
+            self._frequency_cache[timestep.device] = frequencies
+        args = timestep.float().reshape(-1, 1) * frequencies.reshape(1, -1)
+        embedding = torch.cat((torch.cos(args), torch.sin(args)), dim=-1)
+        return self.proj_out(nn.functional.silu(self.proj_in(embedding)))
+
+
+class MiniMaxH3Attention(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.num_heads = config.num_attention_heads
+        self.head_dim = config.attention_head_dim
+        self.inner_dim = config.inner_dim
+        self.qkv_proj = nn.Linear(config.hidden_size, 3 * self.inner_dim, bias=False, dtype=torch.bfloat16)
+        self.q_norm = _rms_norm(self.head_dim, config.qk_norm_eps)
+        self.k_norm = _rms_norm(self.head_dim, config.qk_norm_eps)
+        self.out_proj = nn.Linear(self.inner_dim, config.hidden_size, bias=False, dtype=torch.bfloat16)
+        self.ulysses_group: dist.ProcessGroup | None = None
+        self.tp_group: dist.ProcessGroup | None = None
+        self._communication_events: list[tuple[torch.cuda.Event, torch.cuda.Event]] = []
+
+    def set_ulysses_group(self, group: dist.ProcessGroup | None) -> None:
+        self.ulysses_group = group
+
+    def enable_tp(self, group: dist.ProcessGroup, *, rank: int, world_size: int) -> None:
+        if self.num_heads % world_size:
+            raise ValueError(f"attention heads ({self.num_heads}) must divide TP degree ({world_size})")
+        original_inner_dim = self.inner_dim
+        _shard_linear_output(
+            self.qkv_proj,
+            rank=rank,
+            world_size=world_size,
+            sections=(original_inner_dim, original_inner_dim, original_inner_dim),
+        )
+        _shard_linear_input(self.out_proj, rank=rank, world_size=world_size)
+        self.num_heads //= world_size
+        self.inner_dim //= world_size
+        self.tp_group = group
+
+    def reset_communication_metrics(self) -> None:
+        self._communication_events.clear()
+
+    def communication_seconds(self) -> float:
+        return sum(start.elapsed_time(end) for start, end in self._communication_events) / 1000.0
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        *,
+        sequence_lengths: list[int],
+        rope_cos_sin_cache: torch.Tensor | None,
+        attention_config: AttentionConfig | None,
+        cu_seqlens: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        sequence, _ = hidden.shape
+        qkv = self.qkv_proj(hidden).reshape(sequence, 3, self.num_heads, self.head_dim)
+        query, key, value = qkv.unbind(dim=1)
+        if rope_cos_sin_cache is not None:
+            query, key = apply_qk_norm_rope_neox(
+                query,
+                key,
+                self.q_norm.weight,
+                self.k_norm.weight,
+                rope_cos_sin_cache,
+                eps=self.q_norm.eps,
+            )
+        else:
+            query = self.q_norm(query)
+            key = self.k_norm(key)
+        query = query.unsqueeze(0)
+        key = key.unsqueeze(0)
+        value = value.unsqueeze(0)
+        group = self.ulysses_group
+        use_ulysses = group is not None and dist.get_world_size(group) > 1
+        if use_ulysses:
+            scatter_start = torch.cuda.Event(enable_timing=True)
+            scatter_end = torch.cuda.Event(enable_timing=True)
+            scatter_start.record()
+            query, key, value = ulysses_scatter_qkv(query, key, value, group)()
+            scatter_end.record()
+            self._communication_events.append((scatter_start, scatter_end))
+        output = attention(
+            query,
+            key,
+            value,
+            attention_config=attention_config,
+            scale=self.head_dim**-0.5,
+            sequence_lengths=sequence_lengths,
+            cu_seqlens=cu_seqlens,
+        )
+        if use_ulysses:
+            gather_start = torch.cuda.Event(enable_timing=True)
+            gather_end = torch.cuda.Event(enable_timing=True)
+            gather_start.record()
+            output = ulysses_gather_heads_destination_major(output, group, num_heads=self.num_heads)()
+            gather_end.record()
+            self._communication_events.append((gather_start, gather_end))
+        output = self.out_proj(output[0].reshape(sequence, self.inner_dim))
+        if self.tp_group is not None:
+            all_reduce_sum_((output,), group=self.tp_group)
+        return output
+
+
+class MiniMaxH3MLP(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.fc1 = nn.Linear(config.hidden_size, 2 * config.ffn_hidden_size, bias=False, dtype=torch.bfloat16)
+        self.fc2 = nn.Linear(config.ffn_hidden_size, config.hidden_size, bias=False, dtype=torch.bfloat16)
+        self.intermediate_size = config.ffn_hidden_size
+        self.tp_group: dist.ProcessGroup | None = None
+
+    def enable_tp(self, group: dist.ProcessGroup, *, rank: int, world_size: int) -> None:
+        _shard_linear_output(
+            self.fc1,
+            rank=rank,
+            world_size=world_size,
+            sections=(self.intermediate_size, self.intermediate_size),
+        )
+        _shard_linear_input(self.fc2, rank=rank, world_size=world_size)
+        self.intermediate_size //= world_size
+        self.tp_group = group
+
+    def forward(self, hidden: torch.Tensor) -> torch.Tensor:
+        output = self.fc2(silu_and_mul_reuse_input(self.fc1(hidden)))
+        if self.tp_group is not None:
+            all_reduce_sum_((output,), group=self.tp_group)
+        return output
+
+
+class MiniMaxH3AdaLNProjection(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig, *, expand_ratio: int, modality_count: int) -> None:
+        super().__init__()
+        self.expand_ratio = expand_ratio
+        self.modality_count = modality_count
+        self.hidden_size = config.hidden_size
+        self.linear = nn.Linear(
+            config.time_embed_dim,
+            expand_ratio * modality_count * config.hidden_size,
+            dtype=torch.bfloat16,
+        )
+        self.tp_group: dist.ProcessGroup | None = None
+        self.tp_world_size = 1
+
+    def enable_tp(self, group: dist.ProcessGroup, *, rank: int, world_size: int) -> None:
+        _shard_linear_output(self.linear, rank=rank, world_size=world_size)
+        self.tp_group = group
+        self.tp_world_size = world_size
+
+    def project_local(self, embedding: torch.Tensor) -> torch.Tensor:
+        return self.linear(embedding)
+
+    def split_output(self, output: torch.Tensor) -> tuple[torch.Tensor, ...]:
+        output = output.reshape(-1, self.expand_ratio * self.hidden_size)
+        return tuple(output.chunk(self.expand_ratio, dim=-1))
+
+    def forward(self, embedding: torch.Tensor) -> tuple[torch.Tensor, ...]:
+        output = self.project_local(embedding)
+        if self.tp_group is not None:
+            output = all_gather_cat(
+                output,
+                dim=-1,
+                group=self.tp_group,
+                world_size=self.tp_world_size,
+            )
+        return self.split_output(output)
+
+
+def _modulate(
+    hidden: torch.Tensor,
+    shift: torch.Tensor,
+    scale: torch.Tensor,
+    indices: torch.Tensor,
+) -> torch.Tensor:
+    return indexed_scale_shift(hidden, shift, scale, indices)
+
+
+class MiniMaxH3TokenRefinerBlock(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.norm1 = _rms_norm(config.hidden_size, config.norm_eps)
+        self.norm2 = _rms_norm(config.hidden_size, config.norm_eps)
+        self.attn = MiniMaxH3Attention(config)
+        self.mlp = MiniMaxH3MLP(config)
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        *,
+        sequence_lengths: list[int],
+        attention_config: AttentionConfig | None,
+    ) -> torch.Tensor:
+        hidden = hidden + self.attn(
+            self.norm1(hidden),
+            sequence_lengths=sequence_lengths,
+            rope_cos_sin_cache=None,
+            attention_config=attention_config,
+        )
+        return hidden + self.mlp(self.norm2(hidden))
+
+
+class MiniMaxH3TokenRefiner(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.blocks = nn.ModuleList(
+            [MiniMaxH3TokenRefinerBlock(config) for _ in range(config.token_refiner_num_layers)]
+        )
+        self.final_norm = _rms_norm(config.hidden_size, config.final_norm_eps)
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        *,
+        attention_config: AttentionConfig | None,
+    ) -> torch.Tensor:
+        for block in self.blocks:
+            hidden = block(
+                hidden,
+                sequence_lengths=[hidden.shape[0]],
+                attention_config=attention_config,
+            )
+        return self.final_norm(hidden)
+
+
+class MiniMaxH3DiTBlock(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.norm1 = _rms_norm(config.hidden_size, config.norm_eps)
+        self.norm2 = _rms_norm(config.hidden_size, config.norm_eps)
+        self.attn = MiniMaxH3Attention(config)
+        self.mlp = MiniMaxH3MLP(config)
+        self.adaln_proj = MiniMaxH3AdaLNProjection(
+            config,
+            expand_ratio=6,
+            modality_count=MINIMAX_H3_ADALN_MODALITY_NUM,
+        )
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        *,
+        adaln_input: torch.Tensor,
+        combined_indices: torch.Tensor,
+        sequence_lengths: list[int],
+        rope_cos_sin_cache: torch.Tensor,
+        attention_config: AttentionConfig | None,
+        cu_seqlens: torch.Tensor | None = None,
+        adaln_params: tuple[torch.Tensor, ...] | None = None,
+    ) -> torch.Tensor:
+        if adaln_params is None:
+            adaln_params = self.adaln_proj(adaln_input)
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = adaln_params
+        residual = hidden
+        value = _modulate(self.norm1(hidden), shift_msa, scale_msa, combined_indices)
+        value = self.attn(
+            value,
+            sequence_lengths=sequence_lengths,
+            rope_cos_sin_cache=rope_cos_sin_cache,
+            attention_config=attention_config,
+            cu_seqlens=cu_seqlens,
+        )
+        hidden = indexed_gate(residual, gate_msa, value, combined_indices)
+        residual = hidden
+        value = _modulate(self.norm2(hidden), shift_mlp, scale_mlp, combined_indices)
+        value = self.mlp(value)
+        return indexed_gate(residual, gate_mlp, value, combined_indices)
+
+
+class MiniMaxH3FinalLayer(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.norm = _rms_norm(config.hidden_size, config.final_norm_eps)
+        self.adaln_proj = MiniMaxH3AdaLNProjection(config, expand_ratio=2, modality_count=1)
+        self.video_out = nn.Linear(config.hidden_size, config.video_patch_dim, dtype=torch.float32)
+        self.audio_out = nn.Linear(config.hidden_size, config.audio_latents_dim, dtype=torch.float32)
+
+    def forward(
+        self,
+        hidden: torch.Tensor,
+        *,
+        adaln_input: torch.Tensor,
+        inverse_indices: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        shift, scale = self.adaln_proj(adaln_input)
+        hidden = _modulate(self.norm(hidden), shift, scale, inverse_indices).float()
+        return self.video_out(hidden), self.audio_out(hidden)
+
+
+class MiniMaxH3DiT(BaseModel):
+    """Faithful packed DiT baseline for H3-Base with optional Ulysses SP."""
+
+    def __init__(self, config: MiniMaxH3DiTConfig | None = None) -> None:
+        super().__init__()
+        self.config = config or MiniMaxH3DiTConfig()
+        config = self.config
+        self.video_patch_proj = nn.Linear(config.video_patch_dim, config.hidden_size, dtype=torch.float32)
+        self.audio_patch_proj = nn.Linear(config.audio_latents_dim, config.hidden_size, dtype=torch.float32)
+        self.condition_proj = nn.Linear(config.text_dim, config.hidden_size, dtype=torch.bfloat16)
+        self.time_embedder = MiniMaxH3TimeEmbedder(config)
+        self.rope = MiniMaxH3Rope(config.rope_inv_freq_len)
+        self.token_refiner = MiniMaxH3TokenRefiner(config)
+        self.blocks = nn.ModuleList([MiniMaxH3DiTBlock(config) for _ in range(config.num_layers)])
+        self.final_layer = MiniMaxH3FinalLayer(config)
+        self.layer_name_list = ["blocks"]
+        self.device_mesh: Any | None = None
+        self.usp_flag = False
+        self.tp_flag = False
+        self._static_cache_key: Any | None = None
+        self._static_prompt: torch.Tensor | None = None
+        self._static_rope_cos_sin: torch.Tensor | None = None
+        self._static_sequence_lengths: list[int] | None = None
+        self._static_cu_seqlens: torch.Tensor | None = None
+
+    def _preserve_fp32_boundaries(self) -> None:
+        for name in MINIMAX_H3_FP32_PARAM_NAMES:
+            parameter = self.get_parameter(name)
+            if parameter.dtype != torch.float32:
+                parameter.data = parameter.data.float()
+        if self.rope.inv_freq.dtype != torch.float32:
+            self.rope.inv_freq.data = self.rope.inv_freq.data.float()
+
+    def to(self, *args: Any, **kwargs: Any) -> MiniMaxH3DiT:
+        preserved_parameters = {
+            name: parameter.detach().clone()
+            for name in MINIMAX_H3_FP32_PARAM_NAMES
+            if not (parameter := self.get_parameter(name)).is_meta
+        }
+        preserved_buffers = {
+            name: buffer.detach().clone()
+            for name in MINIMAX_H3_FP32_BUFFER_NAMES
+            if not (buffer := self.get_buffer(name)).is_meta
+        }
+        result = super().to(*args, **kwargs)
+        for name, value in preserved_parameters.items():
+            parameter = result.get_parameter(name)
+            parameter.data = value.to(device=parameter.device, dtype=torch.float32)
+        for name, value in preserved_buffers.items():
+            buffer = result.get_buffer(name)
+            buffer.data = value.to(device=buffer.device, dtype=torch.float32)
+        result._preserve_fp32_boundaries()
+        return result
+
+    @staticmethod
+    def _position_ids(value: Any, name: str) -> torch.Tensor:
+        position_ids = value.get("position_ids") if isinstance(value, dict) else getattr(value, "position_ids", None)
+        if position_ids is None:
+            raise ValueError(f"{name}.position_ids is required")
+        return position_ids.reshape(-1).long()
+
+    @staticmethod
+    def _cu_seqlens(packed: Any) -> torch.Tensor:
+        cu = packed.get("cu_seqlens_q") if isinstance(packed, dict) else packed.cu_seqlens_q
+        if cu is None:
+            raise ValueError("packed_seq_params.cu_seqlens_q is required")
+        return cu.reshape(-1)
+
+    @classmethod
+    def _sequence_lengths(cls, packed: Any) -> list[int]:
+        values = [int(value) for value in cls._cu_seqlens(packed).tolist()]
+        return [stop - start for start, stop in zip(values[:-1], values[1:], strict=True) if stop > start]
+
+    def _static_inputs(
+        self,
+        kwargs: dict[str, Any],
+        *,
+        device: torch.device,
+        text_positions: torch.Tensor,
+        rope_row_start: int = 0,
+        rope_row_stop: int | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor, list[int], torch.Tensor]:
+        cache_key = kwargs.get("static_cache_key")
+        if (
+            cache_key is not None
+            and cache_key == self._static_cache_key
+            and self._static_prompt is not None
+            and self._static_rope_cos_sin is not None
+            and self._static_sequence_lengths is not None
+            and self._static_cu_seqlens is not None
+        ):
+            return (
+                self._static_prompt,
+                self._static_rope_cos_sin,
+                self._static_sequence_lengths,
+                self._static_cu_seqlens,
+            )
+
+        prompt = kwargs["prompt_embeds"].to(device=device, dtype=torch.bfloat16)
+        prompt = self.condition_proj(prompt[: text_positions.numel()])
+        prompt = self.token_refiner(prompt, attention_config=self.attention_config)
+        rope_position_ids = kwargs["img_position_ids"].to(device)
+        rope_position_ids = rope_position_ids[:, rope_row_start:rope_row_stop]
+        rope_frequencies = self.rope(rope_position_ids)
+        rope_half = rope_frequencies.shape[-1] // 2
+        rope_cos_sin_cache = torch.cat(
+            (rope_frequencies[..., :rope_half].cos(), rope_frequencies[..., :rope_half].sin()),
+            dim=-1,
+        ).to(torch.bfloat16)
+        sequence_lengths = self._sequence_lengths(kwargs["packed_seq_params"])
+        cu_seqlens = self._cu_seqlens(kwargs["packed_seq_params"]).to(device=device, dtype=torch.int32)
+        if cache_key is not None:
+            self._static_cache_key = cache_key
+            self._static_prompt = prompt
+            self._static_rope_cos_sin = rope_cos_sin_cache
+            self._static_sequence_lengths = sequence_lengths
+            self._static_cu_seqlens = cu_seqlens
+        return prompt, rope_cos_sin_cache, sequence_lengths, cu_seqlens
+
+    def forward(self, **kwargs: Any) -> tuple[torch.Tensor, torch.Tensor]:
+        required = (
+            "x",
+            "audio_x",
+            "img_position_ids",
+            "unique_timesteps",
+            "inverse_indices",
+            "update_mask",
+            "prompt_embeds",
+            "img_pos_info",
+            "audio_pos_info",
+            "text_pos_info",
+            "img_pos_for_infer_output_info",
+            "packed_seq_params",
+        )
+        missing = [name for name in required if kwargs.get(name) is None]
+        if missing:
+            raise ValueError(f"MiniMaxH3DiT.forward missing required inputs: {missing}")
+        video_state = kwargs["x"]
+        audio_state = kwargs["audio_x"]
+        if video_state.ndim != 3 or video_state.shape[0] != 1:
+            raise ValueError("x must have shape [1, sequence, video_patch_dim]")
+        sequence = video_state.shape[1]
+        device = video_state.device
+        image_positions = self._position_ids(kwargs["img_pos_info"], "img_pos_info").to(device)
+        audio_positions = self._position_ids(kwargs["audio_pos_info"], "audio_pos_info").to(device)
+        text_positions = self._position_ids(kwargs["text_pos_info"], "text_pos_info").to(device)
+        output_positions = self._position_ids(
+            kwargs["img_pos_for_infer_output_info"], "img_pos_for_infer_output_info"
+        ).to(device)
+
+        local_embedding_layout = kwargs.get("local_embedding_layout")
+        use_local_embedding = self.usp_flag and local_embedding_layout is not None
+        if use_local_embedding:
+            row_start = int(local_embedding_layout["row_start"])
+            row_stop = int(local_embedding_layout["row_stop"])
+            if row_start < 0 or row_stop <= row_start or row_stop > sequence:
+                raise ValueError("local_embedding_layout has an invalid packed row range")
+        else:
+            row_start = 0
+            row_stop = sequence
+
+        prompt, rope_cos_sin_cache, sequence_lengths, cu_seqlens = self._static_inputs(
+            kwargs,
+            device=device,
+            text_positions=text_positions,
+            rope_row_start=row_start,
+            rope_row_stop=row_stop,
+        )
+        if use_local_embedding:
+            hidden = torch.zeros(row_stop - row_start, self.config.hidden_size, device=device, dtype=torch.bfloat16)
+
+            def layout_tensor(name: str) -> torch.Tensor:
+                value = local_embedding_layout[name]
+                if not isinstance(value, torch.Tensor):
+                    raise ValueError(f"local_embedding_layout.{name} must be a tensor")
+                return value.to(device=device, dtype=torch.long)
+
+            text_source_ids = layout_tensor("text_source_ids")
+            text_row_ids = layout_tensor("text_row_ids")
+            if text_row_ids.numel():
+                hidden.index_copy_(0, text_row_ids, prompt.index_select(0, text_source_ids))
+            img_global_ids = layout_tensor("img_global_ids")
+            img_row_ids = layout_tensor("img_row_ids")
+            if img_row_ids.numel():
+                video_rows = video_state[0].index_select(0, img_global_ids).float()
+                hidden.index_copy_(0, img_row_ids, self.video_patch_proj(video_rows).to(torch.bfloat16))
+            audio_global_ids = layout_tensor("audio_global_ids")
+            audio_row_ids = layout_tensor("audio_row_ids")
+            if audio_row_ids.numel():
+                audio_rows = audio_state[0].index_select(0, audio_global_ids).float()
+                hidden.index_copy_(0, audio_row_ids, self.audio_patch_proj(audio_rows).to(torch.bfloat16))
+        else:
+            hidden = torch.zeros(sequence, self.config.hidden_size, device=device, dtype=torch.bfloat16)
+            hidden.index_copy_(0, text_positions, prompt)
+            video_rows = video_state[0].index_select(0, image_positions).float()
+            audio_rows = audio_state[0].index_select(0, audio_positions).float()
+            hidden.index_copy_(0, image_positions, self.video_patch_proj(video_rows).to(torch.bfloat16))
+            hidden.index_copy_(0, audio_positions, self.audio_patch_proj(audio_rows).to(torch.bfloat16))
+
+        timesteps = kwargs["unique_timesteps"].reshape(-1).to(device)
+        adaln_input = nn.functional.silu(self.time_embedder(timesteps)).to(torch.bfloat16)
+        inverse_indices = kwargs["inverse_indices"].reshape(-1).long().to(device)
+        if inverse_indices.numel() != sequence:
+            raise ValueError("inverse_indices must cover the full packed sequence")
+        local_inverse_indices = inverse_indices[row_start:row_stop]
+        combined_indices = kwargs.get("block_combined_indices")
+        if combined_indices is not None:
+            combined_indices = combined_indices.reshape(-1).long().to(device)
+            if combined_indices.numel() != row_stop - row_start:
+                raise ValueError("block_combined_indices must cover the local packed sequence")
+        else:
+            token_tags = kwargs.get("block_token_tags")
+            if token_tags is None:
+                token_tags = kwargs.get("token_tags")
+            if token_tags is None:
+                raise ValueError("token_tags or block_token_tags is required")
+            token_tags = token_tags.reshape(-1).long().to(device).clamp_min(0)
+            if token_tags.numel() == sequence:
+                token_tags = token_tags[row_start:row_stop]
+            if token_tags.numel() != row_stop - row_start:
+                raise ValueError("block token tags must cover the local packed sequence")
+            combined_indices = token_tags + local_inverse_indices * MINIMAX_H3_ADALN_MODALITY_NUM
+        full_sequence = sequence
+        if self.usp_flag:
+            world_size = get_ulysses_world_size(self.device_mesh)
+            if sequence % world_size:
+                raise ValueError(
+                    f"MiniMax H3 packed sequence length ({sequence}) must be divisible by Ulysses degree ({world_size})"
+                )
+            if use_local_embedding:
+                inverse_indices = local_inverse_indices
+            else:
+                inverse_indices = inverse_indices.clone()
+                rope_cos_sin_cache = rope_cos_sin_cache.clone()
+                sequence_parallel_shard(
+                    self.device_mesh,
+                    [hidden, combined_indices, inverse_indices, rope_cos_sin_cache],
+                    [0, 0, 0, 0],
+                )
+        else:
+            inverse_indices = local_inverse_indices
+        block_adaln_params = None
+        if self.tp_flag:
+            local_adaln = torch.stack([block.adaln_proj.project_local(adaln_input) for block in self.blocks])
+            first_projection = self.blocks[0].adaln_proj
+            gathered_adaln = all_gather_cat(
+                local_adaln,
+                dim=-1,
+                group=first_projection.tp_group,
+                world_size=first_projection.tp_world_size,
+            )
+            block_adaln_params = tuple(
+                block.adaln_proj.split_output(output) for block, output in zip(self.blocks, gathered_adaln)
+            )
+        for index, block in enumerate(self.blocks):
+            hidden = block(
+                hidden,
+                adaln_input=adaln_input,
+                combined_indices=combined_indices,
+                sequence_lengths=sequence_lengths,
+                rope_cos_sin_cache=rope_cos_sin_cache,
+                attention_config=self.attention_config,
+                cu_seqlens=cu_seqlens,
+                adaln_params=None if block_adaln_params is None else block_adaln_params[index],
+            )
+        video_logits, audio_logits = self.final_layer(
+            hidden,
+            adaln_input=adaln_input,
+            inverse_indices=inverse_indices,
+        )
+        if self.usp_flag:
+            video_logits, audio_logits = sequence_parallel_unshard(
+                self.device_mesh,
+                [video_logits, audio_logits],
+                [0, 0],
+                [full_sequence, full_sequence],
+            )
+        video_logits = video_logits.index_select(0, output_positions)
+        audio_logits = audio_logits.index_select(0, audio_positions)
+        if not bool(kwargs.get("skip_mask_out_condition", False)):
+            video_logits = video_logits * kwargs["update_mask"].reshape(-1, 1).to(video_logits)
+            if kwargs.get("update_audio_mask") is not None:
+                audio_logits = audio_logits * kwargs["update_audio_mask"].reshape(-1, 1).to(audio_logits)
+        return video_logits, audio_logits
+
+    def enable_usp(self, device_mesh: Any | None = None) -> None:
+        self.device_mesh = device_mesh if device_mesh is not None else self.device_mesh
+        world_size = get_ulysses_world_size(self.device_mesh)
+        local_num_heads = self.blocks[0].attn.num_heads
+        if local_num_heads % world_size:
+            raise ValueError(
+                f"MiniMax H3 local attention heads ({local_num_heads}) must be divisible by "
+                f"Ulysses degree ({world_size})"
+            )
+        group = get_ulysses_group(self.device_mesh) if world_size > 1 else None
+        self.usp_flag = world_size > 1
+        for block in self.blocks:
+            block.attn.set_ulysses_group(group)
+
+    def enable_tp(self, device_mesh: Any | None = None) -> None:
+        self.device_mesh = device_mesh if device_mesh is not None else self.device_mesh
+        world_size = get_tp_world_size(self.device_mesh)
+        if world_size <= 1:
+            return
+        if self.tp_flag:
+            raise RuntimeError("MiniMax H3 tensor parallelism is already enabled")
+        group = get_tp_group(self.device_mesh)
+        if group is None:
+            raise RuntimeError("MiniMax H3 TP requires a tensor-parallel process group")
+        rank = get_tp_rank(self.device_mesh)
+        if self.config.num_attention_heads % world_size:
+            raise ValueError(
+                f"MiniMax H3 attention heads ({self.config.num_attention_heads}) must divide TP degree ({world_size})"
+            )
+        if self.config.ffn_hidden_size % world_size:
+            raise ValueError(
+                f"MiniMax H3 FFN size ({self.config.ffn_hidden_size}) must divide TP degree ({world_size})"
+            )
+        for block in self.token_refiner.blocks:
+            block.attn.enable_tp(group, rank=rank, world_size=world_size)
+            block.mlp.enable_tp(group, rank=rank, world_size=world_size)
+        for block in self.blocks:
+            block.attn.enable_tp(group, rank=rank, world_size=world_size)
+            block.mlp.enable_tp(group, rank=rank, world_size=world_size)
+            block.adaln_proj.enable_tp(group, rank=rank, world_size=world_size)
+        self.final_layer.adaln_proj.enable_tp(group, rank=rank, world_size=world_size)
+        self.tp_flag = True
+
+    def reset_communication_metrics(self) -> None:
+        for block in self.blocks:
+            block.attn.reset_communication_metrics()
+
+    def communication_seconds(self) -> float:
+        return sum(block.attn.communication_seconds() for block in self.blocks)
+
+    def get_fsdp_module_names(self) -> list[str]:
+        return ["blocks"]
+
+    @staticmethod
+    def state_dict_converter(config_path: str | Path | None = None) -> MiniMaxH3DiTStateDictConverter:
+        return MiniMaxH3DiTStateDictConverter(config_path=config_path)
+
+
+_BLOCK_INDEX = re.compile(r"^blocks\.(\d+)\.")
+_REFINER_INDEX = re.compile(r"^token_refiner\.blocks\.(\d+)\.")
+
+
+class MiniMaxH3DiTStateDictConverter:
+    def __init__(self, config_path: str | Path | None = None) -> None:
+        self.config_path = None if config_path is None else Path(config_path)
+
+    def _config(self, state_dict: dict[str, torch.Tensor]) -> MiniMaxH3DiTConfig:
+        if self.config_path is not None:
+            return MiniMaxH3DiTConfig.from_json(self.config_path)
+        q_norm = state_dict["blocks.0.attn.q_norm.weight"]
+        qkv = state_dict["blocks.0.attn.qkv_proj.weight"]
+        layers = 1 + max(int(match.group(1)) for key in state_dict if (match := _BLOCK_INDEX.match(key)))
+        refiners = 1 + max(int(match.group(1)) for key in state_dict if (match := _REFINER_INDEX.match(key)))
+        video_patch_dim = state_dict["video_patch_proj.weight"].shape[1]
+        return MiniMaxH3DiTConfig(
+            hidden_size=state_dict["video_patch_proj.weight"].shape[0],
+            num_layers=layers,
+            token_refiner_num_layers=refiners,
+            num_attention_heads=qkv.shape[0] // (3 * q_norm.numel()),
+            attention_head_dim=q_norm.numel(),
+            ffn_hidden_size=state_dict["blocks.0.mlp.fc1.weight"].shape[0] // 2,
+            latents_dim=video_patch_dim // 4,
+            audio_latents_dim=state_dict["audio_patch_proj.weight"].shape[1],
+            text_dim=state_dict["condition_proj.weight"].shape[1],
+            timestep_input_dim=state_dict["time_embedder.proj_in.weight"].shape[1],
+            time_embed_hidden_size=state_dict["time_embedder.proj_in.weight"].shape[0],
+            time_embed_dim=state_dict["time_embedder.proj_out.weight"].shape[0],
+            rope_inv_freq_len=state_dict["rope.inv_freq"].numel(),
+        )
+
+    def from_official(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        config = self._config(state_dict)
+        converted = dict(state_dict)
+        for key, value in state_dict.items():
+            if key.endswith(".attn.qkv_proj.weight"):
+                converted[key] = _reorder_grouped_qkv_to_qkv(
+                    value,
+                    num_query_groups=config.num_attention_heads,
+                    heads_per_group=1,
+                    head_dim=config.attention_head_dim,
+                )
+        return converted, {"config": config}
+
+    def from_diffusers(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        renamed: dict[str, torch.Tensor] = {}
+        qkv_parts: dict[str, dict[str, torch.Tensor]] = {}
+        direct = {
+            "proj_in.": "video_patch_proj.",
+            "audio_proj_in.": "audio_patch_proj.",
+            "context_embedder.": "condition_proj.",
+            "time_embedder.linear_1.": "time_embedder.proj_in.",
+            "time_embedder.linear_2.": "time_embedder.proj_out.",
+            "norm_out.norm.": "final_layer.norm.",
+            "norm_out.linear.": "final_layer.adaln_proj.linear.",
+            "proj_out.": "final_layer.video_out.",
+            "audio_proj_out.": "final_layer.audio_out.",
+        }
+        for key, value in state_dict.items():
+            target = key
+            for source, destination in direct.items():
+                if target.startswith(source):
+                    target = destination + target[len(source) :]
+                    break
+            target = target.replace("transformer_blocks.", "blocks.")
+            target = target.replace("token_refiner.refiner_blocks.", "token_refiner.blocks.")
+            target = target.replace(".attn.norm_q.", ".attn.q_norm.")
+            target = target.replace(".attn.norm_k.", ".attn.k_norm.")
+            target = target.replace(".attn.to_out.0.", ".attn.out_proj.")
+            target = target.replace(".ff.net.0.proj.", ".mlp.fc1.")
+            target = target.replace(".ff.net.2.", ".mlp.fc2.")
+            for part in ("q", "k", "v"):
+                marker = f".attn.to_{part}."
+                if marker in target:
+                    prefix, suffix = target.split(marker, 1)
+                    qkv_parts.setdefault(f"{prefix}.attn.qkv_proj.{suffix}", {})[part] = value
+                    break
+            else:
+                renamed[target] = value
+        for target, parts in qkv_parts.items():
+            if set(parts) != {"q", "k", "v"}:
+                raise ValueError(f"incomplete Diffusers QKV weights for {target}")
+            renamed[target] = torch.cat((parts["q"], parts["k"], parts["v"]), dim=0)
+        config = self._config(renamed)
+        return renamed, {"config": config}
+
+
+__all__ = [
+    "MINIMAX_H3_FP32_BUFFER_NAMES",
+    "MINIMAX_H3_FP32_PARAM_NAMES",
+    "MiniMaxH3DiT",
+    "MiniMaxH3DiTConfig",
+    "MiniMaxH3DiTStateDictConverter",
+    "_reorder_grouped_qkv_to_qkv",
+]
diff --git a/telefuser/models/minimax_h3_encoder.py b/telefuser/models/minimax_h3_encoder.py
new file mode 100644
index 00000000..3890d490
--- /dev/null
+++ b/telefuser/models/minimax_h3_encoder.py
@@ -0,0 +1,281 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 Qwen3-VL layer-50 encoder."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from transformers import Qwen3VLConfig, Qwen3VLModel
+
+from telefuser.core.base_model import BaseModel
+from telefuser.distributed.collectives import all_reduce_sum_
+from telefuser.distributed.device_mesh import get_tp_group, get_tp_rank, get_tp_world_size
+
+MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER = 50
+MINIMAX_H3_QWEN3VL_HIDDEN_DIM = 5120
+_LAYER_WEIGHT_RE = re.compile(r"^model\.language_model\.layers\.(\d+)\.")
+
+
+def _is_unconsumed_checkpoint_weight(name: str) -> bool:
+    if name == "lm_head.weight" or name.startswith("model.language_model.norm."):
+        return True
+    match = _LAYER_WEIGHT_RE.match(name)
+    return bool(match and int(match.group(1)) >= MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER)
+
+
+def load_minimax_h3_encoder_config(path: str | Path) -> Qwen3VLConfig:
+    config_path = Path(path)
+    source = config_path.parent if config_path.is_file() else config_path
+    config = Qwen3VLConfig.from_pretrained(source, local_files_only=True)
+    config.text_config.num_hidden_layers = MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER
+    config.text_config.output_hidden_states = False
+    config.text_config.use_cache = False
+    return config
+
+
+def _replace_parameter(module: nn.Module, name: str, value: torch.Tensor) -> None:
+    parameter = module.get_parameter(name)
+    setattr(module, name, nn.Parameter(value.contiguous(), requires_grad=parameter.requires_grad))
+
+
+def _shard_linear_output(
+    linear: nn.Linear,
+    *,
+    rank: int,
+    world_size: int,
+    sections: tuple[int, ...] | None = None,
+) -> None:
+    sections = sections or (linear.out_features,)
+    if sum(sections) != linear.out_features or any(size % world_size for size in sections):
+        raise ValueError(
+            f"linear output sections {sections} must sum to {linear.out_features} and divide TP degree {world_size}"
+        )
+    weight_sections = linear.weight.split(sections, dim=0)
+    local_weight = torch.cat(tuple(section.chunk(world_size, dim=0)[rank] for section in weight_sections), dim=0)
+    _replace_parameter(linear, "weight", local_weight)
+    if linear.bias is not None:
+        bias_sections = linear.bias.split(sections, dim=0)
+        local_bias = torch.cat(tuple(section.chunk(world_size, dim=0)[rank] for section in bias_sections), dim=0)
+        _replace_parameter(linear, "bias", local_bias)
+    linear.out_features //= world_size
+
+
+def _shard_linear_input(linear: nn.Linear, *, rank: int, world_size: int) -> None:
+    if linear.in_features % world_size:
+        raise ValueError(f"linear input size {linear.in_features} must divide TP degree {world_size}")
+    _replace_parameter(linear, "weight", linear.weight.chunk(world_size, dim=1)[rank])
+    if linear.bias is not None and rank != 0:
+        _replace_parameter(linear, "bias", torch.zeros_like(linear.bias))
+    linear.in_features //= world_size
+
+
+def _register_row_parallel_reduce(linear: nn.Linear, group: dist.ProcessGroup) -> None:
+    def reduce_output(_module: nn.Module, _inputs: tuple[torch.Tensor, ...], output: torch.Tensor) -> torch.Tensor:
+        all_reduce_sum_((output,), group=group)
+        return output
+
+    linear.register_forward_hook(reduce_output)
+
+
+class MiniMaxH3Encoder(BaseModel):
+    """Qwen3-VL multimodal backbone ending at unnormalized layer 50."""
+
+    def __init__(self, config: Qwen3VLConfig) -> None:
+        super().__init__()
+        if int(config.text_config.num_hidden_layers) != MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER:
+            raise ValueError("MiniMax H3 encoder config must be trimmed to 50 language layers")
+        if int(config.text_config.hidden_size) != MINIMAX_H3_QWEN3VL_HIDDEN_DIM:
+            raise ValueError("MiniMax H3 encoder hidden size must be 5120")
+        self.model = Qwen3VLModel(config)
+        self.model.language_model.norm = nn.Identity()
+        self.config = config
+        self.image_token_id = int(config.image_token_id)
+        self.video_token_id = int(config.video_token_id)
+        self.selected_lm_layer = MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER
+        self.hidden_dim = MINIMAX_H3_QWEN3VL_HIDDEN_DIM
+        self.layer_name_list = ["model"]
+        self.tp_flag = False
+
+    @property
+    def fsdp_language_layers(self) -> nn.ModuleList:
+        """Return language blocks as inference FSDP wrapping boundaries."""
+        return self.model.language_model.layers
+
+    @property
+    def fsdp_visual_blocks(self) -> nn.ModuleList:
+        """Return vision blocks as inference FSDP wrapping boundaries."""
+        return self.model.visual.blocks
+
+    @property
+    def fsdp_visual_deepstack_mergers(self) -> nn.ModuleList:
+        """Return vision deep-stack mergers as inference FSDP boundaries."""
+        return self.model.visual.deepstack_merger_list
+
+    def get_fsdp_module_names(self) -> list[str]:
+        return [
+            "fsdp_language_layers",
+            "fsdp_visual_blocks",
+            "fsdp_visual_deepstack_mergers",
+        ]
+
+    def enable_tp(self, device_mesh: Any) -> None:
+        world_size = get_tp_world_size(device_mesh)
+        if world_size <= 1:
+            return
+        if self.tp_flag:
+            raise RuntimeError("MiniMax H3 encoder tensor parallelism is already enabled")
+        group = get_tp_group(device_mesh)
+        if group is None:
+            raise RuntimeError("MiniMax H3 encoder TP requires a tensor-parallel process group")
+        rank = get_tp_rank(device_mesh)
+        text_config = self.config.text_config
+        if int(text_config.num_attention_heads) % world_size:
+            raise ValueError("Qwen3-VL query heads must divide the encoder TP degree")
+        if int(text_config.num_key_value_heads) % world_size:
+            raise ValueError("Qwen3-VL key/value heads must divide the encoder TP degree")
+        if int(text_config.intermediate_size) % world_size:
+            raise ValueError("Qwen3-VL language FFN size must divide the encoder TP degree")
+
+        for layer in self.model.language_model.layers:
+            attention = layer.self_attn
+            for projection in (attention.q_proj, attention.k_proj, attention.v_proj):
+                _shard_linear_output(projection, rank=rank, world_size=world_size)
+            _shard_linear_input(attention.o_proj, rank=rank, world_size=world_size)
+            _register_row_parallel_reduce(attention.o_proj, group)
+
+            mlp = layer.mlp
+            _shard_linear_output(mlp.gate_proj, rank=rank, world_size=world_size)
+            _shard_linear_output(mlp.up_proj, rank=rank, world_size=world_size)
+            _shard_linear_input(mlp.down_proj, rank=rank, world_size=world_size)
+            _register_row_parallel_reduce(mlp.down_proj, group)
+            mlp.intermediate_size //= world_size
+
+        vision_config = self.config.vision_config
+        if int(vision_config.num_heads) % world_size:
+            raise ValueError("Qwen3-VL vision heads must divide the encoder TP degree")
+        if int(vision_config.intermediate_size) % world_size:
+            raise ValueError("Qwen3-VL vision FFN size must divide the encoder TP degree")
+        for block in self.model.visual.blocks:
+            attention = block.attn
+            _shard_linear_output(
+                attention.qkv,
+                rank=rank,
+                world_size=world_size,
+                sections=(attention.dim, attention.dim, attention.dim),
+            )
+            _shard_linear_input(attention.proj, rank=rank, world_size=world_size)
+            _register_row_parallel_reduce(attention.proj, group)
+            attention.num_heads //= world_size
+
+            mlp = block.mlp
+            _shard_linear_output(mlp.linear_fc1, rank=rank, world_size=world_size)
+            _shard_linear_input(mlp.linear_fc2, rank=rank, world_size=world_size)
+            _register_row_parallel_reduce(mlp.linear_fc2, group)
+            mlp.intermediate_size //= world_size
+        self.tp_flag = True
+
+    @property
+    def device(self) -> torch.device:
+        return next(self.parameters()).device
+
+    @torch.no_grad()
+    def forward(
+        self,
+        input_ids: torch.Tensor | None,
+        position_ids: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        inputs_embeds: torch.Tensor | None = None,
+        **kwargs: Any,
+    ) -> torch.Tensor:
+        outputs = self.model(
+            input_ids=input_ids,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=True,
+            use_cache=False,
+            **kwargs,
+        )
+        return outputs.last_hidden_state
+
+    @torch.no_grad()
+    def encode_ids(
+        self,
+        input_ids: torch.Tensor,
+        *,
+        pixel_values: torch.Tensor | None = None,
+        image_grid_thw: torch.Tensor | None = None,
+        pixel_values_videos: torch.Tensor | None = None,
+        video_grid_thw: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        if input_ids.ndim != 1:
+            raise ValueError(f"input_ids must be one-dimensional, got {list(input_ids.shape)}")
+        if (pixel_values is None) != (image_grid_thw is None):
+            raise ValueError("pixel_values and image_grid_thw must be provided together")
+        if (pixel_values_videos is None) != (video_grid_thw is None):
+            raise ValueError("pixel_values_videos and video_grid_thw must be provided together")
+
+        host_ids = input_ids.to(device="cpu", dtype=torch.long).unsqueeze(0)
+        host_image_grid = None if image_grid_thw is None else image_grid_thw.to(device="cpu", dtype=torch.long)
+        host_video_grid = None if video_grid_thw is None else video_grid_thw.to(device="cpu", dtype=torch.long)
+        position_ids = None
+        if host_image_grid is not None or host_video_grid is not None:
+            position_ids, _ = self.model.get_rope_index(
+                host_ids,
+                host_image_grid,
+                host_video_grid,
+                attention_mask=torch.ones_like(host_ids),
+            )
+        call_kwargs: dict[str, Any] = {
+            "input_ids": host_ids.to(self.device),
+            "attention_mask": torch.ones_like(host_ids).to(self.device),
+        }
+        if position_ids is not None:
+            call_kwargs["position_ids"] = position_ids.to(self.device)
+        if pixel_values is not None:
+            call_kwargs["pixel_values"] = pixel_values.to(self.device, torch.bfloat16)
+            call_kwargs["image_grid_thw"] = host_image_grid
+        if pixel_values_videos is not None:
+            call_kwargs["pixel_values_videos"] = pixel_values_videos.to(self.device, torch.bfloat16)
+            call_kwargs["video_grid_thw"] = host_video_grid
+        hidden = self(**call_kwargs)[0].to(torch.bfloat16)
+        expected = (input_ids.numel(), self.hidden_dim)
+        if tuple(hidden.shape) != expected:
+            raise ValueError(f"unexpected MiniMax H3 encoder shape {tuple(hidden.shape)}, expected {expected}")
+        return hidden
+
+    @staticmethod
+    def state_dict_converter(config_path: str | Path) -> MiniMaxH3EncoderStateDictConverter:
+        return MiniMaxH3EncoderStateDictConverter(config_path)
+
+
+class MiniMaxH3EncoderStateDictConverter:
+    def __init__(self, config_path: str | Path) -> None:
+        self.config = load_minimax_h3_encoder_config(config_path)
+
+    def from_official(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        converted = {
+            name: value
+            for name, value in state_dict.items()
+            if "rotary_emb.inv_freq" not in name and not _is_unconsumed_checkpoint_weight(name)
+        }
+        return converted, {"config": self.config}
+
+    def from_diffusers(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        return self.from_official(state_dict)
+
+
+__all__ = [
+    "MINIMAX_H3_QWEN3VL_HIDDEN_DIM",
+    "MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER",
+    "MiniMaxH3Encoder",
+    "MiniMaxH3EncoderStateDictConverter",
+    "load_minimax_h3_encoder_config",
+]
diff --git a/telefuser/models/minimax_h3_video/__init__.py b/telefuser/models/minimax_h3_video/__init__.py
new file mode 100644
index 00000000..28f7bde2
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+
+from .klvae import AutoencoderKLLegacy
+
+__all__ = ["AutoencoderKLLegacy"]
diff --git a/telefuser/models/minimax_h3_video/attention.py b/telefuser/models/minimax_h3_video/attention.py
new file mode 100644
index 00000000..67bb98b8
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/attention.py
@@ -0,0 +1,157 @@
+# SPDX-License-Identifier: Apache-2.0
+# Attention module for the MiniMax H3 visual VAE (inference-only bundle).
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from diffusers.utils import logging
+
+from .flash import flash_attn
+from .vit_utils import apply_rotary_pos_emb_qk
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _vit_norm_input(module, hidden_states):
+    return hidden_states.float()
+
+
+def _apply_qk_norm(module, hidden_states):
+    if (
+        isinstance(module, (nn.LayerNorm, nn.RMSNorm))
+        and getattr(module, "weight", None) is None
+        and getattr(module, "bias", None) is None
+        and hidden_states.is_cuda
+        and hidden_states.dtype in (torch.float16, torch.bfloat16)
+        and not torch.is_grad_enabled()
+        and not torch.compiler.is_compiling()
+    ):
+        # CUDA LayerNorm/RMSNorm accumulates half/bfloat16 inputs in FP32.
+        # With no affine parameters its half output is bit-identical to the
+        # released FP32-norm-then-cast recipe, without two full-tensor casts.
+        with torch.autocast("cuda", enabled=False):
+            return module(hidden_states)
+    return module(_vit_norm_input(module, hidden_states)).to(hidden_states.dtype)
+
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        heads,
+        dim_head,
+        embed_dim: Optional[int] = None,
+        qk_norm_type: Optional[str] = None,
+        qk_norm_affine: bool = False,
+        bias: bool = True,
+        out_bias: Optional[bool] = None,
+        eps: float = 1e-5,
+        **kwargs,
+    ):
+        super().__init__()
+        self.dim_head = dim_head
+        self.heads = heads
+        self.attn_inner_dim = dim_head * heads
+        self.embed_dim = embed_dim if embed_dim is not None else self.attn_inner_dim
+
+        out_bias = out_bias if out_bias is not None else bias
+
+        if qk_norm_type is None:
+            self.norm_q = None
+            self.norm_k = None
+        elif qk_norm_type == "layer_norm":
+            self.norm_q = nn.LayerNorm(dim_head, eps=eps, elementwise_affine=qk_norm_affine)
+            self.norm_k = nn.LayerNorm(dim_head, eps=eps, elementwise_affine=qk_norm_affine)
+        elif qk_norm_type == "rms_norm":
+            self.norm_q = nn.RMSNorm(dim_head, eps=eps, elementwise_affine=qk_norm_affine)
+            self.norm_k = nn.RMSNorm(dim_head, eps=eps, elementwise_affine=qk_norm_affine)
+        else:
+            raise ValueError(f"unknown qk_norm_type: {qk_norm_type}. Should be None,'layer_norm','rms_norm'")
+
+        self.to_qkv = nn.Linear(self.embed_dim, self.attn_inner_dim * 3, bias=bias)
+
+        self.to_out = nn.Linear(self.attn_inner_dim, self.embed_dim, bias=out_bias)
+
+        if len(kwargs) > 0:
+            logger.warning(f"Unused kwargs: {kwargs}")
+
+    def _perform_attention(self, query, key, value, pack_info):
+        cu_seqlens = pack_info.get("cu_seqlens", None)
+        mask_mod = pack_info.get("mask_mod", None)
+        block_sparse = pack_info.get("block_sparse", None)
+        valid_seq_len = pack_info.get("valid_seq_len", None)
+
+        if cu_seqlens is not None:
+            raise NotImplementedError("varlen attention is not supported in this inference-only bundle")
+
+        padded_seq_len = query.shape[1]
+        if valid_seq_len is not None:
+            valid_seq_len = int(valid_seq_len)
+            if not 0 < valid_seq_len <= padded_seq_len:
+                raise ValueError(
+                    "valid_seq_len must be in (0, padded_seq_len], got "
+                    f"{valid_seq_len} for padded_seq_len={padded_seq_len}"
+                )
+            query = query[:, :valid_seq_len]
+            key = key[:, :valid_seq_len]
+            value = value[:, :valid_seq_len]
+
+        if mask_mod is not None:
+            hidden_states = flash_attn(
+                query,
+                key,
+                value,
+                mask_mod=mask_mod,
+                block_sparse=block_sparse,
+            )
+        else:
+            hidden_states = flash_attn(
+                query,
+                key,
+                value,
+            )
+
+        if valid_seq_len is not None and valid_seq_len < padded_seq_len:
+            hidden_states = torch.cat(
+                [
+                    hidden_states,
+                    hidden_states.new_zeros(
+                        hidden_states.shape[0],
+                        padded_seq_len - valid_seq_len,
+                        hidden_states.shape[2],
+                        hidden_states.shape[3],
+                    ),
+                ],
+                dim=1,
+            )
+
+        return hidden_states
+
+    def perform_attention(self, query, key, value, pack_info: dict | None = None):
+        return self._perform_attention(query, key, value, {} if pack_info is None else pack_info)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        rotary_pos_emb: Optional[torch.Tensor] = None,
+        pack_info: dict | None = None,
+    ) -> torch.Tensor:
+        batch_size, seq_len, _ = hidden_states.shape
+
+        qkv = self.to_qkv(hidden_states)
+        qkv = qkv.view(batch_size, seq_len, -1, 3 * self.dim_head)
+        query, key, value = torch.chunk(qkv, 3, dim=-1)
+
+        if self.norm_q is not None:
+            query = _apply_qk_norm(self.norm_q, query)
+        if self.norm_k is not None:
+            key = _apply_qk_norm(self.norm_k, key)
+
+        if rotary_pos_emb is not None:
+            query, key = apply_rotary_pos_emb_qk(query, key, rotary_pos_emb)
+
+        hidden_states = self.perform_attention(query, key, value, pack_info)
+
+        hidden_states = hidden_states.reshape(batch_size, seq_len, -1)
+        hidden_states = self.to_out(hidden_states)
+
+        return hidden_states
diff --git a/telefuser/models/minimax_h3_video/base_module.py b/telefuser/models/minimax_h3_video/base_module.py
new file mode 100644
index 00000000..2837cee2
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/base_module.py
@@ -0,0 +1,195 @@
+# SPDX-License-Identifier: Apache-2.0
+# Transformer building blocks for the MiniMax H3 visual VAE ViT decoder.
+import math
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from diffusers.utils import logging
+from diffusers.utils.torch_utils import maybe_allow_in_graph
+
+from telefuser.ops.activations import silu_and_mul
+
+from .attention import Attention
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _vit_norm_input(module, hidden_states):
+    return hidden_states.float()
+
+
+def _scaled_residual_add(residual, x, scale):
+    return residual + x * scale
+
+
+class FeedForward(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        dim_out: Optional[int] = None,
+        mult: int = 4,
+        activation_fn: str = "silu",
+        bias: bool = True,
+        use_gated: bool = True,
+        glu_balanced: bool = False,
+    ):
+        super().__init__()
+        ratio = 2 / 3 if (use_gated and glu_balanced) else 1
+        inner_dim = round(dim * mult * ratio)
+        dim_out = dim_out if dim_out is not None else dim
+        self.use_gated = use_gated
+
+        if use_gated:
+            self.w1 = nn.Linear(dim, inner_dim * 2, bias=bias)
+        else:
+            self.w1 = nn.Linear(dim, inner_dim, bias=bias)
+
+        if activation_fn == "silu":
+            self.act_fn = nn.SiLU()
+        elif activation_fn == "gelu":
+            self.act_fn = nn.GELU()
+        elif activation_fn == "gelu-approximate":
+            self.act_fn = nn.GELU(approximate="tanh")
+        else:
+            raise ValueError(f"Unsupported activation function: {activation_fn}")
+
+        self.w2 = nn.Linear(inner_dim, dim_out, bias=bias)
+
+    def _forward_impl(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.w1(hidden_states)
+
+        if self.use_gated:
+            if isinstance(self.act_fn, nn.SiLU):
+                hidden_states = silu_and_mul(hidden_states)
+            else:
+                gate, hidden_states = hidden_states.chunk(2, dim=-1)
+                hidden_states = self.act_fn(gate).mul_(hidden_states)
+        else:
+            hidden_states = self.act_fn(hidden_states)
+
+        hidden_states = self.w2(hidden_states)
+        return hidden_states
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return self._forward_impl(hidden_states)
+
+
+class RotaryEmbeddingND(nn.Module):
+    def __init__(self, dim, rotary_base=10000, n_dim=3, use_angle=False):
+        super().__init__()
+        self.dim = dim
+        self.n_dim = n_dim
+
+        if dim % (2 * n_dim) != 0:
+            raise ValueError(f"head_dim {dim} must be divisible by 2 * n_dim {2 * n_dim}")
+
+        if use_angle:
+            self.angle_scale = 2.0 * math.pi
+        else:
+            self.angle_scale = 1.0
+
+        inv_freq = 1 / rotary_base ** torch.arange(0, 1, 2 * n_dim / dim, dtype=torch.float32)
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+    def forward(self, img_ids):
+        B, N, D = img_ids.shape
+        if D != self.n_dim:
+            raise ValueError(f"Expected {self.n_dim} dimensions, got {D}")
+
+        with torch.autocast("cuda", enabled=False):
+            angles = self.angle_scale * img_ids[:, :, :, None] * self.inv_freq.to(img_ids.device)[None, None, None, :]
+            angles = angles.flatten(2, 3)
+            angles = angles.tile(2)
+            angles = angles.unsqueeze(2)
+
+            cos = torch.cos(angles)
+            sin = torch.sin(angles)
+
+        return cos.to(dtype=img_ids.dtype), sin.to(dtype=img_ids.dtype)
+
+
+@maybe_allow_in_graph
+class TransformerBlock(nn.Module):
+    def __init__(
+        self,
+        heads: int,
+        dim_head: int,
+        embed_dim: Optional[int] = None,
+        ffn_glu_balanced: bool = False,
+        norm_type: str = "layer_norm",
+        norm_affine: bool = True,
+        qk_norm_type: str = "rms_norm",
+        qk_norm_affine: bool = False,
+        ffn_activation_fn: str = "silu",
+        ffn_use_gated: bool = True,
+        use_scale: bool = True,
+        bias: bool = True,
+        eps: float = 1e-5,
+        **kwargs,
+    ):
+        super().__init__()
+        dim = embed_dim if embed_dim is not None else dim_head * heads
+        self.use_scale = use_scale
+
+        if norm_type == "layer_norm":
+            norm_class = nn.LayerNorm
+        elif norm_type == "rms_norm":
+            norm_class = nn.RMSNorm
+        else:
+            raise ValueError(f"unknown norm_type {norm_type}")
+
+        self.norm1 = norm_class(
+            dim,
+            elementwise_affine=norm_affine,
+            eps=eps,
+        )
+        self.attn = Attention(
+            heads=heads,
+            dim_head=dim_head,
+            embed_dim=dim,
+            qk_norm_type=qk_norm_type,
+            qk_norm_affine=qk_norm_affine,
+            bias=bias,
+            eps=eps,
+            **kwargs,
+        )
+        if use_scale:
+            self.scale1 = nn.Parameter(torch.zeros(dim))
+
+        self.norm2 = norm_class(
+            dim,
+            elementwise_affine=norm_affine,
+            eps=eps,
+        )
+        self.ff = FeedForward(
+            dim=dim,
+            activation_fn=ffn_activation_fn,
+            bias=bias,
+            use_gated=ffn_use_gated,
+            glu_balanced=ffn_glu_balanced,
+        )
+        if use_scale:
+            self.scale2 = nn.Parameter(torch.zeros(dim))
+
+    def forward(
+        self,
+        hidden_states: torch.FloatTensor,
+        rotary_pos_emb: Optional[torch.FloatTensor] = None,
+        pack_info: dict | None = None,
+    ):
+        norm_hidden_states = self.norm1(_vit_norm_input(self.norm1, hidden_states)).to(hidden_states.dtype)
+        attn_output = self.attn(norm_hidden_states, rotary_pos_emb, pack_info)
+        if self.use_scale:
+            hidden_states = _scaled_residual_add(hidden_states, attn_output, self.scale1)
+        else:
+            hidden_states = hidden_states + attn_output
+
+        norm_hidden_states = self.norm2(_vit_norm_input(self.norm2, hidden_states)).to(hidden_states.dtype)
+        ff_output = self.ff(norm_hidden_states)
+        if self.use_scale:
+            hidden_states = _scaled_residual_add(hidden_states, ff_output, self.scale2)
+        else:
+            hidden_states = hidden_states + ff_output
+
+        return hidden_states
diff --git a/telefuser/models/minimax_h3_video/conv.py b/telefuser/models/minimax_h3_video/conv.py
new file mode 100644
index 00000000..98a2e483
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/conv.py
@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: Apache-2.0
+# 3D convolution for the MiniMax H3 visual VAE.
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class BaseConv3d(nn.Conv3d):
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        kernel_size,
+        stride=1,
+        padding=0,
+        bias=True,
+        padding_mode="zeros",
+        padding_mode_t=None,
+        causal=True,
+    ):
+        super().__init__(
+            in_channels,
+            out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            bias=bias,
+            padding_mode=padding_mode,
+        )
+        padding_mode = "constant" if padding_mode == "zeros" else padding_mode
+        padding_mode_t = "constant" if padding_mode_t == "zeros" else padding_mode_t
+        self.pad_mode = padding_mode
+        self.pad_mode_t = padding_mode_t or ("constant" if causal else "replicate")
+        self.causal = causal
+
+    def _apply_temporal_padding(self, x):
+        B, C, D, H, W = x.shape
+        if D > 1:
+            pad_size = (
+                0,
+                0,
+                0,
+                0,
+                self.padding[0] * 2 if self.causal else self.padding[0],
+                0 if self.causal else self.padding[0],
+            )
+            return F.pad(x, pad_size, mode=self.pad_mode_t)
+        else:
+            if self.pad_mode_t == "constant":
+                assert self.causal, "Zeros padding is only supported for causal mode"
+                return F.pad(
+                    x,
+                    (0, 0, 0, 0, self.kernel_size[0] - 1, 0),
+                    mode="constant",
+                )
+            else:
+                return x.expand(-1, -1, self.kernel_size[0], -1, -1)
+
+    def _apply_padding(self, x):
+        if sum(self.padding) == 0:
+            return x
+
+        x = F.pad(
+            x,
+            (self.padding[2], self.padding[2], self.padding[1], self.padding[1], 0, 0),
+            mode=self.pad_mode,
+        )
+
+        x = self._apply_temporal_padding(x)
+        return x
+
+    def forward(self, x):
+        if sum(self.padding) == 0:
+            return super().forward(x)
+
+        x = self._apply_padding(x)
+        return F.conv3d(
+            x,
+            self.weight,
+            self.bias,
+            stride=self.stride,
+            padding=0,
+            dilation=self.dilation,
+        )
diff --git a/telefuser/models/minimax_h3_video/flash.py b/telefuser/models/minimax_h3_video/flash.py
new file mode 100644
index 00000000..f4b83397
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/flash.py
@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: Apache-2.0
+# Torch-native attention implemented with PyTorch SDPA instead of FA4/CUTLASS.
+import torch
+
+from telefuser.ops.attention import attention
+
+_BLOCK_CAUSAL_MASK_MOD_CACHE = {}
+
+
+def _as_bool_mask(mask, *, device):
+    if not isinstance(mask, torch.Tensor):
+        mask = torch.as_tensor(mask, device=device)
+    return mask.to(device=device, dtype=torch.bool)
+
+
+def _ensure_nonempty_rows(mask):
+    if mask.numel() == 0 or mask.shape[-1] == 0:
+        return mask
+    empty = ~mask.any(dim=-1)
+    mask[..., 0] |= empty
+    return mask
+
+
+def _sdpa_attention(query, key, value, causal=False, attn_mask=None):
+    if attn_mask is not None and attn_mask.dim() == 3:
+        attn_mask = attn_mask.unsqueeze(0)
+    return attention(
+        query,
+        key,
+        value,
+        attn_mask=attn_mask,
+        input_layout="BSND",
+        output_layout="BSND",
+        is_causal=causal,
+    ).nan_to_num(0.0)
+
+
+def _mask_mod_to_dense(mask_mod, batch, heads, q_len, kv_len, device, aux_tensors=None):
+    q_idx = torch.arange(q_len, device=device).view(q_len, 1)
+    kv_idx = torch.arange(kv_len, device=device).view(1, kv_len)
+    dense = torch.empty((batch, heads, q_len, kv_len), dtype=torch.bool, device=device)
+    for b in range(batch):
+        b_idx = torch.tensor(b, device=device)
+        for h in range(heads):
+            h_idx = torch.tensor(h, device=device)
+            mask = mask_mod(b_idx, h_idx, q_idx, kv_idx, None, aux_tensors)
+            dense[b, h] = _as_bool_mask(mask, device=device)
+    return _ensure_nonempty_rows(dense)
+
+
+#########################################################
+# Block causal attention
+#########################################################
+
+
+def make_block_causal_mask_mod(num_tokens, block_size, num_special=0, suffix=False):
+    if num_tokens < 0:
+        raise ValueError(f"num_tokens must be non-negative, got {num_tokens}")
+    if block_size <= 0:
+        raise ValueError(f"block_size must be positive, got {block_size}")
+    if num_special < 0:
+        raise ValueError(f"num_special must be non-negative, got {num_special}")
+
+    cache_key = (num_tokens, block_size, num_special, suffix)
+    if cache_key in _BLOCK_CAUSAL_MASK_MOD_CACHE:
+        return _BLOCK_CAUSAL_MASK_MOD_CACHE[cache_key]
+
+    if suffix:
+
+        def mask_mod(b, h, q_idx, kv_idx, seqlen_info, aux_tensors):
+            del b, h, seqlen_info, aux_tensors
+            q_is_special = q_idx >= num_tokens
+            kv_is_special = kv_idx >= num_tokens
+            return q_is_special | kv_is_special | (q_idx // block_size >= kv_idx // block_size)
+
+    else:
+
+        def mask_mod(b, h, q_idx, kv_idx, seqlen_info, aux_tensors):
+            del b, h, seqlen_info, aux_tensors
+            q_is_special = q_idx < num_special
+            kv_is_special = kv_idx < num_special
+            q_block_idx = (q_idx - num_special) // block_size
+            kv_block_idx = (kv_idx - num_special) // block_size
+            return q_is_special | kv_is_special | (q_block_idx >= kv_block_idx)
+
+    mask_mod.block_sparse_cache_key = (
+        "block_causal",
+        num_tokens,
+        block_size,
+        num_special,
+        suffix,
+    )
+    _BLOCK_CAUSAL_MASK_MOD_CACHE[cache_key] = mask_mod
+    return mask_mod
+
+
+#########################################################
+# Public entry point
+#########################################################
+
+
+@torch.compiler.disable
+def flash_attn(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    causal: bool = False,
+    mask_mod=None,
+    block_sparse=None,
+    aux_tensors=None,
+) -> torch.Tensor:
+    use_masked = mask_mod is not None or block_sparse is not None
+
+    if block_sparse is not None and mask_mod is None:
+        raise ValueError("block_sparse requires mask_mod")
+    if causal and mask_mod is not None:
+        raise ValueError("causal must be encoded in mask_mod when using masked attention")
+    if aux_tensors is not None and not use_masked:
+        raise ValueError("aux_tensors is only supported with masked attention")
+
+    if use_masked:
+        batch, q_len, heads, _ = query.shape
+        kv_len = key.shape[1]
+        dense_mask = _mask_mod_to_dense(
+            mask_mod,
+            batch,
+            heads,
+            q_len,
+            kv_len,
+            query.device,
+            aux_tensors=aux_tensors,
+        )
+        return _sdpa_attention(query, key, value, attn_mask=dense_mask)
+
+    return _sdpa_attention(query, key, value, causal=causal)
diff --git a/telefuser/models/minimax_h3_video/klvae.py b/telefuser/models/minimax_h3_video/klvae.py
new file mode 100644
index 00000000..633bf5ff
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/klvae.py
@@ -0,0 +1,1162 @@
+# SPDX-License-Identifier: Apache-2.0
+# MiniMax H3 visual VAE: 3D causal CNN encoder + ViT3D decoder (inference-only bundle).
+import math
+from typing import List, Union
+
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from PIL import Image
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.loaders.single_file_model import FromOriginalModelMixin
+from diffusers.models import ModelMixin
+from diffusers.utils import logging
+
+from telefuser.distributed.collectives import all_gather_stacked
+
+from .processor import (
+    VAEProcessor,
+    get_denormalize_transform,
+    get_normalize_transform,
+)
+from .vae_cnn import EncoderFCN3D
+from .vae_vit import ViT3DDecoder
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+def _resolve_temporal_cat_dtype():
+    return None
+
+
+def _resolve_temporal_stream_cat():
+    return True
+
+
+class DiagonalGaussianDistribution(object):
+    def __init__(self, parameters, upcast_fp32=True):
+        if upcast_fp32:
+            parameters = parameters.to(dtype=torch.float32)
+
+        self.parameters = parameters
+        self.mean, self.logvar = torch.chunk(parameters, 2, dim=1)
+        self.logvar = torch.clamp(self.logvar, -30.0, 20.0)
+        self.std = self.logvar.mul(0.5).exp_()
+
+    @torch.compiler.disable
+    def sample(self, generator=None):
+        noise = torch.randn(self.mean.shape, generator=generator)
+        noise = noise.to(device=self.parameters.device)
+        return noise.mul_(self.std).add_(self.mean)
+
+
+class ClsTokenAggregator:
+    def __init__(self, vae_model):
+        self.vae = vae_model
+        self.cls_tokens = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.cls_tokens and hasattr(self.vae.encoder, "loss_info"):
+            self.vae.encoder.loss_info["cls_token"] = torch.stack(self.cls_tokens, dim=0).mean(dim=0)
+        return False
+
+    def collect(self):
+        if hasattr(self.vae.encoder, "loss_info") and "cls_token" in self.vae.encoder.loss_info:
+            self.cls_tokens.append(self.vae.encoder.loss_info["cls_token"].clone())
+
+    def collect_stacked(self, num_tiles, sample_batch_size):
+        if hasattr(self.vae.encoder, "loss_info") and "cls_token" in self.vae.encoder.loss_info:
+            cls_token = self.vae.encoder.loss_info["cls_token"]
+            cls_token = cls_token.unflatten(0, (num_tiles, sample_batch_size))
+            self.cls_tokens.extend(token.clone() for token in cls_token)
+
+
+class AutoencoderKL(ModelMixin, ConfigMixin, FromOriginalModelMixin):
+    r"""
+    Abstract shared base for the MiniMax H3 visual VAE.
+
+    This class only carries the shared inference machinery (temporal
+    chunking, tiling, encode/decode entry points). Instantiate the concrete
+    subclass ``AutoencoderKLLegacy`` via ``from_pretrained`` instead.
+    """
+
+    _compilable_modules = ["encoder", "decoder"]
+    _deprecated_kwargs = [
+        "clip_length",
+        "token_drop",
+        "isolated_first_frame",
+        "isolated_last_frame",
+        "isolated_key_frame",
+        "encoder_tiling",
+        "decoder_tiling",
+        "parallel_tiling",
+        "stack_tiling",
+        "tile_size",
+        "tile_overlap_min",
+        "decoder_tile_size",
+        "decoder_tile_overlap_min",
+        "latent_patch_size",
+        "crop_mode",
+        "encoder_parallel",
+        "decoder_parallel",
+        "chunk_dim",
+    ]  # legacy config keys accepted by from_pretrained for checkpoint compatibility
+
+    def setup_forward(self, **kwargs):
+        self.clip_length = kwargs.get("clip_length", 17)
+        self.token_drop = kwargs.get("token_drop", 0)
+        self.frame_drop = self.token_drop * self.vae_ratio_t
+        self.frame_pre_padding = (-self.clip_length) % self.vae_ratio_t
+        self.tokens_chunk_size = math.ceil(self.clip_length / self.vae_ratio_t)
+        self.token_overlap = (-self.token_drop) % self.tokens_chunk_size
+        self.frame_overlap = max(self.token_overlap * self.vae_ratio_t - self.frame_pre_padding, 0)
+        self.isolated_first_frame = kwargs.get("isolated_first_frame", False)
+        self.isolated_last_frame = kwargs.get("isolated_last_frame", False)
+        self.isolated_key_frame = kwargs.get("isolated_key_frame", False)
+
+        self.encoder_tiling = kwargs.get("encoder_tiling", False)
+        self.decoder_tiling = kwargs.get("decoder_tiling", False)
+        self.stack_tiling = kwargs.get("stack_tiling", False)
+        self.tile_size = kwargs.get("tile_size", 256)
+        self.tile_overlap_min = kwargs.get("tile_overlap_min", 64)
+        self.decoder_tile_size = kwargs.get("decoder_tile_size", self.tile_size)
+        self.decoder_tile_overlap_min = kwargs.get("decoder_tile_overlap_min", self.tile_overlap_min)
+        self._blend_weight_cache = {}
+        self.latent_patch_size = kwargs.get("latent_patch_size", 1)
+        self.crop_mode = kwargs.get("crop_mode", "top_left")
+        self.pixel_norm_type = kwargs.get("pixel_norm_type", "imagenet")
+
+        if kwargs.get("encoder_parallel", False) or kwargs.get("decoder_parallel", False):
+            raise ValueError("MiniMax H3 VAE spatial sharding is unsupported")
+        self.parallel_tiling = bool(kwargs.get("parallel_tiling", False))
+        self.tile_parallel_group = None
+
+        processor_kwargs = {
+            "vae_ratio": self.vae_ratio,
+            "vae_ratio_t": self.vae_ratio_t,
+            "clip_length": self.clip_length,
+            "frame_overlap": self.frame_overlap,
+            "token_overlap": self.token_overlap,
+            "tokens_chunk_size": self.tokens_chunk_size,
+            "isolated_last_frame": self.isolated_last_frame,
+            "latent_patch_size": self.latent_patch_size,
+            "crop_mode": self.crop_mode,
+            "pixel_norm_type": self.pixel_norm_type,
+            "transform": self.transform,
+            "transform_rev": self.transform_rev,
+            "use_3d_conv": self.use_3d_conv,
+        }
+        if hasattr(self, "processor"):
+            for key, value in processor_kwargs.items():
+                setattr(self.processor, key, value)
+        else:
+            self.processor = VAEProcessor(**processor_kwargs)
+
+    def enable_parallel_tiling(self, group: dist.ProcessGroup) -> None:
+        self.tile_parallel_group = group
+        self.parallel_tiling = dist.get_world_size(group=group) > 1
+
+    def _tile_parallel_state(self) -> tuple[int, int]:
+        if not self.parallel_tiling or self.tile_parallel_group is None:
+            return 0, 1
+        return (
+            dist.get_rank(group=self.tile_parallel_group),
+            dist.get_world_size(group=self.tile_parallel_group),
+        )
+
+    def split_tiles(self, input_len, is_decoder=False):
+        tile_size = self.decoder_tile_size if is_decoder else self.tile_size
+        tile_overlap_min = self.decoder_tile_overlap_min if is_decoder else self.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 // self.vae_ratio
+        for i in range(remaining_units):
+            overlaps[i % (N - 1)] += self.vae_ratio
+
+        tile_start_idx = [0]
+        for i in range(N - 1):
+            tile_start_idx.append(tile_start_idx[-1] + tile_size - overlaps[i])
+
+        tile_len = [tile_size] * N
+        return tile_start_idx, tile_len, overlaps
+
+    def blend(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int, dim: int) -> torch.Tensor:
+        blend_extent = min(a.shape[dim], b.shape[dim], blend_extent)
+
+        cache_key = (blend_extent, b.device, b.dtype)
+        weights = self._blend_weight_cache.get(cache_key)
+        if weights is None:
+            positions = torch.arange(blend_extent, device=b.device, dtype=b.dtype)
+            weights = (1 - positions / blend_extent, positions / blend_extent)
+            self._blend_weight_cache[cache_key] = weights
+        weight_a, weight_b = weights
+
+        shape = [1] * a.ndim
+        shape[dim] = blend_extent
+        weight_a = weight_a.view(shape)
+        weight_b = weight_b.view(shape)
+
+        slice_a = [slice(None)] * a.ndim
+        slice_a[dim] = slice(-blend_extent, None)
+        a_overlap = a[tuple(slice_a)]
+
+        slice_b = [slice(None)] * b.ndim
+        slice_b[dim] = slice(0, blend_extent)
+        b_overlap = b[tuple(slice_b)]
+
+        blended = a_overlap * weight_a
+        blended.add_(b_overlap * weight_b)
+
+        if blend_extent < b.shape[dim]:
+            slice_b_rest = [slice(None)] * b.ndim
+            slice_b_rest[dim] = slice(blend_extent, None)
+            b_rest = b[tuple(slice_b_rest)]
+            return torch.cat([blended, b_rest], dim=dim)
+        else:
+            return blended
+
+    def _assemble_tiles(self, rows, y_overlap, x_overlap):
+        output_height = sum(row[0].shape[-2] - (y_overlap[i] if i < len(rows) - 1 else 0) for i, row in enumerate(rows))
+        output_width = sum(
+            tile.shape[-1] - (x_overlap[j] if j < len(rows[0]) - 1 else 0) for j, tile in enumerate(rows[0])
+        )
+        output = rows[0][0].new_empty((*rows[0][0].shape[:-2], output_height, output_width))
+
+        y_offset = 0
+        # released VAE blends vertically before horizontally; preserve that
+        # order while writing each cropped tile into the final tensor
+        for i, row in enumerate(rows):
+            row_height = row[0].shape[-2] - (y_overlap[i] if i < len(rows) - 1 else 0)
+            x_offset = 0
+            for j, tile in enumerate(row):
+                if i > 0:
+                    tile = self.blend(rows[i - 1][j], tile, y_overlap[i - 1], dim=-2)
+                if j > 0:
+                    tile = self.blend(row[j - 1], tile, x_overlap[j - 1], dim=-1)
+                if i < len(rows) - 1:
+                    tile = tile[..., : -y_overlap[i], :]
+                if j < len(row) - 1:
+                    tile = tile[..., :, : -x_overlap[j]]
+
+                tile_height, tile_width = tile.shape[-2:]
+                output[
+                    ...,
+                    y_offset : y_offset + tile_height,
+                    x_offset : x_offset + tile_width,
+                ].copy_(tile)
+                x_offset += tile_width
+            y_offset += row_height
+
+        return output
+
+    def _all_gather_tiled_results(self, tasks, num_tiles):
+        tile_rank, tile_world_size = self._tile_parallel_state()
+
+        if not tasks:
+            raise ValueError(f"Found empty tasks on tile rank {tile_rank}")
+
+        expected_tasks = (num_tiles - tile_rank + tile_world_size - 1) // tile_world_size
+        if len(tasks) != expected_tasks:
+            raise ValueError(
+                f"Expected {expected_tasks} tiled tasks on rank {tile_rank}, "
+                f"got {len(tasks)} for num_tiles={num_tiles}, "
+                f"world_size={tile_world_size}"
+            )
+
+        max_tasks = (num_tiles + tile_world_size - 1) // tile_world_size
+        if len(tasks) == max_tasks:
+            stacked = torch.stack(tasks, dim=0)
+        else:
+            stacked = tasks[0].new_empty((max_tasks, *tasks[0].shape))
+            torch.stack(tasks, dim=0, out=stacked[: len(tasks)])
+            stacked[len(tasks) :].zero_()
+
+        # Round-robin tile ownership makes every rank's task count known from
+        # num_tiles and world size. Pad only the leading task dimension and use a
+        # single equal-shape all-gather; the previous path paid for a barrier,
+        # a shape all-gather, and then a padded data all-gather per temporal
+        # clip.
+        gathered = all_gather_stacked(
+            stacked,
+            group=self.tile_parallel_group,
+            world_size=tile_world_size,
+        )
+
+        results = [None] * num_tiles
+        for rank, rank_tensors in enumerate(gathered):
+            num_rank_tasks = (num_tiles - rank + tile_world_size - 1) // tile_world_size
+            for k in range(num_rank_tasks):
+                global_idx = k * tile_world_size + rank
+                results[global_idx] = rank_tensors[k]
+
+        return results
+
+    def _local_tile_indices(self, num_tiles, tile_rank, tile_world_size):
+        return list(range(tile_rank, num_tiles, tile_world_size))
+
+    def _run_tile_tasks(self, tiles, tile_indices, forward_fn, stack_tiling, cls_agg=None):
+        if stack_tiling and tile_indices:
+            sample_batch_size = tiles[0].shape[0]
+            tile_batch = torch.cat([tiles[idx] for idx in tile_indices], dim=0)
+            output_batch = forward_fn(tile_batch)
+            output_tiles = output_batch.unflatten(0, (len(tile_indices), sample_batch_size)).unbind(dim=0)
+            if cls_agg is not None:
+                cls_agg.collect_stacked(len(tile_indices), sample_batch_size)
+            return list(output_tiles)
+
+        tasks = []
+        for idx in tile_indices:
+            tasks.append(forward_fn(tiles[idx]))
+            if cls_agg is not None:
+                cls_agg.collect()
+        return tasks
+
+    def tiled_encode(self, x):
+        if self.parallel_tiling:  # Fast online encoding for large videos
+            tile_rank, tile_world_size = self._tile_parallel_state()
+        else:
+            tile_rank, tile_world_size = 0, 1
+
+        height, width = x.shape[-2], x.shape[-1]
+        y_idx, y_len, y_overlap = self.split_tiles(height, False)
+        x_idx, x_len, x_overlap = self.split_tiles(width, False)
+
+        i_max, j_max = len(y_idx), len(x_idx)
+        num_tiles = i_max * j_max
+        if tile_world_size > num_tiles:
+            # Every rank executes this replicated path. When the canvas has
+            # fewer tiles than ranks, run locally instead of assigning
+            # empty task lists that cannot participate in the tensor gather.
+            tile_rank, tile_world_size = 0, 1
+
+        x_tiles = []
+        for i, (i_pos, i_len) in enumerate(zip(y_idx, y_len)):
+            for j, (j_pos, j_len) in enumerate(zip(x_idx, x_len)):
+                tile = x[..., i_pos : i_pos + i_len, j_pos : j_pos + j_len]
+                x_tiles.append(tile)
+
+        with ClsTokenAggregator(self) as agg:
+            local_tile_indices = self._local_tile_indices(num_tiles, tile_rank, tile_world_size)
+            stack_tiling = self.stack_tiling and not (self.training and getattr(self.encoder, "mask_enabled", False))
+            encoded_tasks = self._run_tile_tasks(x_tiles, local_tile_indices, self.encode, stack_tiling, agg)
+
+            if tile_world_size > 1:
+                all_encoded = self._all_gather_tiled_results(encoded_tasks, num_tiles)
+                if agg.cls_tokens:
+                    agg.cls_tokens = self._all_gather_tiled_results(agg.cls_tokens, num_tiles)
+            else:
+                all_encoded = encoded_tasks
+
+        rows = [[None for _ in range(j_max)] for _ in range(i_max)]
+        for idx, encoded in enumerate(all_encoded):
+            i, j = idx // j_max, idx % j_max
+            rows[i][j] = encoded.to(x.device)
+
+        latent_y_overlap = [tile_overlap // self.vae_ratio for tile_overlap in y_overlap]
+        latent_x_overlap = [tile_overlap // self.vae_ratio for tile_overlap in x_overlap]
+
+        z = self._assemble_tiles(rows, latent_y_overlap, latent_x_overlap)
+
+        return z
+
+    def tiled_decode(self, z):
+        if self.parallel_tiling:  # Fast online decoding for large videos
+            tile_rank, tile_world_size = self._tile_parallel_state()
+        else:
+            tile_rank, tile_world_size = 0, 1
+
+        height, width = (
+            z.shape[-2] * self.vae_ratio,
+            z.shape[-1] * self.vae_ratio,
+        )
+        y_idx, y_len, y_overlap = self.split_tiles(height, True)
+        x_idx, x_len, x_overlap = self.split_tiles(width, True)
+
+        i_max, j_max = len(y_idx), len(x_idx)
+        num_tiles = i_max * j_max
+        if tile_world_size > num_tiles:
+            # See tiled_encode: small canvases fall back to replicated local
+            # tiling so no decode rank is assigned an empty task list.
+            tile_rank, tile_world_size = 0, 1
+
+        z_tiles = []
+        for i, (i_pos, i_len) in enumerate(zip(y_idx, y_len)):
+            i_pos, i_len = (
+                i_pos // self.vae_ratio,
+                i_len // self.vae_ratio,
+            )
+            for j, (j_pos, j_len) in enumerate(zip(x_idx, x_len)):
+                j_pos, j_len = (j_pos // self.vae_ratio, j_len // self.vae_ratio)
+                tile = z[..., i_pos : i_pos + i_len, j_pos : j_pos + j_len]
+                z_tiles.append(tile)
+
+        local_tile_indices = self._local_tile_indices(num_tiles, tile_rank, tile_world_size)
+        stack_tiling = self.stack_tiling and not (self.training and getattr(self.decoder, "mask_enabled", False))
+        decoded_tasks = self._run_tile_tasks(z_tiles, local_tile_indices, self.decode, stack_tiling)
+
+        if tile_world_size > 1:
+            all_decoded = self._all_gather_tiled_results(decoded_tasks, num_tiles)
+        else:
+            all_decoded = decoded_tasks
+
+        rows = [[None for _ in range(j_max)] for _ in range(i_max)]
+        for idx, decoded in enumerate(all_decoded):
+            i, j = idx // j_max, idx % j_max
+            rows[i][j] = decoded.to(z.device)
+
+        dec = self._assemble_tiles(rows, y_overlap, x_overlap)
+        return dec
+
+    def _adaptive_encode(self, x):
+        if self.encoder_tiling:
+            return self.tiled_encode(x)
+        else:
+            return self.encode(x)
+
+    def _adaptive_decode(self, z):
+        if self.decoder_tiling:
+            return self.tiled_decode(z)
+        else:
+            return self.decode(z)
+
+    def trim_code(self, z, target_codes):
+        if target_codes < z.shape[2]:
+            if self.causal_encoder:
+                z = z[:, :, -target_codes:, :, :]
+            else:
+                start_frame = (z.shape[2] - target_codes) // 2
+                z = z[:, :, start_frame : start_frame + target_codes, :, :]
+        return z
+
+    def trim_output(self, dec, target_frames):
+        if target_frames < dec.shape[2]:
+            if self.causal_encoder:  # This is defined by encoder, not decoder
+                dec = dec[:, :, -target_frames:, :, :]
+            else:
+                start_frame = (dec.shape[2] - target_frames) // 2
+                dec = dec[:, :, start_frame : start_frame + target_frames, :, :]
+        return dec
+
+    def encode_temporal(self, x):
+        offset_frame = 1 if self.isolated_first_frame and self.frame_pre_padding == 0 else 0
+
+        frame_num = x.shape[2]
+        pad_size = (offset_frame - frame_num) % self.clip_length
+        padded_frame_num = frame_num + pad_size
+        num_chunks = (padded_frame_num - offset_frame) // self.clip_length
+
+        z_list = []
+        for i in range(num_chunks):
+            start_idx = i * self.clip_length + offset_frame
+            end_idx = (i + 1) * self.clip_length + offset_frame
+            clip_x = x[:, :, start_idx : min(end_idx, frame_num), :, :]
+            if end_idx > frame_num:
+                pad_frames = x[:, :, -1:].expand(-1, -1, end_idx - frame_num, -1, -1)
+                clip_x = torch.cat([clip_x, pad_frames], dim=2)
+
+            if self.isolated_key_frame:
+                key_frame = clip_x[:, :, :1, :, :]
+                z_key = self._adaptive_encode(key_frame)
+
+                if clip_x.shape[2] > 1:
+                    video_frames = clip_x[:, :, 1:, :, :]
+                    z_video = self._adaptive_encode(video_frames)
+                    z = torch.cat([z_key, z_video], dim=2)
+                else:
+                    z = z_key
+            else:
+                z = self._adaptive_encode(clip_x)
+
+            z_list.append(z)
+
+        z = torch.cat(z_list, dim=2)
+        if self.token_drop > 0:
+            z = z[:, :, : -self.token_drop]
+
+        if self.isolated_first_frame:
+            input_first_frame = x[:, :, :1, :, :]
+            z_first_frame = self._adaptive_encode(input_first_frame)
+
+            if self.frame_pre_padding == 0:
+                z = torch.cat([z_first_frame, z], dim=2)
+            else:
+                z = torch.cat([z_first_frame, z[:, :, 1:, :, :]], dim=2)
+
+        if self.isolated_last_frame:
+            last_frame_idx = padded_frame_num - self.frame_drop + offset_frame
+            if last_frame_idx >= frame_num:
+                input_last_frame = x[:, :, -1:, :, :]
+            else:
+                input_last_frame = x[:, :, last_frame_idx : last_frame_idx + 1, :, :]
+            z_last_frame = self._adaptive_encode(input_last_frame)
+            z = torch.cat([z, z_last_frame], dim=2)
+
+        return z
+
+    def _decode_temporal_pad_frames(self, z, pad_tokens):
+        if pad_tokens <= 0:
+            return 0
+        intra_tail = self.clip_length % self.vae_ratio_t
+        if intra_tail == 0:
+            return int(pad_tokens) * int(self.vae_ratio_t)
+
+        z_len_before_pad = z.shape[2] - pad_tokens
+        return sum(
+            (intra_tail if (z_len_before_pad + k) % self.tokens_chunk_size == 0 else self.vae_ratio_t)
+            for k in range(pad_tokens)
+        )
+
+    def _decode_temporal_output_frame_plan(self, z, z_head, z_tail, num_chunks, pad_tokens):
+        chunk_dec = self.tokens_chunk_size * self.vae_ratio_t
+        split_count = int(self.token_drop > 0) + 1
+        total_frames = 0
+        final_overlap_frames = 0
+
+        if z_head is not None:
+            total_frames += 1
+
+        for i in range(num_chunks):
+            t_start_idx = i * self.tokens_chunk_size
+            t_end_idx = t_start_idx + self.tokens_chunk_size + self.token_overlap
+            clip_token_len = max(0, min(t_end_idx, z.shape[2]) - min(t_start_idx, z.shape[2]))
+            if i == 0 and z_head is not None:
+                clip_token_len += z_head.shape[2]
+            if i == num_chunks - 1 and z_tail is not None:
+                clip_token_len += z_tail.shape[2]
+
+            clip_frame_len = clip_token_len * self.vae_ratio_t
+            if i == 0 and z_head is not None:
+                clip_frame_len = max(0, clip_frame_len - self.vae_ratio_t)
+            if i == num_chunks - 1 and z_tail is not None:
+                clip_frame_len = max(0, clip_frame_len - self.vae_ratio_t)
+
+            for j in range(split_count):
+                f_start_idx = j * chunk_dec
+                f_end_idx = min(f_start_idx + chunk_dec, clip_frame_len)
+                chunk_frames = max(0, f_end_idx - f_start_idx - self.frame_pre_padding)
+                if j == 0:
+                    total_frames += chunk_frames
+                else:
+                    final_overlap_frames = chunk_frames
+
+        total_frames += final_overlap_frames
+        if z_tail is not None:
+            total_frames += 1
+
+        pad_frames = self._decode_temporal_pad_frames(z, pad_tokens)
+        return int(total_frames), int(pad_frames), int(total_frames - pad_frames)
+
+    def _decode_temporal_streaming(self, z, z_head, z_tail, num_chunks, pad_tokens, temporal_cat_dtype):
+        total_frames, pad_frames, output_frames = self._decode_temporal_output_frame_plan(
+            z, z_head, z_tail, num_chunks, pad_tokens
+        )
+        if output_frames <= 0:
+            raise ValueError(
+                f"decode_temporal streaming planned non-positive output_frames={output_frames} "
+                f"total_frames={total_frames} pad_frames={pad_frames}"
+            )
+
+        chunk_dec = self.tokens_chunk_size * self.vae_ratio_t
+        split_count = int(self.token_drop > 0) + 1
+        dec = None
+        dec_overlap = None
+        write_pos = 0
+        logical_frames = 0
+        dropped_frames = 0
+        decoded_count = 0
+
+        def write_part(part):
+            nonlocal dec, write_pos, logical_frames, dropped_frames
+            part_frames = int(part.shape[2])
+            if part_frames <= 0:
+                return
+            logical_frames += part_frames
+            if dec is None:
+                out_shape = list(part.shape)
+                out_shape[2] = output_frames
+                dec = torch.empty(out_shape, dtype=part.dtype, device=part.device)
+
+            remaining = int(dec.shape[2]) - write_pos
+            copy_frames = min(part_frames, max(0, remaining))
+            if copy_frames > 0:
+                dec[:, :, write_pos : write_pos + copy_frames, :, :].copy_(part[:, :, :copy_frames, :, :])
+                write_pos += copy_frames
+            dropped_frames += part_frames - copy_frames
+
+        for i in range(num_chunks):
+            t_start_idx = i * self.tokens_chunk_size
+            t_end_idx = t_start_idx + self.tokens_chunk_size + self.token_overlap
+            clip_z = z[:, :, t_start_idx:t_end_idx, :, :]
+
+            if i == 0 and z_head is not None:
+                clip_z = torch.cat([z_head, clip_z], dim=2)
+
+            if i == num_chunks - 1 and z_tail is not None:
+                clip_z = torch.cat([clip_z, z_tail], dim=2)
+
+            clip_dec = self._adaptive_decode(clip_z)
+            decoded_count += 1
+            if temporal_cat_dtype is not None and clip_dec.dtype != temporal_cat_dtype:
+                clip_dec = clip_dec.to(temporal_cat_dtype)
+            if clip_dec.device != z.device:
+                clip_dec = clip_dec.to(z.device)
+
+            dec_tail = None
+            if i == 0 and z_head is not None:
+                write_part(clip_dec[:, :, self.vae_ratio_t - 1 : self.vae_ratio_t, :, :])
+                clip_dec = clip_dec[:, :, self.vae_ratio_t :, :, :]
+
+            if i == num_chunks - 1 and z_tail is not None:
+                dec_tail = clip_dec[:, :, -1:, :, :]
+                clip_dec = clip_dec[:, :, : -self.vae_ratio_t, :, :]
+
+            for j in range(split_count):
+                f_start_idx = j * chunk_dec
+                f_end_idx = min(f_start_idx + chunk_dec, clip_dec.shape[2])
+                clip_dec_chunk = clip_dec[:, :, f_start_idx:f_end_idx, :, :]
+                clip_dec_chunk = clip_dec_chunk[:, :, self.frame_pre_padding :, :, :]
+
+                if j == 0:
+                    if dec_overlap is not None:
+                        clip_dec_chunk = self.blend(dec_overlap, clip_dec_chunk, self.frame_overlap, dim=-3)
+                        dec_overlap = None
+                    write_part(clip_dec_chunk)
+                else:
+                    # Break the view's reference to the full decoded clip so earlier
+                    # temporal chunks can be released before the final output exists.
+                    dec_overlap = clip_dec_chunk.contiguous()
+
+            if i == num_chunks - 1:
+                if dec_overlap is not None:
+                    write_part(dec_overlap)
+                    dec_overlap = None
+                if dec_tail is not None:
+                    write_part(dec_tail)
+
+            del clip_dec, clip_z
+
+        if dec is None:
+            raise RuntimeError("decode_temporal streaming produced no output tensor")
+        if logical_frames != total_frames or dropped_frames != pad_frames or write_pos != output_frames:
+            raise RuntimeError(
+                "decode_temporal streaming frame plan mismatch: "
+                f"logical_frames={logical_frames} total_frames={total_frames} "
+                f"dropped_frames={dropped_frames} pad_frames={pad_frames} "
+                f"write_pos={write_pos} output_frames={output_frames}"
+            )
+
+        return dec
+
+    def decode_temporal(self, z):
+        chunk_dec = self.tokens_chunk_size * self.vae_ratio_t
+
+        isolated_token_num = 0
+        if self.isolated_first_frame and self.frame_pre_padding == 0:
+            isolated_token_num = isolated_token_num + 1
+        if self.isolated_last_frame:
+            isolated_token_num = isolated_token_num + 1
+
+        pseudo_total_tokens = z.shape[2] - isolated_token_num + self.token_drop
+
+        pad_tokens = 0
+        remainder = pseudo_total_tokens % self.tokens_chunk_size
+        if remainder != 0:
+            if self.training:
+                raise ValueError(f"Temporal token length {z.shape[2]} is wrong!")
+            else:
+                pad_tokens = self.tokens_chunk_size - remainder
+                pseudo_total_tokens = pseudo_total_tokens + pad_tokens
+
+        pseudo_num_chunks = pseudo_total_tokens // self.tokens_chunk_size
+        num_chunks = pseudo_num_chunks - int(self.token_drop > 0)
+
+        z_head = None
+        if self.isolated_first_frame and self.frame_pre_padding == 0:
+            z_head = z[:, :, :1, :, :]
+            z = z[:, :, 1:, :, :]
+
+        z_tail = None
+        if self.isolated_last_frame:
+            z_tail = z[:, :, -1:, :, :]
+            z = z[:, :, :-1, :, :]
+
+        if pad_tokens > 0:
+            pad_z = z[:, :, -1:, :, :].expand(-1, -1, pad_tokens, -1, -1)
+            z = torch.cat([z, pad_z], dim=2)
+
+        temporal_cat_dtype = _resolve_temporal_cat_dtype()
+        if not self.training and _resolve_temporal_stream_cat():
+            return self._decode_temporal_streaming(z, z_head, z_tail, num_chunks, pad_tokens, temporal_cat_dtype)
+
+        decoded_tasks = []
+        for i in range(num_chunks):
+            t_start_idx = i * self.tokens_chunk_size
+            t_end_idx = t_start_idx + self.tokens_chunk_size + self.token_overlap
+            clip_z = z[:, :, t_start_idx:t_end_idx, :, :]
+
+            if i == 0 and z_head is not None:
+                clip_z = torch.cat([z_head, clip_z], dim=2)
+
+            if i == num_chunks - 1 and z_tail is not None:
+                clip_z = torch.cat([clip_z, z_tail], dim=2)
+
+            clip_dec = self._adaptive_decode(clip_z)
+            if temporal_cat_dtype is not None and clip_dec.dtype != temporal_cat_dtype:
+                clip_dec = clip_dec.to(temporal_cat_dtype)
+
+            decoded_tasks.append((i, clip_dec))
+
+        clip_dec_list = [clip_dec.to(z.device) for _, clip_dec in decoded_tasks]
+
+        dec_list = []
+        dec_overlap = None
+
+        dec_head = None
+        if z_head is not None:
+            dec_head = clip_dec_list[0][:, :, self.vae_ratio_t - 1 : self.vae_ratio_t, :, :]
+            clip_dec_list[0] = clip_dec_list[0][:, :, self.vae_ratio_t :, :, :]
+
+        dec_tail = None
+        if z_tail is not None:
+            dec_tail = clip_dec_list[-1][:, :, -1:, :, :]
+            clip_dec_list[-1] = clip_dec_list[-1][:, :, : -self.vae_ratio_t, :, :]
+
+        if dec_head is not None:
+            dec_list.append(dec_head)
+
+        for i in range(num_chunks):
+            for j in range(int(self.token_drop > 0) + 1):
+                clip_dec = clip_dec_list[i]
+
+                f_start_idx = j * chunk_dec
+                f_end_idx = min(f_start_idx + chunk_dec, clip_dec.shape[2])
+                clip_dec_chunk = clip_dec[:, :, f_start_idx:f_end_idx, :, :]
+                clip_dec_chunk = clip_dec_chunk[:, :, self.frame_pre_padding :, :, :]
+
+                if j == 0:
+                    if dec_overlap is not None:
+                        clip_dec_chunk = self.blend(dec_overlap, clip_dec_chunk, self.frame_overlap, dim=-3)
+                    dec_list.append(clip_dec_chunk)
+                else:
+                    dec_overlap = clip_dec_chunk
+
+        if dec_overlap is not None:
+            dec_list.append(dec_overlap)
+
+        if dec_tail is not None:
+            dec_list.append(dec_tail)
+
+        dec = torch.cat(dec_list, dim=2)
+
+        pad_frames = self._decode_temporal_pad_frames(z, pad_tokens)
+        if pad_frames > 0:
+            dec = dec[:, :, :-pad_frames, :, :]
+
+        return dec
+
+    def decode_base(self, z, frame_num=None, process_image=False):
+        if process_image or not self.use_3d_conv:
+            if not self.use_3d_conv and z.ndim == 5:
+                z = z.squeeze(2)
+
+            recon = self._adaptive_decode(z)
+        else:
+            recon = self.decode_temporal(z)
+
+        if self.use_3d_conv:
+            if frame_num is not None:
+                target_frames = frame_num
+            else:
+                target_frames = recon.shape[2]
+
+            recon = self.trim_output(recon, target_frames)
+            if process_image:
+                recon = recon.squeeze(2)
+
+        return recon
+
+    #########################################################
+    # following methods are for inference
+    #########################################################
+
+    @torch.no_grad()
+    def encode_images(
+        self,
+        images: Union[List[np.ndarray], List[torch.Tensor]],
+        transform_input: bool = False,
+        use_fp16_latent: bool = False,
+        verbose: bool = False,
+    ) -> List[torch.Tensor]:
+        """encode images into latents
+
+        Args:
+            images (Union[List[np.ndarray], List[torch.Tensor]]):
+                List of images, single input will be wrapped in a list.
+                If input is a list of np.ndarray, it should be in shape B * (H, W, 3), dtype uint8.
+                If input is a list of torch.Tensor, it should be in shape B * (3, H, W), dtype float32.
+            transform_input (bool, optional):
+                Whether to transform input using ImageNet std/mean. Defaults to False.
+                If input is a list of np.ndarray, it will always be set to True.
+            use_fp16_latent (bool, optional):
+                Whether to use fp16 latent. Defaults to False.
+            verbose (bool, optional):
+                Whether to print debug information. Defaults to False.
+
+        Returns:
+            List[torch.Tensor]:
+                List of image latents.
+                If self.use_3d_conv is True, it should be in shape B * (D, 1, H', W').
+                Otherwise, it should be in shape B * (D, H', W').
+        """
+
+        images = self.processor._ensure_list(images)
+        runtime_owned = False
+
+        if isinstance(images[0], Image.Image):
+            images = [np.array(image) for image in images]
+
+        if isinstance(images[0], np.ndarray):
+            device = next(self.parameters()).device
+            images = self.processor.convert_numpy_to_tensor(images, device)
+            images = torch.split(images, 1, dim=0)
+            transform_input = True
+            runtime_owned = True
+
+        if transform_input:
+            images = [image.unsqueeze(0) if image.ndim == 3 else image for image in images]
+            images = [self.processor.transform_tensor(image, runtime_owned=runtime_owned) for image in images]
+
+        prepared = []
+        for image_tensor in images:
+            if image_tensor.ndim == 3:
+                image_tensor = image_tensor.unsqueeze(0)
+            _, _, h, w = image_tensor.shape
+            new_h, new_w = self.processor._align_to_total_patch_size(h, w)
+            image_tensor = self.processor._crop_to_align(image_tensor, new_h, new_w)
+            prepared.append(image_tensor)
+
+        if len(prepared) > 1 and len(set(t.shape for t in prepared)) == 1:
+            stacked = torch.cat(prepared, dim=0)
+            if verbose:
+                logger.info(f"batch encode input shape {tuple(stacked.shape)}")
+            all_latents = self.encode_base(stacked, True)
+            image_latents = [all_latents[i].contiguous() for i in range(all_latents.shape[0])]
+        else:
+            image_latents = []
+            for image_tensor in prepared:
+                if verbose:
+                    logger.info(f"input shape {tuple(image_tensor.shape)}")
+                image_latent = self.encode_base(image_tensor, True)
+                image_latents.append(image_latent.squeeze(0).contiguous())
+
+        if use_fp16_latent:
+            image_latents = [lat.to(torch.float16) for lat in image_latents]
+
+        if verbose:
+            for lat in image_latents:
+                logger.info(f"image latent shape {tuple(lat.shape)}")
+
+        return image_latents
+
+    @torch.no_grad()
+    def encode_videos(
+        self,
+        videos: Union[List[np.ndarray], List[torch.Tensor]],
+        transform_input: bool = False,
+        use_fp16_latent: bool = False,
+        verbose: bool = False,
+        encode_prefix: bool = False,
+    ) -> List[torch.Tensor]:
+        """encode videos into latents
+
+        Args:
+            videos (Union[List[np.ndarray], List[torch.Tensor]]):
+                List of videos, single input will be wrapped in a list.
+                If input is a list of np.ndarray, it should be in shape B * (T, H, W, 3), dtype uint8.
+                If input is a list of torch.Tensor, it should be in shape B * (3, T, H, W), dtype float32.
+            transform_input (bool, optional):
+                Whether to transform input using ImageNet std/mean. Defaults to False.
+                If input is a list of np.ndarray, it will always be set to True.
+            use_fp16_latent (bool, optional):
+                Whether to use fp16 latent. Defaults to False.
+            verbose (bool, optional):
+                Whether to print debug information. Defaults to False.
+            encode_prefix (bool, optional):
+                Continuation (prefix) mode: prepend normalized
+                black frames to token alignment, append black frames to chunk
+                alignment, encode with token_drop disabled, then discard only
+                the trailing padding tokens. Returns both latents and leading
+                pad-frame counts. Defaults to False.
+
+        Returns:
+            List[torch.Tensor]:
+                List of video latents, shape B * (D, T', H', W').
+                With encode_prefix=True, returns
+                (List[torch.Tensor], List[int]).
+        """
+
+        videos = self.processor._ensure_list(videos)
+        runtime_owned = False
+
+        if isinstance(videos[0], np.ndarray):
+            device = next(self.parameters()).device
+            videos = [self.processor.convert_numpy_to_tensor(video, device) for video in videos]
+            transform_input = True
+            runtime_owned = True
+
+        if transform_input:
+            videos = [self.processor.transform_tensor(video, runtime_owned=runtime_owned) for video in videos]
+            videos = [video.transpose(0, 1) for video in videos]
+
+        if encode_prefix:
+            if self.isolated_last_frame:
+                raise ValueError("encode_prefix does not support isolated_last_frame")
+
+            video_latents = []
+            prefix_pad_frames = []
+            for video in videos:
+                if video.ndim == 4:
+                    video = video.unsqueeze(0)
+                _, _, _, h, w = video.shape
+                new_h, new_w = self.processor._align_to_total_patch_size(h, w)
+                video = self.processor._crop_to_align(video, new_h, new_w, is_video=True)
+
+                model_alignment = (
+                    self.token_drop,
+                    self.frame_drop,
+                    self.token_overlap,
+                    self.frame_overlap,
+                )
+                processor_alignment = (
+                    self.processor.token_overlap,
+                    self.processor.frame_overlap,
+                )
+                self.token_drop = 0
+                self.frame_drop = 0
+                self.token_overlap = 0
+                self.frame_overlap = 0
+                self.processor.token_overlap = 0
+                self.processor.frame_overlap = 0
+                try:
+                    orig_frames = video.shape[2]
+                    leading, trailing, drop_tokens = self.processor.align_video_length_2pass(orig_frames)
+                    _, _, _, cropped_h, cropped_w = video.shape
+                    if leading > 0:
+                        black = self.processor.transform(video.new_zeros(leading, 3, cropped_h, cropped_w))
+                        black = black.unsqueeze(0).permute(0, 2, 1, 3, 4)
+                        video = torch.cat([black, video], dim=2)
+                    if trailing > 0:
+                        black = self.processor.transform(video.new_zeros(trailing, 3, cropped_h, cropped_w))
+                        black = black.unsqueeze(0).permute(0, 2, 1, 3, 4)
+                        video = torch.cat([video, black], dim=2)
+
+                    if verbose:
+                        logger.info(
+                            f"[encode_prefix] {orig_frames} frames -> "
+                            f"pad leading={leading}, trailing={trailing} -> "
+                            f"{video.shape[2]} frames"
+                        )
+
+                    video_latent = self.encode_base(video, False)
+                    if drop_tokens > 0:
+                        video_latent = video_latent[:, :, :-drop_tokens, :, :]
+                    prefix_pad_frames.append(leading)
+                finally:
+                    (
+                        self.token_drop,
+                        self.frame_drop,
+                        self.token_overlap,
+                        self.frame_overlap,
+                    ) = model_alignment
+                    (
+                        self.processor.token_overlap,
+                        self.processor.frame_overlap,
+                    ) = processor_alignment
+
+                video_latents.append(video_latent.squeeze(0).contiguous())
+
+            if use_fp16_latent:
+                video_latents = [lat.to(torch.float16) for lat in video_latents]
+            if verbose:
+                for latent in video_latents:
+                    logger.info(f"video latent shape {tuple(latent.shape)}")
+            return video_latents, prefix_pad_frames
+
+        prepared = []
+        for video in videos:
+            if video.ndim == 4:
+                video = video.unsqueeze(0)
+            used_frame_length = self.processor.get_suitable_video_length(video.shape[2], verbose)
+            _, _, _, h, w = video.shape
+            new_h, new_w = self.processor._align_to_total_patch_size(h, w)
+            video = video[:, :, :used_frame_length, :, :]
+            video = self.processor._crop_to_align(video, new_h, new_w, is_video=True)
+            prepared.append(video)
+
+        if len(prepared) > 1 and len(set(t.shape for t in prepared)) == 1:
+            stacked = torch.cat(prepared, dim=0)
+            if verbose:
+                logger.info(f"batch encode input shape {tuple(stacked.shape)}")
+            all_latents = self.encode_base(stacked, False)
+            video_latents = [all_latents[i].contiguous() for i in range(all_latents.shape[0])]
+        else:
+            video_latents = []
+            for video in prepared:
+                if verbose:
+                    logger.info(f"input shape {tuple(video.shape)}")
+                video_latent = self.encode_base(video, False)
+                video_latents.append(video_latent.squeeze(0).contiguous())
+
+        if use_fp16_latent:
+            video_latents = [lat.to(torch.float16) for lat in video_latents]
+
+        if verbose:
+            for lat in video_latents:
+                logger.info(f"video latent shape {tuple(lat.shape)}")
+
+        return video_latents
+
+
+# ============================================================================
+# Legacy CNN VAE
+# ============================================================================
+
+
+class AutoencoderKLLegacy(AutoencoderKL):
+    r"""
+    A VAE model (legacy CNN-based) for encoding pixels into latents and decoding latent representations into pixels.
+    """
+
+    @register_to_config
+    def __init__(
+        self,
+        in_channels=3,
+        out_ch=3,
+        ch=128,
+        embed_dim=16,
+        z_channels=16,
+        use_3d_conv=False,
+        # cnn vae
+        zq_ch_encoder=None,
+        zq_ch_decoder=None,
+        num_res_blocks=2,
+        num_res_blocks_decoder=None,
+        ch_mult=[1, 2, 2, 4, 4, 8],
+        space_down=[2, 2, 2, 2, 1, 1],
+        space_up=[1, 2, 2, 2, 2, 1],
+        time_down=None,
+        time_up=None,
+        padding_mode="zeros",
+        padding_mode_t=None,
+        use_t_isolated_gn=False,
+        causal_encoder=True,
+        causal_decoder=True,
+        use_vit_decoder=False,
+        vit_decoder_kwargs=None,
+        # stats
+        shift_factor=0.0,
+        scaling_factor=1.0,
+        # pixel normalization
+        pixel_norm_type="imagenet",
+        # others
+        **kwargs,
+    ):
+        ModelMixin.__init__(self)  # NOTE: avoid wrong @register_to_config
+
+        if not use_3d_conv or not use_vit_decoder:
+            raise NotImplementedError("this release only supports use_3d_conv=True with use_vit_decoder=True")
+
+        self.transform = get_normalize_transform(pixel_norm_type)
+        self.transform_rev = get_denormalize_transform(pixel_norm_type)
+
+        self.use_3d_conv = use_3d_conv
+        self.causal_encoder = causal_encoder
+        self.causal_decoder = causal_decoder
+        self.slidedec = self.causal_encoder and not self.causal_decoder
+
+        # some registered parameters for simplicity
+        self.vae_ratio = int(np.cumprod(space_down)[-1])
+        self.vae_ratio_t = int(np.cumprod(time_down)[-1]) if time_down else 1
+        self.config["vae_ratio"] = self.vae_ratio
+        self.config["vae_ratio_t"] = self.vae_ratio_t
+
+        # Configure inference-time chunking and tiling.
+        self.setup_forward(**kwargs)
+
+        # init encoder
+        encoder_config = {
+            "double_z": True,
+            "z_channels": z_channels,
+            "zq_ch": zq_ch_encoder,
+            "in_channels": in_channels,
+            "ch": ch,
+            "num_res_blocks": num_res_blocks,
+            "ch_mult": ch_mult,
+            "space_down": space_down,
+            "time_down": time_down,
+            "padding_mode": padding_mode,
+            "padding_mode_t": padding_mode_t,
+            "causal": causal_encoder,
+            "use_t_isolated_gn": use_t_isolated_gn,
+        }
+        self.encoder = EncoderFCN3D(**encoder_config)
+
+        # init pointwise quant/post_quant conv
+        self.quant_conv = nn.Conv3d(z_channels * 2, 2 * embed_dim, 1)
+        self.post_quant_conv = nn.Conv3d(embed_dim, z_channels, 1)
+
+        self.use_vit_decoder = use_vit_decoder
+
+        # init decoder
+        vit_kwargs = {
+            "patch_size": self.vae_ratio,
+            "in_channels": z_channels,
+            "out_channels": out_ch,
+            **(vit_decoder_kwargs or {}),
+        }
+        vit_kwargs.setdefault("patch_size_t", self.vae_ratio_t)
+        vit_kwargs.setdefault("t_causal", causal_decoder)
+        self.decoder = ViT3DDecoder(**vit_kwargs)
+
+    @torch.no_grad()
+    def encode(self, x):
+        return self.quant_conv(self.encoder(x))
+
+    @torch.no_grad()
+    def decode(self, z):
+        z2 = self.post_quant_conv(z)
+        if self.use_vit_decoder:
+            return self.decoder(z2)
+        return self.decoder(z2, z)
+
+    def encode_base(self, input, process_image=False):
+        if self.use_3d_conv and input.ndim == 4:
+            input = input.unsqueeze(2)
+
+        if process_image or not self.use_3d_conv:
+            moments = self._adaptive_encode(input)
+        else:
+            moments = self.encode_temporal(input)
+
+        z = DiagonalGaussianDistribution(moments).sample()
+
+        if process_image and self.use_3d_conv:
+            z = self.trim_code(z, 1)
+
+        return z
diff --git a/telefuser/models/minimax_h3_video/norm.py b/telefuser/models/minimax_h3_video/norm.py
new file mode 100644
index 00000000..f39a242b
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/norm.py
@@ -0,0 +1,247 @@
+# SPDX-License-Identifier: Apache-2.0
+# Torch-native normalization for the MiniMax H3 visual VAE.
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .conv import BaseConv3d
+
+
+def _validate_activation(activation):
+    valid_activations = {"identity", "silu", "relu"}
+    if activation not in valid_activations:
+        raise ValueError(f"Unsupported activation: {activation}. Supported: {valid_activations}")
+
+
+def _apply_activation(x, activation):
+    _validate_activation(activation)
+    if activation == "identity":
+        return x
+    if activation == "silu":
+        return F.silu(x)
+    return F.relu(x)
+
+
+def _merge_time_to_batch(x):
+    batch, channels, depth, height, width = x.shape
+    return x.permute(0, 2, 1, 3, 4).contiguous().view(batch * depth, channels, 1, height, width)
+
+
+def _split_time_from_batch(x, batch):
+    batch_depth, channels, _, height, width = x.shape
+    depth = batch_depth // batch
+    return x.view(batch, depth, channels, height, width).permute(0, 2, 1, 3, 4).contiguous()
+
+
+def fused_group_norm(x, num_groups, weight, bias, eps=1e-5, activation="silu"):
+    out = F.group_norm(x, num_groups, weight=weight, bias=bias, eps=eps)
+    return _apply_activation(out, activation)
+
+
+def fused_spatial_norm(
+    f,
+    num_groups,
+    norm_weight,
+    norm_bias,
+    dynamic_scale,
+    dynamic_bias,
+    eps=1e-5,
+    activation="silu",
+):
+    norm_f = F.group_norm(
+        f,
+        num_groups,
+        weight=norm_weight,
+        bias=norm_bias,
+        eps=eps,
+    )
+    out = norm_f * dynamic_scale + dynamic_bias
+    return _apply_activation(out, activation)
+
+
+class DummyAffine(torch.nn.Module):
+    def __init__(self, num_channels, affine=True):
+        super().__init__()
+        if affine:
+            self.weight = torch.nn.Parameter(torch.ones(num_channels))
+            self.bias = torch.nn.Parameter(torch.zeros(num_channels))
+        else:
+            self.register_parameter("weight", None)
+            self.register_parameter("bias", None)
+
+    def forward(self, input):
+        if self.weight is None:
+            return input
+        shape = [1, -1] + [1] * (input.dim() - 2)
+        return input * self.weight.view(*shape) + self.bias.view(*shape)
+
+
+class FusedGroupNorm3D(torch.nn.Module):
+    """Compatibility wrapper implemented with native PyTorch ops."""
+
+    def __init__(
+        self,
+        num_groups,
+        num_channels,
+        eps=1e-5,
+        affine=True,
+        activation="silu",
+        cond_channels=None,
+        use_t_isolated_gn=False,
+        padding_mode="zeros",
+        padding_mode_t=None,
+        causal=True,
+    ):
+        super().__init__()
+        _validate_activation(activation)
+        self.num_groups = num_groups
+        self.num_channels = num_channels
+        self.eps = eps
+        self.affine = affine
+        self.activation = activation
+        self.use_t_isolated_gn = use_t_isolated_gn
+
+        if cond_channels is not None:
+            self.use_spatial_affine = True
+            self.norm_layer = DummyAffine(num_channels, affine=affine)
+            self.conv_y = BaseConv3d(
+                cond_channels,
+                num_channels,
+                kernel_size=1,
+                padding_mode=padding_mode,
+                padding_mode_t=padding_mode_t,
+                causal=causal,
+            )
+            self.conv_b = BaseConv3d(
+                cond_channels,
+                num_channels,
+                kernel_size=1,
+                padding_mode=padding_mode,
+                padding_mode_t=padding_mode_t,
+                causal=causal,
+            )
+        else:
+            self.use_spatial_affine = False
+            if self.affine:
+                self.weight = torch.nn.Parameter(torch.ones(num_channels))
+                self.bias = torch.nn.Parameter(torch.zeros(num_channels))
+            else:
+                self.register_parameter("weight", None)
+                self.register_parameter("bias", None)
+
+    def forward(self, f, cond=None):
+        need_reshape = self.use_t_isolated_gn and f.dim() == 5
+        batch = f.shape[0] if need_reshape else None
+        f_size = f.shape[-3:]
+        if need_reshape:
+            f = _merge_time_to_batch(f)
+
+        if self.use_spatial_affine:
+            scale = self.conv_y(cond)
+            bias = self.conv_b(cond)
+            if math.prod(scale.shape[-3:]) * math.prod(bias.shape[-3:]) > 1:
+                scale = F.interpolate(scale, size=f_size, mode="nearest")
+                bias = F.interpolate(bias, size=f_size, mode="nearest")
+            if need_reshape:
+                scale = _merge_time_to_batch(scale)
+                bias = _merge_time_to_batch(bias)
+            out = fused_spatial_norm(
+                f,
+                self.num_groups,
+                self.norm_layer.weight,
+                self.norm_layer.bias,
+                scale,
+                bias,
+                self.eps,
+                self.activation,
+            )
+        else:
+            if cond is not None:
+                raise NotImplementedError("Dynamic affine is not defined")
+            weight = self.weight if self.affine else None
+            bias = self.bias if self.affine else None
+            out = fused_group_norm(f, self.num_groups, weight, bias, self.eps, self.activation)
+
+        if need_reshape:
+            out = _split_time_from_batch(out, batch)
+        return out
+
+
+class TemporalIsolatedGroupNorm(nn.GroupNorm):
+    def forward(self, input):
+        if input.dim() == 5:
+            batch = input.shape[0]
+            input = _merge_time_to_batch(input)
+            output = super().forward(input)
+            return _split_time_from_batch(output, batch)
+        return super().forward(input)
+
+
+class SpatialNorm3D(nn.Module):
+    def __init__(
+        self,
+        f_channels,
+        zq_channels,
+        padding_mode="zeros",
+        padding_mode_t=None,
+        causal=True,
+        use_t_isolated_gn=False,
+    ):
+        super().__init__()
+        norm_cls = TemporalIsolatedGroupNorm if use_t_isolated_gn else nn.GroupNorm
+        self.norm_layer = norm_cls(num_groups=32, num_channels=f_channels, eps=1e-6, affine=True)
+
+        self.conv_y = BaseConv3d(
+            zq_channels,
+            f_channels,
+            kernel_size=1,
+            padding_mode=padding_mode,
+            padding_mode_t=padding_mode_t,
+            causal=causal,
+        )
+        self.conv_b = BaseConv3d(
+            zq_channels,
+            f_channels,
+            kernel_size=1,
+            padding_mode=padding_mode,
+            padding_mode_t=padding_mode_t,
+            causal=causal,
+        )
+
+    def forward(self, f, zq):
+        f_size = f.shape[-3:]
+        norm_f = self.norm_layer(f)
+        scale = self.conv_y(zq)
+        bias = self.conv_b(zq)
+
+        if math.prod(scale.shape[-3:]) * math.prod(bias.shape[-3:]) > 1:
+            scale = F.interpolate(scale, size=f_size, mode="nearest")
+            bias = F.interpolate(bias, size=f_size, mode="nearest")
+
+        return norm_f * scale + bias
+
+
+def get_spatial_norm_3d(
+    num_channels,
+    cond_channels,
+    *,
+    padding_mode="zeros",
+    padding_mode_t=None,
+    causal=True,
+    use_t_isolated_gn=False,
+):
+    return SpatialNorm3D(
+        num_channels,
+        cond_channels,
+        padding_mode=padding_mode,
+        padding_mode_t=padding_mode_t,
+        causal=causal,
+        use_t_isolated_gn=use_t_isolated_gn,
+    )
+
+
+def get_group_norm_3d(num_channels, use_t_isolated_gn=False):
+    norm_cls = TemporalIsolatedGroupNorm if use_t_isolated_gn else nn.GroupNorm
+    return norm_cls(num_groups=32, num_channels=num_channels, eps=1e-6, affine=True)
diff --git a/telefuser/models/minimax_h3_video/processor.py b/telefuser/models/minimax_h3_video/processor.py
new file mode 100644
index 00000000..467d0729
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/processor.py
@@ -0,0 +1,254 @@
+# SPDX-License-Identifier: Apache-2.0
+# Tensor pre/post-processing for the MiniMax H3 visual VAE.
+import math
+from typing import Tuple
+
+import numpy as np
+import torch
+from diffusers.utils import logging
+from einops import rearrange
+from torchvision.transforms import Normalize
+
+NORM_CONFIGS = {
+    "imagenet": {
+        "mean": (0.485, 0.456, 0.406),
+        "std": (0.229, 0.224, 0.225),
+    },
+    "simple": {
+        "mean": (0.5, 0.5, 0.5),
+        "std": (0.5, 0.5, 0.5),
+    },
+    "raw": {
+        "mean": (0.0, 0.0, 0.0),
+        "std": (1.0, 1.0, 1.0),
+    },
+}
+
+
+def get_norm_constants(
+    norm_type: str = "imagenet",
+) -> Tuple[Tuple[float, ...], Tuple[float, ...]]:
+    if norm_type not in NORM_CONFIGS:
+        raise ValueError(f"Unknown norm_type: {norm_type}. Must be one of {list(NORM_CONFIGS.keys())}")
+    config = NORM_CONFIGS[norm_type]
+    return config["mean"], config["std"]
+
+
+def get_normalize_transform(norm_type: str = "imagenet", *, inplace: bool = False) -> Normalize:
+    mean, std = get_norm_constants(norm_type)
+    return Normalize(mean, std, inplace=inplace)
+
+
+def get_denormalize_transform(norm_type: str = "imagenet") -> Normalize:
+    mean, std = get_norm_constants(norm_type)
+    inv_mean = tuple(-m / s for m, s in zip(mean, std))
+    inv_std = tuple(1.0 / s for s in std)
+    return Normalize(inv_mean, inv_std)
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+class VAEProcessor:
+    def __init__(
+        self,
+        *,
+        vae_ratio,
+        vae_ratio_t,
+        clip_length,
+        frame_overlap,
+        token_overlap,
+        tokens_chunk_size,
+        isolated_last_frame,
+        latent_patch_size,
+        crop_mode,
+        pixel_norm_type="imagenet",
+        transform=None,
+        transform_rev=None,
+        use_3d_conv=False,
+    ):
+        self.vae_ratio = vae_ratio
+        self.vae_ratio_t = vae_ratio_t
+        self.clip_length = clip_length
+        self.frame_overlap = frame_overlap
+        self.token_overlap = token_overlap
+        self.tokens_chunk_size = tokens_chunk_size
+        self.isolated_last_frame = isolated_last_frame
+        self.latent_patch_size = latent_patch_size
+        self.crop_mode = crop_mode
+        self.transform = transform or get_normalize_transform(pixel_norm_type)
+        self._runtime_owned_transform = (
+            get_normalize_transform(pixel_norm_type, inplace=True) if transform is None else None
+        )
+        self.transform_rev = transform_rev or get_denormalize_transform(pixel_norm_type)
+        self.use_3d_conv = use_3d_conv
+
+    def _ensure_list(self, data):
+        return data if isinstance(data, list) else [data]
+
+    def _align_to_total_patch_size(self, h, w):
+        total_patch_size = self.latent_patch_size * self.vae_ratio
+        new_h = (h // total_patch_size) * total_patch_size
+        new_w = (w // total_patch_size) * total_patch_size
+        return new_h, new_w
+
+    def _crop_to_align(self, tensor, new_h, new_w, is_video=False):
+        if is_video:
+            _, _, _, h, w = tensor.shape
+        else:
+            _, _, h, w = tensor.shape
+
+        if self.crop_mode == "center":
+            top = (h - new_h) // 2
+            left = (w - new_w) // 2
+        else:
+            top = 0
+            left = 0
+
+        if is_video:
+            return tensor[:, :, :, top : top + new_h, left : left + new_w]
+        else:
+            return tensor[:, :, top : top + new_h, left : left + new_w]
+
+    def _align_target_token(self, T, mode):
+        intra_tail = self.clip_length % self.vae_ratio_t
+        min_frames = intra_tail or self.vae_ratio_t
+        full_chunks = T // self.clip_length
+        remainder = T % self.clip_length
+
+        if remainder == 0:
+            return max(T, min_frames)
+
+        if mode == "pad":
+            aligned_r = math.ceil((remainder - intra_tail) / self.vae_ratio_t) * self.vae_ratio_t + intra_tail
+            if aligned_r > self.clip_length:
+                return (full_chunks + 1) * self.clip_length + intra_tail
+            return full_chunks * self.clip_length + aligned_r
+        else:  # trim
+            k = (remainder - intra_tail) // self.vae_ratio_t
+            if k >= 0:
+                target = full_chunks * self.clip_length + k * self.vae_ratio_t + intra_tail
+                return max(target, min_frames)
+            elif full_chunks > 0:
+                return full_chunks * self.clip_length
+            else:
+                return min_frames
+
+    def _align_target(self, T, mode, granularity):
+        if granularity == "chunk":
+            step = self.clip_length
+            tail = self.frame_overlap
+            if self.isolated_last_frame:
+                tail += 1
+
+            k = math.ceil((T - tail) / step) if mode == "pad" else (T - tail) // step
+            return max(k, 1) * step + tail
+
+        isolated_extra = 1 if self.isolated_last_frame else 0
+        return self._align_target_token(T - isolated_extra, mode) + isolated_extra
+
+    def align_video_length(self, video_length, mode="pad", granularity="chunk"):
+        target = self._align_target(video_length, mode, granularity)
+        delta = target - video_length
+        if delta > 0 and mode == "trim":
+            raise ValueError(
+                f"Cannot trim {video_length} frames to valid length {target}: "
+                f"not enough frames (granularity={granularity})"
+            )
+        return delta
+
+    def align_video_length_2pass(self, video_length):
+        """Return the leading/trailing frame pads and trailing latent drop.
+
+        This is the continuation-prefix (2-pass) alignment.  The caller temporarily disables the model's normal token
+        drop and keeps these mirrored processor fields at zero.
+        """
+        if self.isolated_last_frame:
+            raise ValueError("align_video_length_2pass does not support isolated_last_frame")
+        if self.token_overlap != 0 or self.frame_overlap != 0:
+            raise ValueError("align_video_length_2pass requires token_drop=0 alignment")
+
+        leading = self.align_video_length(video_length, mode="pad", granularity="token")
+        token_aligned = video_length + leading
+        trailing = self.align_video_length(token_aligned, mode="pad", granularity="chunk")
+
+        if trailing > 0:
+            intra_tail = self.clip_length % self.vae_ratio_t
+            full_chunks = token_aligned // self.clip_length
+            remainder = token_aligned % self.clip_length
+            real_tokens = full_chunks * self.tokens_chunk_size
+            if remainder > 0:
+                real_tokens += (remainder - intra_tail) // self.vae_ratio_t + 1
+            drop_tokens = self.get_latent_length(token_aligned + trailing) - real_tokens
+        else:
+            drop_tokens = 0
+
+        return leading, trailing, drop_tokens
+
+    def get_suitable_video_length(self, video_length, verbose=False):
+        used_frame_length = video_length + self.align_video_length(video_length, mode="trim", granularity="chunk")
+        if verbose:
+            logger.info(f"Pick first {used_frame_length} frames from {video_length}-frame video")
+        return used_frame_length
+
+    def get_latent_length(self, video_length):
+        tail_frame = self.frame_overlap
+        tail_token = self.token_overlap
+        if self.isolated_last_frame:
+            tail_frame += 1
+            tail_token += 1
+
+        video_length = self.get_suitable_video_length(video_length)
+        latent_length = int((video_length - tail_frame) // self.clip_length) * self.tokens_chunk_size + tail_token
+        return latent_length
+
+    def transform_tensor(self, tensor, *, runtime_owned=False):
+        B, T = None, None
+        if tensor.ndim == 5:
+            if tensor.shape[2] == 3:
+                tensor = tensor.transpose(1, 2)
+            B, _, T, _, _ = tensor.shape
+            tensor = rearrange(tensor, "b c t h w -> (b t) c h w")
+        elif tensor.ndim == 4:
+            if tensor.shape[0] == 3:
+                tensor = tensor.transpose(0, 1)
+        elif tensor.ndim == 3:
+            tensor = tensor.unsqueeze(0)
+        else:
+            raise ValueError(f"Unsupported tensor shape: {tensor.shape}")
+
+        transform = (
+            self._runtime_owned_transform
+            if runtime_owned and self._runtime_owned_transform is not None
+            else self.transform
+        )
+        tensor = transform(tensor)
+
+        if B is not None and T is not None:
+            tensor = rearrange(tensor, "(b t) c h w -> b c t h w", b=B, t=T)
+
+        return tensor.contiguous()
+
+    def revert_tensor(self, tensor):
+        B, T = None, None
+        if self.use_3d_conv:
+            tensor = tensor.unsqueeze(2) if tensor.ndim == 4 else tensor
+            B, _, T, _, _ = tensor.shape
+            tensor = rearrange(tensor, "b c t h w -> (b t) c h w")
+        tensor_rev = self.transform_rev(tensor).clamp_(0, 1)
+        if B is not None:
+            tensor_rev = rearrange(tensor_rev, "(b t) c h w -> b c t h w", b=B, t=T)
+        return tensor_rev.contiguous()
+
+    @staticmethod
+    def convert_numpy_to_tensor(numpy_array, device=None):
+        if isinstance(numpy_array, list):
+            numpy_array = np.stack(numpy_array, axis=0)
+        tensor = torch.from_numpy(numpy_array)
+        # Keep decoded uint8 pixels compact across the host-to-device copy.
+        # Casting the full video on CPU quadruples both the temporary host
+        # allocation and transfer volume for no loss of information.
+        if device is not None:
+            tensor = tensor.to(device)
+        tensor = tensor.permute(0, 3, 1, 2)
+        return tensor.to(torch.float32).div_(255.0)
diff --git a/telefuser/models/minimax_h3_video/vae_cnn.py b/telefuser/models/minimax_h3_video/vae_cnn.py
new file mode 100644
index 00000000..6c40907c
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/vae_cnn.py
@@ -0,0 +1,262 @@
+# SPDX-License-Identifier: Apache-2.0
+# 3D causal CNN encoder for the MiniMax H3 visual VAE (inference-only bundle).
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .conv import BaseConv3d
+from .norm import get_group_norm_3d, get_spatial_norm_3d
+
+# ============================================================================
+# 3D CNN Components
+# ============================================================================
+
+
+def norm_silu(x, norm, cond=None):
+    if cond is None:
+        return F.silu(norm(x), inplace=True)
+    else:
+        return F.silu(norm(x, cond), inplace=True)
+
+
+class Downsample3D(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        time_stride=1,
+        space_stride=2,
+        padding_mode="zeros",
+        padding_mode_t=None,
+        causal=True,
+    ):
+        super().__init__()
+        self.time_stride = time_stride
+        self.space_stride = space_stride
+
+        assert time_stride in [1, 2]
+        assert space_stride in [1, 2, 3]
+
+        self.conv = BaseConv3d(
+            in_channels,
+            out_channels,
+            kernel_size=3,
+            padding=(1, 0, 0),
+            stride=(time_stride, space_stride, space_stride),
+            padding_mode=padding_mode,
+            padding_mode_t=padding_mode_t,
+            causal=causal,
+        )
+        self.causal = self.conv.causal
+        self.pad_mode = self.conv.pad_mode
+
+    def forward(self, x):
+        if self.space_stride == 2:
+            pad = (0, 1, 0, 1, 0, 0)
+            x = F.pad(x, pad, mode=self.pad_mode)
+        return self.conv(x)
+
+
+class ResnetBlock3D(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        out_channels=None,
+        zq_ch=None,
+        padding_mode="zeros",
+        padding_mode_t=None,
+        causal=True,
+        use_t_isolated_gn=False,
+    ):
+        super().__init__()
+        self.in_channels = in_channels
+        out_channels = in_channels if out_channels is None else out_channels
+        self.out_channels = out_channels
+
+        self.use_fused_norm = False
+
+        if zq_ch is None:
+            self.norm1 = get_group_norm_3d(in_channels, use_t_isolated_gn=use_t_isolated_gn)
+            self.norm2 = get_group_norm_3d(out_channels, use_t_isolated_gn=use_t_isolated_gn)
+        else:
+            self.norm1 = get_spatial_norm_3d(
+                in_channels,
+                zq_ch,
+                padding_mode=padding_mode,
+                padding_mode_t=padding_mode_t,
+                causal=causal,
+                use_t_isolated_gn=use_t_isolated_gn,
+            )
+            self.norm2 = get_spatial_norm_3d(
+                out_channels,
+                zq_ch,
+                padding_mode=padding_mode,
+                padding_mode_t=padding_mode_t,
+                causal=causal,
+                use_t_isolated_gn=use_t_isolated_gn,
+            )
+
+        self.conv1 = BaseConv3d(
+            in_channels,
+            out_channels,
+            kernel_size=3,
+            padding=1,
+            padding_mode=padding_mode,
+            padding_mode_t=padding_mode_t,
+            causal=causal,
+        )
+
+        self.conv2 = BaseConv3d(
+            out_channels,
+            out_channels,
+            kernel_size=3,
+            padding=1,
+            padding_mode=padding_mode,
+            padding_mode_t=padding_mode_t,
+            causal=causal,
+        )
+
+        if self.in_channels != self.out_channels:
+            self.nin_shortcut = BaseConv3d(
+                in_channels,
+                out_channels,
+                kernel_size=1,
+                padding_mode=padding_mode,
+                padding_mode_t=padding_mode_t,
+                causal=causal,
+            )
+
+    def forward(self, x, zq=None):
+        h = x
+
+        if self.use_fused_norm:
+            h = self.norm1(h, zq)
+        else:
+            h = norm_silu(h, self.norm1, zq)
+
+        h = self.conv1(h)
+
+        if self.use_fused_norm:
+            h = self.norm2(h, zq)
+        else:
+            h = norm_silu(h, self.norm2, zq)
+
+        h = self.conv2(h)
+
+        if self.in_channels != self.out_channels:
+            x = self.nin_shortcut(x)
+
+        return h.add_(x)
+
+
+class EncoderFCN3D(nn.Module):
+    def __init__(
+        self,
+        ch,
+        ch_mult,
+        space_down,
+        time_down,
+        num_res_blocks,
+        in_channels,
+        z_channels,
+        double_z=False,
+        zq_ch=None,
+        padding_mode="zeros",
+        padding_mode_t=None,
+        causal=True,
+        use_t_isolated_gn=False,
+    ):
+        super().__init__()
+        self.ch = ch
+        self.num_levels = len(ch_mult)
+
+        if isinstance(num_res_blocks, int):
+            self.num_res_blocks = [num_res_blocks] * self.num_levels
+        else:
+            self.num_res_blocks = num_res_blocks
+
+        self.space_down_factors = space_down
+        self.time_down_factors = time_down
+        self.in_channels = in_channels
+
+        self.use_fused_norm = False
+
+        block_mid = [ch * ch_mult[i] for i in range(self.num_levels)]
+        block_in = [block_mid[0]] + block_mid[:-1]
+        block_out = block_mid
+
+        conv_kwargs = dict(
+            padding_mode=padding_mode,
+            padding_mode_t=padding_mode_t,
+            causal=causal,
+        )
+
+        self.conv_in = BaseConv3d(in_channels, block_in[0], kernel_size=3, padding=1, **conv_kwargs)
+
+        self.down = nn.ModuleList()
+        for i_level in range(self.num_levels):
+            down = nn.Module()
+
+            down.block = nn.ModuleList()
+            for i in range(self.num_res_blocks[i_level]):
+                down.block.append(
+                    ResnetBlock3D(
+                        in_channels=block_in[i_level] if i == 0 else block_mid[i_level],
+                        out_channels=block_mid[i_level],
+                        zq_ch=zq_ch,
+                        use_t_isolated_gn=use_t_isolated_gn,
+                        **conv_kwargs,
+                    )
+                )
+
+            if space_down[i_level] * time_down[i_level] > 1:
+                down.downsample = Downsample3D(
+                    block_mid[i_level],
+                    block_out[i_level],
+                    time_stride=time_down[i_level],
+                    space_stride=space_down[i_level],
+                    **conv_kwargs,
+                )
+            else:
+                if block_out[i_level] != block_mid[i_level]:
+                    down.downsample = BaseConv3d(
+                        block_mid[i_level],
+                        block_out[i_level],
+                        kernel_size=1,
+                        **conv_kwargs,
+                    )
+
+            self.down.append(down)
+
+        if zq_ch is None:
+            self.norm_out = get_group_norm_3d(block_out[-1], use_t_isolated_gn=use_t_isolated_gn)
+        else:
+            self.norm_out = get_spatial_norm_3d(
+                block_out[-1],
+                zq_ch,
+                use_t_isolated_gn=use_t_isolated_gn,
+                **conv_kwargs,
+            )
+
+        self.conv_out = BaseConv3d(
+            block_out[-1],
+            2 * z_channels if double_z else z_channels,
+            kernel_size=3,
+            padding=1,
+            **conv_kwargs,
+        )
+
+    def forward(self, x, zq=None):
+        h = self.conv_in(x)
+        for i_level in range(self.num_levels):
+            for i_block in range(self.num_res_blocks[i_level]):
+                h = self.down[i_level].block[i_block](h, zq)
+            if hasattr(self.down[i_level], "downsample"):
+                h = self.down[i_level].downsample(h)
+
+        if self.use_fused_norm:
+            h = self.norm_out(h, zq)
+        else:
+            h = norm_silu(h, self.norm_out, zq)
+
+        h = self.conv_out(h)
+        return h
diff --git a/telefuser/models/minimax_h3_video/vae_vit.py b/telefuser/models/minimax_h3_video/vae_vit.py
new file mode 100644
index 00000000..c05bc7ef
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/vae_vit.py
@@ -0,0 +1,337 @@
+# SPDX-License-Identifier: Apache-2.0
+# ViT3D decoder for the MiniMax H3 visual VAE (inference-only bundle).
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.utils import logging
+
+from .base_module import RotaryEmbeddingND, TransformerBlock
+from .flash import make_block_causal_mask_mod
+from .vit_utils import create_token_ids, prepare_rotary_pos_emb
+
+logger = logging.get_logger(__name__)
+
+
+def _linear_with_module_dtype(linear, tensor, out_dtype=None):
+    weight = getattr(linear, "weight", None)
+    target_dtype = getattr(weight, "dtype", tensor.dtype)
+    output = linear(tensor.to(target_dtype))
+    if out_dtype is not None and output.dtype != out_dtype:
+        output = output.to(out_dtype)
+    return output
+
+
+def _pack_tensors_3d(tensors, patch_size, patch_size_t):
+    batch_size, num_channels_tensors, temporal, height, width = tensors.shape
+
+    tensors = tensors.view(
+        batch_size,
+        num_channels_tensors,
+        temporal // patch_size_t,
+        patch_size_t,
+        height // patch_size,
+        patch_size,
+        width // patch_size,
+        patch_size,
+    )
+    tensors = tensors.permute(0, 2, 4, 6, 1, 3, 5, 7)
+    tensors = tensors.reshape(
+        batch_size,
+        (temporal // patch_size_t) * (height // patch_size) * (width // patch_size),
+        num_channels_tensors * patch_size_t * patch_size * patch_size,
+    )
+    return tensors
+
+
+def _unpack_tensors_3d(tensors, patch_size, patch_size_t, temporal, height, width):
+    batch_size, num_patches, channels = tensors.shape
+    num_channels_tensors = channels // (patch_size_t * patch_size * patch_size)
+
+    tensors = tensors.view(
+        batch_size,
+        temporal // patch_size_t,
+        height // patch_size,
+        width // patch_size,
+        num_channels_tensors,
+        patch_size_t,
+        patch_size,
+        patch_size,
+    )
+    tensors = tensors.permute(0, 4, 1, 5, 2, 6, 3, 7).contiguous()
+    tensors = tensors.reshape(batch_size, num_channels_tensors, temporal, height, width)
+    return tensors
+
+
+class ViTBase(ModelMixin, ConfigMixin):
+    """Base class for ViT Encoder and Decoder with common functionality."""
+
+    _no_split_modules = ["TransformerBlock"]
+
+    def _init_weights(self):
+        def basic_init(m):
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+        self.apply(basic_init)
+
+    def init_mask_config(self, dim, is_3d=False):
+        self._mask_dim = dim
+        self._mask_is_3d = is_3d
+        self.register_buffer("mask_token", torch.zeros(1, 1, dim))
+
+    def set_mask_config(self, mask_config):
+        self.mask_prob = mask_config.get("mask_prob", 0.0)
+        self.mask_enabled = self.mask_prob > 0
+        self.mask_style = mask_config.get("mask_style", "replace")
+        if self.mask_enabled and self.mask_style == "drop" and self.mask_prob < 1.0:
+            logger.warning("mask_style='drop' with mask_prob < 1.0")
+        if self._mask_is_3d:
+            self.temporal_scale_range = mask_config.get("temporal_scale_range", (0.3, 0.5))
+            self.spatial_scale_range = mask_config.get("spatial_scale_range", (0.1, 0.25))
+            self.min_mask_ratio = mask_config.get("min_mask_ratio", 0.75)
+            self.max_mask_ratio = mask_config.get("max_mask_ratio", 0.95)
+        else:
+            self.spatial_scale_range = mask_config.get("spatial_scale_range", (0.15, 0.15))
+            self.min_mask_ratio = mask_config.get("min_mask_ratio", 0.5)
+            self.max_mask_ratio = mask_config.get("max_mask_ratio", 0.75)
+        self.aspect_ratio_range = mask_config.get("aspect_ratio_range", (0.75, 1.5))
+        self.max_retries = mask_config.get("max_retries", 100)
+        if self.mask_enabled and self.mask_style == "drop" and getattr(self, "t_causal", False):
+            logger.warning("mask_style='drop' with t_causal may cause issues")
+        if self.mask_enabled and "mask_token" in self._buffers:
+            del self._buffers["mask_token"]
+            self.mask_token = nn.Parameter(torch.randn(1, 1, self._mask_dim) * 0.02)
+
+    def init_suffix_tokens(self, dim, num_register_tokens, has_cls_token=True):
+        self.num_register_tokens = num_register_tokens
+        if num_register_tokens > 0:
+            self.register_tokens = nn.Parameter(torch.randn(1, num_register_tokens, dim) * 0.02)
+        else:
+            self.register_tokens = None
+        if has_cls_token:
+            self.cls_token = nn.Parameter(torch.randn(1, 1, dim) * 0.02)
+
+    def apply_mask_preprocess(self, hidden_states, img_ids, patch_dims, num_suffix):
+        if self.training and self.mask_enabled:
+            raise NotImplementedError("mask modeling is not supported in this inference-only bundle")
+        return hidden_states, img_ids
+
+    def forward_transformer_blocks(self, hidden_states, rotary_pos_emb, pack_info=None):
+        if pack_info is None:
+            pack_info = {}
+        for block in self.transformer_blocks:
+            hidden_states = block(hidden_states, rotary_pos_emb, pack_info)
+        return hidden_states
+
+    def apply_mask_postprocess(self, hidden_states, num_patches):
+        if self.training and self.mask_enabled and self.mask_style == "drop":
+            raise NotImplementedError("mask modeling is not supported in this inference-only bundle")
+        return hidden_states
+
+
+class ViT3DDecoder(ViTBase):
+    """Vision Transformer Video Decoder using TransformerBlock."""
+
+    @register_to_config
+    def __init__(
+        self,
+        patch_size: int = 16,
+        patch_size_t: int = 4,
+        t_causal: bool = False,
+        in_channels: int = 16,
+        out_channels: int = 3,
+        num_layers: int = 24,
+        heads: int = 16,
+        dim_head: int = 64,
+        norm_type: str = "layer_norm",
+        norm_affine: bool = True,
+        qk_norm_type: str = None,
+        qk_norm_affine: bool = False,
+        ffn_activation_fn: str = "gelu",
+        ffn_use_gated: bool = False,
+        rope_theta: float = 100.0,
+        rope_dim_ratio: float = 1.0,
+        bias: bool = True,
+        eps: float = 1e-5,
+        num_register_tokens: int = 4,
+        mask_config: dict = {},
+        **kwargs,
+    ):
+        super().__init__()
+
+        dim = heads * dim_head
+        rope_apply_dim = int(dim_head * rope_dim_ratio)
+
+        self.pos_embed = RotaryEmbeddingND(rope_apply_dim, rope_theta, n_dim=3, use_angle=True)
+
+        self.x_embedder = nn.Linear(in_channels, dim)
+
+        self.init_suffix_tokens(dim, num_register_tokens, has_cls_token=False)
+
+        self.t_causal = t_causal
+
+        self.transformer_blocks = nn.ModuleList(
+            [
+                TransformerBlock(
+                    heads=heads,
+                    dim_head=dim_head,
+                    norm_type=norm_type,
+                    norm_affine=norm_affine,
+                    qk_norm_type=qk_norm_type,
+                    qk_norm_affine=qk_norm_affine,
+                    ffn_activation_fn=ffn_activation_fn,
+                    ffn_use_gated=ffn_use_gated,
+                    bias=bias,
+                    eps=eps,
+                    **kwargs,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+
+        self.norm_out = nn.LayerNorm(dim, elementwise_affine=norm_affine, eps=eps)
+        patch_dim = out_channels * patch_size_t * patch_size * patch_size
+        self.proj_out = nn.Linear(dim, patch_dim)
+
+        self.init_mask_config(dim, is_3d=True)
+        self.set_mask_config(mask_config)
+
+        self._rotary_pos_emb_cache = None
+        self._autocast_linear_dtype = None
+
+        if len(kwargs) > 0 and (not dist.is_initialized() or dist.get_rank() == 0):
+            logger.warning(f"Unused kwargs: {kwargs}")
+
+    def _apply(self, fn, recurse=True):
+        result = super()._apply(fn, recurse=recurse)
+        self._rotary_pos_emb_cache = None
+        self._autocast_linear_dtype = None
+        return result
+
+    def prepare_autocast_linear_weights(self, dtype: torch.dtype) -> int:
+        """Keep decoder-block linear weights in their autocast compute dtype.
+
+        PyTorch autocast does not cache casts for these frozen parameters, so
+        tiled decode otherwise converts every FP32 weight and bias once per
+        block invocation.  Persisting the rounded values is numerically
+        equivalent to the per-call autocast conversion.  The embedding and
+        output projections stay FP32 because their calls explicitly disable
+        autocast.
+        """
+
+        if dtype not in (torch.float16, torch.bfloat16):
+            raise ValueError(f"MiniMax H3 decoder autocast weights require fp16 or bf16, got {dtype}")
+        if self._autocast_linear_dtype == dtype:
+            return 0
+
+        converted = 0
+        for block in self.transformer_blocks:
+            for linear in (
+                block.attn.to_qkv,
+                block.attn.to_out,
+                block.ff.w1,
+                block.ff.w2,
+            ):
+                if linear.weight.dtype != dtype:
+                    linear.to(dtype=dtype)
+                    converted += 1
+        self._autocast_linear_dtype = dtype
+        return converted
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        B, C, latent_T, latent_H, latent_W = x.shape
+        patch_size = self.config.patch_size
+        patch_size_t = self.config.patch_size_t
+        num_suffix = 1 + self.num_register_tokens
+
+        hidden_states = _pack_tensors_3d(x, 1, 1)
+        latent_size = (latent_T, latent_H, latent_W)
+
+        with torch.autocast("cuda", enabled=False):
+            hidden_states = _linear_with_module_dtype(self.x_embedder, hidden_states, hidden_states.dtype)
+
+        num_patches = hidden_states.shape[1]
+
+        tokens = [hidden_states]
+
+        if self.register_tokens is not None:
+            register_tokens = self.register_tokens.expand(B, -1, -1)
+            tokens.append(register_tokens)
+
+        cls_token = torch.zeros_like(hidden_states[:, 0:1, :])
+        tokens.append(cls_token)
+        hidden_states = torch.cat(tokens, dim=1)
+
+        patch_dims = [latent_T, latent_H, latent_W]
+        rotary_dtype = (
+            torch.get_autocast_dtype("cuda") if x.is_cuda and torch.is_autocast_enabled("cuda") else hidden_states.dtype
+        )
+        cache_enabled = not self.training and not self.mask_enabled and not torch.compiler.is_compiling()
+        cache_key = (
+            B,
+            latent_T,
+            latent_H,
+            latent_W,
+            num_suffix,
+            x.device,
+            x.dtype,
+            rotary_dtype,
+        )
+        cache_record = self._rotary_pos_emb_cache if cache_enabled else None
+        cache_hit = cache_record is not None and cache_record[0] == cache_key
+        if cache_hit:
+            img_ids = cache_record[1]
+        else:
+            img_ids = create_token_ids(latent_size, x.device, x.dtype).expand(B, -1, -1)
+            suffix_ids = torch.zeros((B, num_suffix, 3), device=x.device, dtype=img_ids.dtype)
+            img_ids = torch.cat([img_ids, suffix_ids], dim=1)
+
+        hidden_states, img_ids = self.apply_mask_preprocess(hidden_states, img_ids, patch_dims, num_suffix)
+        cache_img_ids = img_ids
+
+        pack_info = {}
+        if self.t_causal:
+            spatial_size = latent_H * latent_W
+            mask_mod = make_block_causal_mask_mod(
+                num_tokens=num_patches,
+                block_size=spatial_size,
+                suffix=True,
+            )
+            pack_info["mask_mod"] = mask_mod
+
+        if cache_hit:
+            rotary_pos_emb = cache_record[2]
+        else:
+            rotary_pos_emb = prepare_rotary_pos_emb(
+                self.pos_embed(img_ids),
+                dtype=rotary_dtype,
+            )
+            if cache_enabled:
+                self._rotary_pos_emb_cache = (
+                    cache_key,
+                    cache_img_ids,
+                    rotary_pos_emb,
+                )
+
+        for block in self.transformer_blocks:
+            hidden_states = block(hidden_states, rotary_pos_emb, pack_info)
+
+        hidden_states = self.norm_out(hidden_states)
+
+        hidden_states = self.apply_mask_postprocess(hidden_states, num_patches)
+
+        with torch.autocast("cuda", enabled=False):
+            output = _linear_with_module_dtype(self.proj_out, hidden_states, hidden_states.dtype)
+
+        output = output[:, :num_patches, :]
+
+        video_t = latent_size[0] * patch_size_t
+        video_h = latent_size[1] * patch_size
+        video_w = latent_size[2] * patch_size
+        output = _unpack_tensors_3d(output, patch_size, patch_size_t, video_t, video_h, video_w)
+
+        return output
diff --git a/telefuser/models/minimax_h3_video/vit_utils.py b/telefuser/models/minimax_h3_video/vit_utils.py
new file mode 100644
index 00000000..95b98fec
--- /dev/null
+++ b/telefuser/models/minimax_h3_video/vit_utils.py
@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: Apache-2.0
+# ViT runtime helpers for the MiniMax H3 visual VAE.
+from collections.abc import Sequence
+from typing import Tuple
+
+import torch
+
+
+def create_token_ids(patch_dims, device, dtype, id_type="length_normalized", flatten=True):
+    coords_list = []
+
+    if isinstance(id_type, str):
+        id_type_list = [id_type] * len(patch_dims)
+    elif isinstance(id_type, list):
+        id_type_list = id_type
+        if len(id_type_list) != len(patch_dims):
+            raise ValueError("id_type list must match patch_dims")
+    else:
+        raise ValueError("id_type must be a string or a list")
+
+    if "area_normalized" in id_type_list or id_type == "area_normalized":
+        raise NotImplementedError("area_normalized id_type is not supported in this inference-only bundle")
+
+    for _dim_size, _id_type in zip(patch_dims, id_type_list):
+        if isinstance(_dim_size, torch.Tensor):
+            coords_list.append(_dim_size.to(device=device, dtype=dtype))
+            continue
+
+        if _id_type == "length_normalized":
+            coords = torch.arange(0.5, _dim_size, dtype=dtype, device=device)
+            coords = coords / _dim_size
+            coords = 2.0 * coords - 1.0
+        else:
+            coords = torch.arange(_dim_size, dtype=dtype, device=device)
+
+        coords_list.append(coords)
+
+    coords = torch.stack(torch.meshgrid(*coords_list, indexing="ij"), dim=-1)
+    if flatten:
+        coords = coords.flatten(0, len(patch_dims) - 1)
+
+    return coords.unsqueeze(0)
+
+
+def _rotate_half(x: torch.Tensor) -> torch.Tensor:
+    x1, x2 = torch.chunk(x, 2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def _apply_rotary_pos_emb_impl(t: torch.Tensor, rotary_pos_emb: Tuple[torch.Tensor, torch.Tensor]) -> torch.Tensor:
+    cos, sin = rotary_pos_emb[:2]
+
+    if cos.dim() != 4:
+        raise ValueError(f"cos must be [B, N, 1, D], got {cos.shape}")
+
+    cos = cos.to(t.dtype)
+    sin = sin.to(t.dtype)
+
+    rot_dim = cos.shape[-1]
+    t_dim = t.shape[-1]
+
+    if rot_dim < t_dim:
+        t_rot, t_pass = t[..., :rot_dim], t[..., rot_dim:]
+        scaled = t_rot * cos
+        scaled.add_(_rotate_half(t_rot) * sin)
+        t_rot = scaled
+        t = torch.cat((t_rot, t_pass), dim=-1)
+    else:
+        scaled = t * cos
+        scaled.add_(_rotate_half(t) * sin)
+        t = scaled
+
+    return t
+
+
+def prepare_rotary_pos_emb(
+    rotary_pos_emb: Tuple[torch.Tensor, torch.Tensor],
+    *,
+    dtype: torch.dtype,
+) -> tuple[torch.Tensor, ...]:
+    """Cast-free eager rotary cache used by the parity path."""
+    cos, sin = rotary_pos_emb
+    del dtype
+    return cos, sin
+
+
+def apply_rotary_pos_emb(t: torch.Tensor, rotary_pos_emb: Sequence[torch.Tensor]) -> torch.Tensor:
+    return _apply_rotary_pos_emb_impl(t, rotary_pos_emb)
+
+
+def apply_rotary_pos_emb_qk(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    rotary_pos_emb: Sequence[torch.Tensor],
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Apply the released NeoX rotary recipe to Q and K."""
+    return (
+        apply_rotary_pos_emb(query, rotary_pos_emb),
+        apply_rotary_pos_emb(key, rotary_pos_emb),
+    )
diff --git a/telefuser/models/minimax_h3_video_vae.py b/telefuser/models/minimax_h3_video_vae.py
new file mode 100644
index 00000000..e4529d48
--- /dev/null
+++ b/telefuser/models/minimax_h3_video_vae.py
@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 f16/t4/d24 visual VAE."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.distributed as dist
+
+from telefuser.core.base_model import BaseModel
+
+from .minimax_h3_video import AutoencoderKLLegacy
+
+
+@dataclass(frozen=True)
+class MiniMaxH3VideoVAEConfig:
+    architecture: dict[str, Any]
+    clip_length: int
+    token_drop: int
+    encoder_tiling: bool
+    decoder_tiling: bool
+    tile_size: int
+    tile_overlap_min: int
+    chunk_dim: int
+    latent_channels: int
+    latents_mean: tuple[float, ...]
+    latents_std: tuple[float, ...]
+
+    @classmethod
+    def from_path(cls, path: str | Path) -> MiniMaxH3VideoVAEConfig:
+        component_dir = Path(path)
+        if component_dir.is_file():
+            component_dir = component_dir.parent
+        component = json.loads((component_dir / "config.json").read_text(encoding="utf-8"))
+        source_dir = component_dir / component["source_path"]
+        architecture = json.loads((source_dir / "config.json").read_text(encoding="utf-8"))
+        config = cls(
+            architecture=architecture,
+            clip_length=int(component["vae_clip_length"]),
+            token_drop=int(component["vae_token_drop"]),
+            encoder_tiling=bool(component["vae_encoder_tiling"]),
+            decoder_tiling=bool(component["vae_decoder_tiling"]),
+            tile_size=int(component["vae_tile_size"]),
+            tile_overlap_min=int(component["vae_tile_overlap_min"]),
+            chunk_dim=int(component["vae_chunk_dim"]),
+            latent_channels=int(component["latent_channels"]),
+            latents_mean=tuple(float(value) for value in component["latents_mean"]),
+            latents_std=tuple(float(value) for value in component["latents_std"]),
+        )
+        config.validate()
+        return config
+
+    def validate(self) -> None:
+        spatial_ratio = int(self.architecture.get("vae_ratio", 0))
+        temporal_ratio = int(self.architecture.get("vae_ratio_t", 0))
+        if (spatial_ratio, temporal_ratio, self.latent_channels) != (16, 4, 24):
+            raise ValueError(
+                "MiniMax H3 visual VAE requires f16/t4/d24 geometry, got "
+                f"f{spatial_ratio}/t{temporal_ratio}/d{self.latent_channels}"
+            )
+        if int(self.architecture.get("embed_dim", 0)) != self.latent_channels:
+            raise ValueError("visual VAE embed_dim must equal latent_channels")
+        if self.clip_length != 17 or self.token_drop != 3:
+            raise ValueError("MiniMax H3 visual VAE requires clip_length=17 and token_drop=3")
+        if len(self.latents_mean) != self.latent_channels or len(self.latents_std) != self.latent_channels:
+            raise ValueError("visual VAE latent statistics must contain one value per channel")
+        if any(value <= 0 for value in self.latents_std):
+            raise ValueError("visual VAE latent standard deviations must be positive")
+
+    def model_kwargs(self) -> dict[str, Any]:
+        ignored = {"_class_name", "_diffusers_version", "vae_ratio", "vae_ratio_t"}
+        kwargs = {key: value for key, value in self.architecture.items() if key not in ignored}
+        kwargs.update(
+            {
+                "clip_length": self.clip_length,
+                "token_drop": self.token_drop,
+                "encoder_tiling": self.encoder_tiling,
+                "decoder_tiling": self.decoder_tiling,
+                "parallel_tiling": False,
+                "tile_size": self.tile_size,
+                "tile_overlap_min": self.tile_overlap_min,
+                "encoder_parallel": False,
+                "decoder_parallel": False,
+                "chunk_dim": self.chunk_dim,
+            }
+        )
+        return kwargs
+
+
+class MiniMaxH3VideoVAE(BaseModel):
+    """Checkpoint-backed 3D CNN encoder and ViT decoder."""
+
+    def __init__(self, config: MiniMaxH3VideoVAEConfig) -> None:
+        super().__init__()
+        config.validate()
+        self.model = AutoencoderKLLegacy(**config.model_kwargs())
+        self.config = config
+        self.layer_name_list = ["model"]
+
+    @property
+    def processor(self) -> Any:
+        return self.model.processor
+
+    @torch.no_grad()
+    def encode_images(self, *args: Any, **kwargs: Any) -> list[torch.Tensor]:
+        return self.model.encode_images(*args, **kwargs)
+
+    @torch.no_grad()
+    def encode_videos(self, *args: Any, **kwargs: Any) -> list[torch.Tensor]:
+        return self.model.encode_videos(*args, **kwargs)
+
+    @torch.no_grad()
+    def decode_base(self, *args: Any, **kwargs: Any) -> torch.Tensor:
+        return self.model.decode_base(*args, **kwargs)
+
+    def prepare_decoder_autocast_weights(self, dtype: torch.dtype) -> int:
+        return self.model.decoder.prepare_autocast_linear_weights(dtype)
+
+    def enable_parallel_tiling(self, group: dist.ProcessGroup) -> None:
+        self.model.enable_parallel_tiling(group)
+
+    @torch.no_grad()
+    def decode_normalized(self, latent: torch.Tensor) -> torch.Tensor:
+        if latent.ndim != 5 or latent.shape[1] != self.config.latent_channels:
+            raise ValueError(f"visual latent must be [B, {self.config.latent_channels}, T, H, W]")
+        mean = latent.new_tensor(self.config.latents_mean).view(1, -1, 1, 1, 1)
+        std = latent.new_tensor(self.config.latents_std).view(1, -1, 1, 1, 1)
+        frames = self.model.decode_base(latent.mul(std).add(mean))
+        return self.model.processor.revert_tensor(frames)
+
+    @staticmethod
+    def state_dict_converter(config_path: str | Path) -> MiniMaxH3VideoVAEStateDictConverter:
+        return MiniMaxH3VideoVAEStateDictConverter(config_path)
+
+
+class MiniMaxH3VideoVAEStateDictConverter:
+    def __init__(self, config_path: str | Path) -> None:
+        self.config = MiniMaxH3VideoVAEConfig.from_path(config_path)
+
+    def from_official(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        converted = {f"model.{name}": value for name, value in state_dict.items()}
+        return converted, {"config": self.config}
+
+    def from_diffusers(self, state_dict: dict[str, torch.Tensor]) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        return self.from_official(state_dict)
+
+
+__all__ = [
+    "MiniMaxH3VideoVAE",
+    "MiniMaxH3VideoVAEConfig",
+    "MiniMaxH3VideoVAEStateDictConverter",
+]
diff --git a/telefuser/ops/__init__.py b/telefuser/ops/__init__.py
index 8212542f..9e5da267 100644
--- a/telefuser/ops/__init__.py
+++ b/telefuser/ops/__init__.py
@@ -10,6 +10,7 @@
 
 from __future__ import annotations
 
+from .activations import silu_and_mul_reuse_input
 from .base import CustomOp, CustomOpFunction
 from .custom_op import TritonKernelWrapper, register_custom_op
 from .moe import grouped_expert_forward, route_topk
@@ -18,9 +19,11 @@
     LayerNorm,
     RMSNorm,
     fused_scale_shift,
+    indexed_gate,
+    indexed_scale_shift,
     modulate,
 )
-from .rotary import apply_rotary_emb
+from .rotary import apply_qk_norm_rope_neox, apply_rotary_emb
 
 __all__ = [
     # Base classes
@@ -35,8 +38,12 @@
     "AdaLayerNormContinuous",
     "fused_scale_shift",
     "modulate",
+    "indexed_gate",
+    "indexed_scale_shift",
     "route_topk",
     "grouped_expert_forward",
     # Rotary
     "apply_rotary_emb",
+    "apply_qk_norm_rope_neox",
+    "silu_and_mul_reuse_input",
 ]
diff --git a/telefuser/ops/activations.py b/telefuser/ops/activations.py
index 5f1c8f5a..8fcbd2af 100644
--- a/telefuser/ops/activations.py
+++ b/telefuser/ops/activations.py
@@ -55,13 +55,28 @@ def silu_and_mul(x: torch.Tensor) -> torch.Tensor:
     Returns:
         Gated output: silu(x1) * x2
     """
-    if _has_tf_kernel:
+    if _has_tf_kernel and x.device.type == "cuda":
         return _tf_silu_and_mul(x)
     # Fallback to PyTorch
     gate, val = x.chunk(2, dim=-1)
     return F.silu(gate) * val
 
 
+def silu_and_mul_reuse_input(x: torch.Tensor) -> torch.Tensor:
+    """Apply H3-compatible rounded SiLU gating while reusing disposable BF16 input."""
+    if (
+        x.is_cuda
+        and x.dtype == torch.bfloat16
+        and x.is_contiguous()
+        and x.shape[-1] % 16 == 0
+        and not torch.compiler.is_compiling()
+    ):
+        from telefuser.kernel.triton import silu_and_mul_bf16_input_inplace_
+
+        return silu_and_mul_bf16_input_inplace_(x)
+    return silu_and_mul(x)
+
+
 def gelu_and_mul(x: torch.Tensor) -> torch.Tensor:
     """Apply GELU gated multiplication: gelu(x1) * x2.
 
@@ -74,7 +89,7 @@ def gelu_and_mul(x: torch.Tensor) -> torch.Tensor:
     Returns:
         Gated output: gelu(x1) * x2
     """
-    if _has_tf_kernel:
+    if _has_tf_kernel and x.device.type == "cuda":
         return _tf_gelu_and_mul(x)
     # Fallback to PyTorch
     gate, val = x.chunk(2, dim=-1)
diff --git a/telefuser/ops/attention/attention_impl.py b/telefuser/ops/attention/attention_impl.py
index f05b4958..9375fdde 100755
--- a/telefuser/ops/attention/attention_impl.py
+++ b/telefuser/ops/attention/attention_impl.py
@@ -36,6 +36,7 @@
     flash_attn2,
     flash_attn3,
     flash_attn4,
+    flash_attn4_varlen,
     get_lse_fallback_impl,
     sageattention,
     sdpa_attn_cudnn,
@@ -73,6 +74,57 @@ def _packed_sdpa(
     return torch.cat(outputs, dim=2)
 
 
+def _packed_flash_attention4(
+    q: Tensor,
+    k: Tensor,
+    v: Tensor,
+    sequence_lengths: list[int],
+    *,
+    cu_seqlens: Tensor | None,
+    scale: float | None,
+    is_causal: bool,
+    return_lse: bool,
+    kwargs: dict[str, Any],
+) -> Tensor | tuple[Tensor, Tensor]:
+    """Run FlashAttention 4 varlen over sequences packed on the BSND axis."""
+    if q.shape != k.shape or q.shape != v.shape or q.ndim != 4 or q.shape[0] != 1:
+        raise ValueError("packed FlashAttention requires matching Q/K/V tensors with shape [1, sequence, heads, dim]")
+    if any(length <= 0 for length in sequence_lengths) or sum(sequence_lengths) != q.shape[1]:
+        raise ValueError("packed FlashAttention lengths must be positive and sum to the packed sequence dimension")
+    if cu_seqlens is None:
+        cumulative = [0]
+        for length in sequence_lengths:
+            cumulative.append(cumulative[-1] + length)
+        cu_seqlens = torch.tensor(cumulative, dtype=torch.int32, device=q.device)
+    elif cu_seqlens.ndim != 1 or cu_seqlens.numel() != len(sequence_lengths) + 1:
+        raise ValueError("cu_seqlens must contain one cumulative boundary per packed sequence")
+    else:
+        cu_seqlens = cu_seqlens.to(device=q.device, dtype=torch.int32)
+    if flash_attn4_varlen is None:
+        raise RuntimeError("FlashAttention 4 varlen backend is unavailable")
+    result = flash_attn4_varlen(
+        q[0],
+        k[0],
+        v[0],
+        cu_seqlens_q=cu_seqlens,
+        cu_seqlens_k=cu_seqlens,
+        max_seqlen_q=max(sequence_lengths),
+        max_seqlen_k=max(sequence_lengths),
+        softmax_scale=scale,
+        causal=is_causal,
+        return_lse=return_lse,
+        **kwargs,
+    )
+    if isinstance(result, tuple):
+        output, lse = result[:2]
+    else:
+        output, lse = result, None
+    output = output.unsqueeze(0)
+    if return_lse:
+        return output, lse
+    return output
+
+
 class SparseAttentionState:
     """Runtime state for sparse attention computation.
 
@@ -123,6 +175,7 @@ def attention(
     is_causal: bool = False,
     return_lse: bool = False,
     sequence_lengths: list[int] | None = None,
+    cu_seqlens: Tensor | None = None,
     **kwargs: Any,
 ) -> Tensor | tuple[Tensor, Tensor]:
     """Unified attention function.
@@ -140,6 +193,8 @@ def attention(
         output_layout: Output tensor layout.
         is_causal: Use causal masking.
         return_lse: Return log-sum-exp values.
+        sequence_lengths: Length of each sequence packed along the sequence axis.
+        cu_seqlens: Optional precomputed cumulative sequence lengths for varlen kernels.
         **kwargs: Implementation-specific arguments.
 
     Returns:
@@ -157,8 +212,8 @@ def attention(
     attn_impl = attention_config.attn_impl
     scale = scale if scale is not None else attention_config.scale
     is_causal = is_causal or attention_config.is_causal
-    if sequence_lengths is not None and attn_impl != AttnImplType.TORCH_SDPA:
-        raise ValueError("packed sequence attention currently requires TORCH_SDPA")
+    if sequence_lengths is not None and attn_impl not in {AttnImplType.TORCH_SDPA, AttnImplType.FLASH_ATTN_4}:
+        raise ValueError("packed sequence attention requires TORCH_SDPA or FLASH_ATTN_4")
 
     # Handle sparse attention
     if attn_impl in (AttnImplType.RADIAL_ATTN, AttnImplType.LOCAL_SPARSE_ATTN):
@@ -212,18 +267,45 @@ def attention(
 
     # Flash Attention implementations
     if attn_impl == AttnImplType.FLASH_ATTN_4 and FLASH_ATTN_4_AVAILABLE and flash_attn4 is not None:
-        result = flash_attn4(q, k, v, softmax_scale=scale, causal=is_causal, return_lse=return_lse, **kwargs)
+        if sequence_lengths is None:
+            result = flash_attn4(q, k, v, softmax_scale=scale, causal=is_causal, return_lse=return_lse, **kwargs)
+        elif flash_attn4_varlen is not None:
+            if attn_mask is not None or current_layout != "BSND":
+                raise ValueError("packed FlashAttention requires BSND layout without an attention mask")
+            result = _packed_flash_attention4(
+                q,
+                k,
+                v,
+                sequence_lengths,
+                cu_seqlens=cu_seqlens,
+                scale=scale,
+                is_causal=is_causal,
+                return_lse=return_lse,
+                kwargs=kwargs,
+            )
+        else:
+            result = None
         if isinstance(result, tuple):
             output, lse = result
         else:
             output = result
-    elif attn_impl == AttnImplType.FLASH_ATTN_3 and FLASH_ATTN_3_AVAILABLE and flash_attn3 is not None:
+    elif (
+        sequence_lengths is None
+        and attn_impl == AttnImplType.FLASH_ATTN_3
+        and FLASH_ATTN_3_AVAILABLE
+        and flash_attn3 is not None
+    ):
         result = flash_attn3(q, k, v, softmax_scale=scale, causal=is_causal, return_softmax_lse=return_lse, **kwargs)
         if return_lse:
             output, lse = result
         else:
             output = result
-    elif attn_impl == AttnImplType.FLASH_ATTN_2 and FLASH_ATTN_2_AVAILABLE and flash_attn2 is not None:
+    elif (
+        sequence_lengths is None
+        and attn_impl == AttnImplType.FLASH_ATTN_2
+        and FLASH_ATTN_2_AVAILABLE
+        and flash_attn2 is not None
+    ):
         result = flash_attn2(q, k, v, softmax_scale=scale, causal=is_causal, return_attn_probs=return_lse, **kwargs)
         if return_lse:
             output, lse, _ = result
@@ -231,7 +313,7 @@ def attention(
             output = result
 
     # PyTorch SDPA
-    elif attn_impl == AttnImplType.TORCH_CUDNN and SDPA_AVAILABLE:
+    elif sequence_lengths is None and attn_impl == AttnImplType.TORCH_CUDNN and SDPA_AVAILABLE:
         output = sdpa_attn_cudnn(q, k, v, attn_mask=attn_mask, scale=scale, is_causal=is_causal)
     elif attn_impl == AttnImplType.TORCH_SDPA and SDPA_AVAILABLE:
         if sequence_lengths is None:
@@ -242,7 +324,7 @@ def attention(
             output = _packed_sdpa(q, k, v, sequence_lengths, scale=scale, is_causal=is_causal)
 
     # Sage Attention variants
-    elif SAGE_ATTN_AVAILABLE and sageattention is not None:
+    elif sequence_lengths is None and SAGE_ATTN_AVAILABLE and sageattention is not None:
         # SageAttention tensor_layout: "NHD" for BSND, "HND" for BNSD
         sage_tensor_layout = "NHD" if current_layout == "BSND" else "HND"
         if attn_impl == AttnImplType.SAGE_ATTN_2_8_8:
@@ -286,7 +368,7 @@ def attention(
             output, lse = result if return_lse else (result, None)
 
     # Sparge Attention
-    elif attn_impl == AttnImplType.SPARGE_ATTN:
+    elif sequence_lengths is None and attn_impl == AttnImplType.SPARGE_ATTN:
         output = sparge_attn(q, k, v, attn_mask=attn_mask, scale=scale)
 
     # Fallback to SDPA
diff --git a/telefuser/ops/attention/backends.py b/telefuser/ops/attention/backends.py
index d6009ea3..37f09f4e 100644
--- a/telefuser/ops/attention/backends.py
+++ b/telefuser/ops/attention/backends.py
@@ -28,6 +28,7 @@
 flash_attn2: Callable | None = None
 flash_attn3: Callable | None = None
 flash_attn4: Callable | None = None
+flash_attn4_varlen: Callable | None = None
 sageattention: object | None = None
 spas_sage2_attn_meansim_cuda: Callable | None = None
 flashinfer: object | None = None
@@ -35,7 +36,8 @@
 
 def _try_import_flash_attn() -> None:
     """Import Flash Attention 2/3/4."""
-    global FLASH_ATTN_4_AVAILABLE, FLASH_ATTN_3_AVAILABLE, FLASH_ATTN_2_AVAILABLE, flash_attn4, flash_attn3, flash_attn2
+    global FLASH_ATTN_4_AVAILABLE, FLASH_ATTN_3_AVAILABLE, FLASH_ATTN_2_AVAILABLE
+    global flash_attn4, flash_attn4_varlen, flash_attn3, flash_attn2
 
     if importlib.util.find_spec("flash_attn") is None:
         return
@@ -47,6 +49,12 @@ def _try_import_flash_attn() -> None:
         flash_attn4 = flash_attn4_impl
         FLASH_ATTN_4_AVAILABLE = True
         logger.debug("Flash Attention 4 available")
+        try:
+            from flash_attn.cute import flash_attn_varlen_func as flash_attn4_varlen_impl
+
+            flash_attn4_varlen = flash_attn4_varlen_impl
+        except (ModuleNotFoundError, ImportError):
+            logger.debug("Flash Attention 4 varlen interface unavailable")
     except (ModuleNotFoundError, ImportError):
         pass
 
@@ -205,6 +213,7 @@ def sparge_attn(
     "flash_attn2",
     "flash_attn3",
     "flash_attn4",
+    "flash_attn4_varlen",
     "sageattention",
     "flashinfer",
     "supports_return_lse",
diff --git a/telefuser/ops/normalization.py b/telefuser/ops/normalization.py
index ae93e877..7abd7428 100644
--- a/telefuser/ops/normalization.py
+++ b/telefuser/ops/normalization.py
@@ -27,6 +27,8 @@
     "fused_scale_shift",
     "fused_layernorm_scale_shift",
     "fused_add_layernorm_scale_shift",
+    "indexed_gate_bf16_",
+    "indexed_scale_shift_bf16_",
 ]
 
 
@@ -53,6 +55,14 @@ def _get_triton_kernel(name: KernelName) -> Callable:
         from telefuser.kernel.triton import fused_add_layernorm_scale_shift
 
         return fused_add_layernorm_scale_shift
+    elif name == "indexed_gate_bf16_":
+        from telefuser.kernel.triton import indexed_gate_bf16_
+
+        return indexed_gate_bf16_
+    elif name == "indexed_scale_shift_bf16_":
+        from telefuser.kernel.triton import indexed_scale_shift_bf16_
+
+        return indexed_scale_shift_bf16_
     raise ValueError(f"Unknown kernel: {name}")
 
 
@@ -297,6 +307,79 @@ def modulate(x: torch.Tensor, shift: torch.Tensor, scale: torch.Tensor) -> torch
     return fused_scale_shift(x, scale, shift, scale_constant=1.0)
 
 
+def _validate_indexed_modulation_inputs(
+    x: torch.Tensor,
+    indices: torch.Tensor,
+    *,
+    row_parameters: tuple[torch.Tensor, ...],
+    per_row_tensors: tuple[torch.Tensor, ...] = (),
+) -> None:
+    if x.ndim != 2:
+        raise ValueError("indexed modulation input must be a two-dimensional tensor")
+    if indices.ndim != 1 or indices.numel() != x.shape[0]:
+        raise ValueError("indexed modulation indices must contain one entry per input row")
+    if indices.dtype not in {torch.int32, torch.int64}:
+        raise TypeError("indexed modulation indices must use int32 or int64")
+    tensors = (*row_parameters, *per_row_tensors, indices)
+    if any(tensor.device != x.device for tensor in tensors):
+        raise ValueError("indexed modulation tensors must be on the same device")
+    if any(parameter.ndim != 2 or parameter.shape[1] != x.shape[1] for parameter in row_parameters):
+        raise ValueError("indexed modulation parameter tensors must match the input hidden dimension")
+    if any(parameter.shape[0] == 0 for parameter in row_parameters):
+        raise ValueError("indexed modulation parameter tensors must contain at least one row")
+    parameter_rows = row_parameters[0].shape[0]
+    if any(parameter.shape[0] != parameter_rows for parameter in row_parameters[1:]):
+        raise ValueError("indexed modulation parameter tensors must contain the same number of rows")
+    if any(tensor.shape != x.shape for tensor in per_row_tensors):
+        raise ValueError("indexed modulation per-row tensors must match the input shape")
+
+
+def indexed_scale_shift(
+    x: torch.Tensor,
+    shift: torch.Tensor,
+    scale: torch.Tensor,
+    indices: torch.Tensor,
+) -> torch.Tensor:
+    """Apply row-indexed scale and shift, reusing disposable CUDA BF16 input."""
+    _validate_indexed_modulation_inputs(x, indices, row_parameters=(shift, scale))
+    if (
+        not torch.compiler.is_compiling()
+        and x.device.type == "cuda"
+        and x.dtype == shift.dtype == scale.dtype == torch.bfloat16
+        and x.ndim == shift.ndim == scale.ndim == 2
+        and indices.ndim == 1
+        and x.is_contiguous()
+        and shift.stride(-1) == 1
+        and scale.stride(-1) == 1
+    ):
+        kernel = _get_triton_kernel("indexed_scale_shift_bf16_")
+        return kernel(x, shift, scale, indices.contiguous())
+    return x * (1 + scale.index_select(0, indices)) + shift.index_select(0, indices)
+
+
+def indexed_gate(
+    x: torch.Tensor,
+    gate: torch.Tensor,
+    other: torch.Tensor,
+    indices: torch.Tensor,
+) -> torch.Tensor:
+    """Apply a row-indexed gated residual, reusing disposable CUDA BF16 input."""
+    _validate_indexed_modulation_inputs(x, indices, row_parameters=(gate,), per_row_tensors=(other,))
+    if (
+        not torch.compiler.is_compiling()
+        and x.device.type == "cuda"
+        and x.dtype == gate.dtype == other.dtype == torch.bfloat16
+        and x.ndim == gate.ndim == other.ndim == 2
+        and indices.ndim == 1
+        and x.is_contiguous()
+        and gate.stride(-1) == 1
+        and other.is_contiguous()
+    ):
+        kernel = _get_triton_kernel("indexed_gate_bf16_")
+        return kernel(x, gate, other, indices.contiguous())
+    return x + gate.index_select(0, indices) * other
+
+
 def _fused_layer_norm_scale_shift(
     x: torch.Tensor,
     scale: torch.Tensor,
@@ -339,4 +422,6 @@ def _fused_add_layer_norm_scale_shift(
     "AdaLayerNormContinuous",
     "fused_scale_shift",
     "modulate",
+    "indexed_gate",
+    "indexed_scale_shift",
 ]
diff --git a/telefuser/ops/rotary.py b/telefuser/ops/rotary.py
index b80880f6..0ec57a1f 100644
--- a/telefuser/ops/rotary.py
+++ b/telefuser/ops/rotary.py
@@ -15,6 +15,12 @@
 
 import torch
 
+_tf_apply_rope_neox = None
+try:
+    from tf_kernel import apply_rope_with_cos_sin_cache_inplace as _tf_apply_rope_neox
+except ImportError:
+    pass
+
 
 def _apply_rotary_emb_cuda(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
     """CUDA-optimized implementation using Triton kernel."""
@@ -101,6 +107,103 @@ def _apply_rotary_emb_native(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tens
         return (x.float() * cos.float() + x_rotated.float() * sin.float()).to(x.dtype)
 
 
+def _apply_rotary_emb_neox_native(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    cos_sin_cache: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    rotary_dim = cos_sin_cache.shape[-1]
+    half = rotary_dim // 2
+    cosine = cos_sin_cache[..., :half].unsqueeze(-2).to(query.dtype)
+    sine = cos_sin_cache[..., half:].unsqueeze(-2).to(query.dtype)
+
+    def rotate(value: torch.Tensor) -> torch.Tensor:
+        rotary, passthrough = value[..., :rotary_dim], value[..., rotary_dim:]
+        first, second = rotary.chunk(2, dim=-1)
+        rotated = torch.cat((first * cosine - second * sine, second * cosine + first * sine), dim=-1)
+        return torch.cat((rotated, passthrough), dim=-1)
+
+    return rotate(query), rotate(key)
+
+
+def apply_rotary_emb_neox(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    cos_sin_cache: torch.Tensor,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Apply partial NeoX RoPE to Q and K with optional tf-kernel dispatch."""
+    if query.shape != key.shape or query.ndim != 3:
+        raise ValueError("NeoX RoPE requires matching query and key tensors with shape [sequence, heads, dim]")
+    if cos_sin_cache.ndim != 2 or cos_sin_cache.shape[0] != query.shape[0]:
+        raise ValueError("NeoX RoPE cache must have shape [sequence, rotary_dim]")
+    rotary_dim = cos_sin_cache.shape[-1]
+    if rotary_dim <= 0 or rotary_dim % 2 or rotary_dim > query.shape[-1]:
+        raise ValueError("NeoX RoPE rotary_dim must be positive, even, and no larger than the head dimension")
+
+    if not torch.compiler.is_compiling() and query.device.type == "cuda" and _tf_apply_rope_neox is not None:
+        query = query.contiguous()
+        key = key.contiguous()
+        positions = torch.arange(query.shape[0], dtype=torch.long, device=query.device)
+        _tf_apply_rope_neox(
+            positions,
+            query,
+            key,
+            head_size=query.shape[-1],
+            cos_sin_cache=cos_sin_cache.float().contiguous(),
+            is_neox=True,
+        )
+        return query, key
+
+    return _apply_rotary_emb_neox_native(query, key, cos_sin_cache)
+
+
+def apply_qk_norm_rope_neox(
+    query: torch.Tensor,
+    key: torch.Tensor,
+    q_weight: torch.Tensor,
+    k_weight: torch.Tensor,
+    cos_sin_cache: torch.Tensor,
+    *,
+    eps: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Apply Q/K RMSNorm and partial NeoX RoPE with fused eager CUDA dispatch."""
+    use_fused_cuda = (
+        not torch.compiler.is_compiling()
+        and query.device.type == "cuda"
+        and query.dtype == key.dtype == q_weight.dtype == k_weight.dtype == torch.bfloat16
+        and query.shape == key.shape
+        and query.ndim == 3
+        and q_weight.shape == k_weight.shape == (query.shape[-1],)
+        and cos_sin_cache.ndim == 2
+        and cos_sin_cache.shape[0] == query.shape[0]
+        and 0 < cos_sin_cache.shape[-1] <= query.shape[-1]
+        and cos_sin_cache.shape[-1] % 2 == 0
+        and query.stride(-1) == key.stride(-1) == 1
+        and query.stride(-2) == key.stride(-2) == query.shape[-1]
+    )
+    if use_fused_cuda:
+        from telefuser.kernel.triton import qknorm_rope_neox_bf16_
+
+        return qknorm_rope_neox_bf16_(
+            query,
+            key,
+            q_weight.contiguous(),
+            k_weight.contiguous(),
+            cos_sin_cache.contiguous(),
+            eps,
+        )
+
+    def normalize(value: torch.Tensor, weight: torch.Tensor) -> torch.Tensor:
+        variance = value.to(torch.float32).pow(2).mean(-1, keepdim=True)
+        return (value * torch.rsqrt(variance + eps)).to(weight.dtype) * weight
+
+    return _apply_rotary_emb_neox_native(
+        normalize(query, q_weight),
+        normalize(key, k_weight),
+        cos_sin_cache,
+    )
+
+
 @torch.compiler.disable
 def apply_rotary_emb(
     x: torch.Tensor,
@@ -135,4 +238,4 @@ def apply_rotary_emb(
     return _apply_rotary_emb_native(x, cos, sin)
 
 
-__all__ = ["apply_rotary_emb"]
+__all__ = ["apply_qk_norm_rope_neox", "apply_rotary_emb", "apply_rotary_emb_neox"]
diff --git a/telefuser/pipelines/minimax_h3/__init__.py b/telefuser/pipelines/minimax_h3/__init__.py
new file mode 100644
index 00000000..91f895d0
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/__init__.py
@@ -0,0 +1,29 @@
+"""MiniMax H3 pipeline contracts and stages."""
+
+from telefuser.pipelines.minimax_h3.data import minimax_h3_validate_canonical_request
+from telefuser.pipelines.minimax_h3.packed_sequence import (
+    minimax_h3_packed_sequence,
+    minimax_h3_packed_sequence_ref2va_blocks,
+)
+from telefuser.pipelines.minimax_h3.pipeline import (
+    MiniMaxH3Generation,
+    MiniMaxH3Pipeline,
+    MiniMaxH3PipelineConfig,
+)
+from telefuser.pipelines.minimax_h3.resolved_plan import (
+    MiniMaxH3ResolvedPlan,
+    minimax_h3_resolve_plan,
+)
+from telefuser.pipelines.minimax_h3.scheduler import MiniMaxH3EulerAncestralEta0SchedulerAdapter
+
+__all__ = [
+    "MiniMaxH3EulerAncestralEta0SchedulerAdapter",
+    "MiniMaxH3Generation",
+    "MiniMaxH3Pipeline",
+    "MiniMaxH3PipelineConfig",
+    "MiniMaxH3ResolvedPlan",
+    "minimax_h3_packed_sequence",
+    "minimax_h3_packed_sequence_ref2va_blocks",
+    "minimax_h3_resolve_plan",
+    "minimax_h3_validate_canonical_request",
+]
diff --git a/telefuser/pipelines/minimax_h3/canvas.py b/telefuser/pipelines/minimax_h3/canvas.py
new file mode 100644
index 00000000..40a54caa
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/canvas.py
@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 keyframe target-canvas preparation.
+
+Geometry behavior:
+- auto-aspect canvases delegate to the shared adaptive v2 shape resolver;
+- cover-crop: aspect-preserving max-scale LANCZOS resize + center crop,
+  upscaling refused unless explicitly allowed.
+
+Both Qwen presentation and the visual-condition tokenizer consume the same
+prepared canvas image supplied by the pipeline.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def minimax_h3_cover_crop_plan(
+    *,
+    source_width: int,
+    source_height: int,
+    target_width: int,
+    target_height: int,
+    allow_upscale: bool,
+) -> dict[str, Any]:
+    """Deterministic aspect-preserving cover-crop transform."""
+    if source_width <= 0 or source_height <= 0:
+        raise ValueError("cover_crop requires positive source width/height")
+    scale = max(target_width / float(source_width), target_height / float(source_height))
+    if scale > 1.0 and not allow_upscale:
+        raise ValueError(
+            "target_canvas cover_crop would upscale the source; set "
+            f"allow_upscale=true (source={source_width}x{source_height}, "
+            f"target={target_width}x{target_height})"
+        )
+    resized_width = max(target_width, int(round(source_width * scale)))
+    resized_height = max(target_height, int(round(source_height * scale)))
+    left = max(0, (resized_width - target_width) // 2)
+    top = max(0, (resized_height - target_height) // 2)
+    return {
+        "scale": scale,
+        "resized_size": (resized_width, resized_height),
+        "crop_box": (left, top, left + target_width, top + target_height),
+    }
+
+
+def minimax_h3_prepare_keyframe_canvas(
+    image: Any,
+    *,
+    target_width: int,
+    target_height: int,
+    allow_upscale: bool = False,
+) -> Any:
+    """Prepare a PIL image onto the target canvas.
+
+    Identity (no resample) when the image already IS the canvas.
+    """
+    from PIL import Image
+
+    image = image.convert("RGB")
+    if image.size == (target_width, target_height):
+        return image
+    plan = minimax_h3_cover_crop_plan(
+        source_width=image.size[0],
+        source_height=image.size[1],
+        target_width=target_width,
+        target_height=target_height,
+        allow_upscale=allow_upscale,
+    )
+    resized = image.resize(plan["resized_size"], Image.Resampling.LANCZOS)
+    return resized.crop(plan["crop_box"])
+
+
+def minimax_h3_stretch_keyframe_canvas(
+    image: Any,
+    *,
+    target_width: int,
+    target_height: int,
+) -> Any:
+    """Stretch the FL first frame directly onto the resolved target canvas."""
+
+    from PIL import Image
+
+    image = image.convert("RGB")
+    if image.size == (target_width, target_height):
+        return image
+    return image.resize((target_width, target_height), Image.Resampling.LANCZOS)
+
+
+__all__ = [
+    "minimax_h3_cover_crop_plan",
+    "minimax_h3_prepare_keyframe_canvas",
+    "minimax_h3_stretch_keyframe_canvas",
+]
diff --git a/telefuser/pipelines/minimax_h3/condition_noise.py b/telefuser/pipelines/minimax_h3/condition_noise.py
new file mode 100644
index 00000000..b6d31b2d
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/condition_noise.py
@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 visual/audio condition-noise augmentation.
+
+The request's condition timestep is applied to both the tensor value and the
+DiT timestep. Tokenizer artifacts remain clean
+and reusable; this module materializes the fixed noised anchors immediately
+before the denoise loop.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+from telefuser.pipelines.minimax_h3.packed_tokens import (
+    minimax_h3_patchify_video_latent,
+)
+
+# Channel-major packed audio rows always carry a stereo layout.
+MINIMAX_H3_AUDIO_COND_CHANNELS = 2
+
+
+def minimax_h3_imgvid_cond_noise_aug_rows(
+    clean_rows: torch.Tensor,
+    *,
+    condition_shapes: Sequence[Sequence[int]],
+    target_latent_t: int,
+    imgvid_cond_num_frames: int,
+    seed: int,
+    noise_aug: float,
+) -> torch.Tensor:
+    """Apply the imgvid-condition RF noise recipe to packed clean rows.
+
+    ``condition_shapes`` contains ``(latent_t, latent_h, latent_w)`` in packed
+    visual-condition order. A new CPU generator with the same row seed is
+    created for every condition. Under the dependent-noise policy, each draw
+    uses the target temporal length plus the template's imgvid-condition frame
+    count, then slices the prefix matching the current condition.
+    """
+
+    noise_aug = float(noise_aug)
+    if not 0.0 <= noise_aug <= 1.0:
+        raise ValueError(f"noise_aug must be in [0, 1], got {noise_aug}")
+    if noise_aug == 1.0:
+        return clean_rows
+    if clean_rows.ndim != 2 or int(clean_rows.shape[1]) != 96:
+        raise ValueError(f"clean imgvid condition rows must have shape [n, 96], got {list(clean_rows.shape)}")
+
+    target_latent_t = int(target_latent_t)
+    imgvid_cond_num_frames = int(imgvid_cond_num_frames)
+    if target_latent_t <= 0:
+        raise ValueError(f"target_latent_t must be positive, got {target_latent_t}")
+    if imgvid_cond_num_frames <= 0:
+        raise ValueError(
+            f"imgvid_cond_num_frames must be positive when condition rows exist, got {imgvid_cond_num_frames}"
+        )
+
+    parsed_shapes: list[tuple[int, int, int]] = []
+    expected_rows = 0
+    for raw_shape in condition_shapes:
+        if len(raw_shape) != 3:
+            raise ValueError(
+                f"each imgvid condition shape must be (latent_t, latent_h, latent_w), got {list(raw_shape)}"
+            )
+        latent_t, latent_h, latent_w = (int(value) for value in raw_shape)
+        if latent_t <= 0 or latent_h <= 0 or latent_w <= 0:
+            raise ValueError(f"imgvid condition shape must be positive, got {list(raw_shape)}")
+        if latent_h % 2 or latent_w % 2:
+            raise ValueError(
+                f"imgvid condition spatial dimensions must be divisible by 2, got {(latent_t, latent_h, latent_w)}"
+            )
+        parsed_shapes.append((latent_t, latent_h, latent_w))
+        expected_rows += latent_t * (latent_h // 2) * (latent_w // 2)
+    if not parsed_shapes:
+        raise ValueError("condition_shapes must not be empty")
+    if int(clean_rows.shape[0]) != expected_rows:
+        raise ValueError(
+            f"clean imgvid condition rows {int(clean_rows.shape[0])} != shape-derived rows {expected_rows}"
+        )
+
+    out: list[torch.Tensor] = []
+    row_offset = 0
+    timestep = torch.tensor(noise_aug, dtype=torch.float32, device=clean_rows.device)
+    for latent_t, latent_h, latent_w in parsed_shapes:
+        full_t = target_latent_t + imgvid_cond_num_frames
+        if full_t < latent_t:
+            raise ValueError(f"condition latent_t {latent_t} exceeds the noise draw length {full_t}")
+        generator = torch.Generator(device="cpu").manual_seed(int(seed))
+        noise = torch.randn(
+            1,
+            24,
+            full_t,
+            latent_h,
+            latent_w,
+            generator=generator,
+            dtype=torch.float32,
+            device="cpu",
+        )[:, :, :latent_t]
+        noise_rows = minimax_h3_patchify_video_latent(noise, patch_size=[1, 2, 2]).to(
+            device=clean_rows.device, dtype=torch.float32
+        )
+        row_count = int(noise_rows.shape[0])
+        clean_part = clean_rows[row_offset : row_offset + row_count].to(torch.float32)
+        out.append(timestep * clean_part + (1.0 - timestep) * noise_rows)
+        row_offset += row_count
+    return (out[0] if len(out) == 1 else torch.cat(out, dim=0)).contiguous()
+
+
+def minimax_h3_audio_cond_noise_aug_rows(
+    clean_rows: torch.Tensor,
+    *,
+    condition_audio_t: Sequence[int],
+    seed: int,
+    noise_aug: float,
+) -> torch.Tensor:
+    """Apply the audio-condition RF noise recipe to packed clean rows.
+
+    ``condition_audio_t`` contains the latent T of each audio-bearing
+    condition in canonical request order. Noise is drawn per condition
+    element, with a fresh CPU generator seeded with ``seed + 1`` for every
+    element.  Consequently each condition restarts the
+    same RNG stream; concatenating the rows and drawing once would be
+    numerically different for ordered multi-reference requests.
+
+    The mix is intentionally evaluated on CPU in fp32 before the packed rows
+    are transferred to the DiT device.
+    """
+
+    noise_aug = float(noise_aug)
+    if not 0.0 <= noise_aug <= 1.0:
+        raise ValueError(f"noise_aug must be in [0, 1], got {noise_aug}")
+    if noise_aug == 1.0:
+        return clean_rows
+    if clean_rows.ndim != 2 or int(clean_rows.shape[1]) != 32:
+        raise ValueError(f"clean audio condition rows must have shape [n, 32], got {list(clean_rows.shape)}")
+
+    audio_channels = MINIMAX_H3_AUDIO_COND_CHANNELS
+    parsed_audio_t = [int(value) for value in condition_audio_t]
+    if not parsed_audio_t:
+        raise ValueError("condition_audio_t must not be empty")
+    if any(value <= 0 for value in parsed_audio_t):
+        raise ValueError(f"condition audio latent lengths must be positive, got {parsed_audio_t}")
+    expected_rows = audio_channels * sum(parsed_audio_t)
+    if int(clean_rows.shape[0]) != expected_rows:
+        raise ValueError(f"clean audio condition rows {int(clean_rows.shape[0])} != shape-derived rows {expected_rows}")
+
+    out: list[torch.Tensor] = []
+    row_offset = 0
+    timestep = torch.tensor(noise_aug, dtype=torch.float32, device="cpu")
+    for audio_t in parsed_audio_t:
+        row_count = audio_channels * audio_t
+        clean_part = clean_rows[row_offset : row_offset + row_count].detach().to(device="cpu", dtype=torch.float32)
+        generator = torch.Generator(device="cpu").manual_seed(int(seed) + 1)
+        noise = torch.randn(
+            clean_part.shape,
+            generator=generator,
+            dtype=torch.float32,
+            device="cpu",
+        )
+        out.append(timestep * clean_part + (1.0 - timestep) * noise)
+        row_offset += row_count
+    rows = out[0] if len(out) == 1 else torch.cat(out, dim=0)
+    return rows.to(device=clean_rows.device, dtype=torch.float32).contiguous()
+
+
+__all__ = [
+    "minimax_h3_audio_cond_noise_aug_rows",
+    "minimax_h3_imgvid_cond_noise_aug_rows",
+]
diff --git a/telefuser/pipelines/minimax_h3/constants.py b/telefuser/pipelines/minimax_h3/constants.py
new file mode 100644
index 00000000..a16479a0
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/constants.py
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+MINIMAX_H3_CANVAS_MULTIPLE = 32
+MINIMAX_H3_SUPPORTED_FPS = 24
+MINIMAX_H3_MIN_DURATION_SECONDS = 4.0
+MINIMAX_H3_MAX_DURATION_SECONDS = 15.0
diff --git a/telefuser/pipelines/minimax_h3/data.py b/telefuser/pipelines/minimax_h3/data.py
new file mode 100644
index 00000000..e3ffde3e
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/data.py
@@ -0,0 +1,405 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 canonical request validation.
+
+Entry fail-fast for `minimax_h3.request/v1`: every violation raises ValueError
+with the offending field path. Output is a normalized canonical dict (frame
+indices validated but semantic -1 preserved, nothing else rewritten — prompt passes through verbatim and
+conditions order is semantic, never reordered).
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from telefuser.pipelines.minimax_h3.constants import (
+    MINIMAX_H3_MAX_DURATION_SECONDS,
+    MINIMAX_H3_MIN_DURATION_SECONDS,
+    MINIMAX_H3_SUPPORTED_FPS,
+)
+from telefuser.pipelines.minimax_h3.task_profiles import (
+    MINIMAX_H3_CONDITION_ROLE_KEYFRAME,
+    MINIMAX_H3_CONDITION_ROLE_REFERENCE,
+    MINIMAX_H3_FINITE_ASPECT_RATIOS,
+    MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES,
+    MINIMAX_H3_TASK_FL2VA,
+    MINIMAX_H3_TASK_REF2VA,
+    MINIMAX_H3_TASK_T2VA,
+    MiniMaxH3TaskProfile,
+    canonical_minimax_h3_task,
+    minimax_h3_task_profile,
+)
+from telefuser.pipelines.minimax_h3.time_request import (
+    minimax_h3_align_frame_count,
+)
+
+MINIMAX_H3_REQUEST_SCHEMA = "minimax_h3.request/v1"
+MINIMAX_H3_MAX_SIGNED_SEED = (1 << 63) - 1
+MINIMAX_H3_REF2VA_MAX_FILES = 12
+MINIMAX_H3_REF2VA_MAX_IMAGES = 9
+MINIMAX_H3_REF2VA_MAX_VIDEOS = 3
+MINIMAX_H3_REF2VA_MAX_AUDIO = 3
+MINIMAX_H3_REF2VA_MIN_CLIP_SECONDS = 2.0
+MINIMAX_H3_REF2VA_MAX_CLIP_SECONDS = 15.0
+MINIMAX_H3_REF2VA_MAX_TOTAL_SECONDS = 15.0
+_ALLOWED_CONDITION_KEYS = frozenset({"type", "uri", "role", "frame_index", "start_time_seconds"})
+
+
+def _require_str(value: Any, path: str) -> str:
+    if not isinstance(value, str) or value == "":
+        raise ValueError(f"{path} must be a non-empty string")
+    return value
+
+
+def _require_int(value: Any, path: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(f"{path} must be an integer")
+    return value
+
+
+def _optional_positive_finite_float(value: Any, path: str) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(f"{path} must be a number")
+    normalized = float(value)
+    if not math.isfinite(normalized) or normalized <= 0.0:
+        raise ValueError(f"{path} must be a positive finite number")
+    return normalized
+
+
+def _optional_nonnegative_finite_float(value: Any, path: str) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(f"{path} must be a number")
+    normalized = float(value)
+    if not math.isfinite(normalized) or normalized < 0.0:
+        raise ValueError(f"{path} must be a non-negative finite number")
+    return normalized
+
+
+def _validate_target(target: Any, *, profile: MiniMaxH3TaskProfile) -> dict[str, Any]:
+    path = "target"
+    if not isinstance(target, Mapping):
+        raise ValueError(f"{path} is required and must be an object")
+    # The canonical target has a deliberately small projection.  Transport
+    # compatibility keys are ignored; only these three declared values are
+    # validated and emitted below.
+    short_edge = _require_int(target.get("short_edge"), f"{path}.short_edge")
+    if short_edge != 768:
+        raise ValueError(f"{path}.short_edge must be 768 for minimax_h3, got {short_edge}")
+    aspect_ratio = _require_str(target.get("aspect_ratio"), f"{path}.aspect_ratio")
+    if profile.aspect_ratio_forced_auto and aspect_ratio != "auto":
+        raise ValueError(f'{path}.aspect_ratio must be "auto" for task {profile.task!r}, got {aspect_ratio!r}')
+    has_duration = target.get("duration_seconds") is not None
+    if (
+        profile.task in {MINIMAX_H3_TASK_T2VA, MINIMAX_H3_TASK_REF2VA}
+        and aspect_ratio != "auto"
+        and aspect_ratio not in MINIMAX_H3_FINITE_ASPECT_RATIOS
+    ):
+        raise ValueError(
+            f"{path}.aspect_ratio for task {profile.task!r} must be 'auto' or "
+            f"one of {list(MINIMAX_H3_FINITE_ASPECT_RATIOS)!r}, got "
+            f"{aspect_ratio!r}"
+        )
+    if not has_duration:
+        if not profile.duration_from_audio_reference:
+            raise ValueError(f"{path}.duration_seconds is required")
+        # ref2va: duration may derive from a reference audio; the
+        # audio-condition presence is enforced after conditions validate.
+    out: dict[str, Any] = {
+        "short_edge": short_edge,
+        "aspect_ratio": aspect_ratio,
+    }
+    if has_duration:
+        duration = target["duration_seconds"]
+        if isinstance(duration, bool) or not isinstance(duration, (int, float)):
+            raise ValueError(f"{path}.duration_seconds must be a number")
+        if duration <= 0:
+            raise ValueError(f"{path}.duration_seconds must be positive")
+        if not (MINIMAX_H3_MIN_DURATION_SECONDS <= float(duration) <= MINIMAX_H3_MAX_DURATION_SECONDS):
+            raise ValueError(
+                f"{path}.duration_seconds must be in "
+                f"[{MINIMAX_H3_MIN_DURATION_SECONDS:g}, "
+                f"{MINIMAX_H3_MAX_DURATION_SECONDS:g}], got {duration}"
+            )
+        out["duration_seconds"] = float(duration)
+    return out
+
+
+def _validate_conditions(
+    conditions: Any,
+    *,
+    profile: MiniMaxH3TaskProfile,
+    frame_count: int | None,
+) -> list[dict[str, Any]]:
+    path = "conditions"
+    if conditions is None:
+        conditions = []
+    if not isinstance(conditions, Sequence) or isinstance(conditions, (str, bytes)):
+        raise ValueError(f"{path} must be a list")
+
+    if not profile.conditions_required:
+        if len(conditions) > 0:
+            raise ValueError(f"{path} must be empty for task {profile.task!r} (got {len(conditions)} entries)")
+        return []
+    if len(conditions) == 0:
+        raise ValueError(f"{path} requires at least one entry for task {profile.task!r}")
+    if profile.min_condition_count is not None and len(conditions) < profile.min_condition_count:
+        raise ValueError(
+            f"{path} requires at least {profile.min_condition_count} entries "
+            f"for task {profile.task!r}, got {len(conditions)}"
+        )
+    if profile.max_condition_count is not None and len(conditions) > profile.max_condition_count:
+        raise ValueError(
+            f"{path} allows at most {profile.max_condition_count} entries "
+            f"for task {profile.task!r}, got {len(conditions)}"
+        )
+
+    aligned_frame_count = minimax_h3_align_frame_count(frame_count) if frame_count is not None else None
+    normalized: list[dict[str, Any]] = []
+    seen_frame_indices: dict[int, int] = {}
+    for index, cond in enumerate(conditions):
+        cpath = f"{path}[{index}]"
+        if not isinstance(cond, Mapping):
+            raise ValueError(f"{cpath} must be an object")
+        unknown = set(cond) - _ALLOWED_CONDITION_KEYS
+        if unknown:
+            raise ValueError(f"{cpath} has unknown fields: {sorted(unknown)}")
+        role = _require_str(cond.get("role"), f"{cpath}.role")
+        if role not in (
+            MINIMAX_H3_CONDITION_ROLE_KEYFRAME,
+            MINIMAX_H3_CONDITION_ROLE_REFERENCE,
+        ):
+            raise ValueError(f"{cpath}.role must be keyframe or reference, got {role!r}")
+        cond_type = _require_str(cond.get("type"), f"{cpath}.type")
+        try:
+            rule = profile.rule_for(role=role, condition_type=cond_type)
+        except ValueError as exc:
+            raise ValueError(f"{cpath}: {exc}") from exc
+        uri = _require_str(cond.get("uri"), f"{cpath}.uri")
+
+        entry: dict[str, Any] = {"type": cond_type, "uri": uri, "role": role}
+        if rule.requires_frame_index:
+            frame_index = _require_int(cond.get("frame_index"), f"{cpath}.frame_index")
+            if aligned_frame_count is None:
+                raise ValueError(f"{cpath}.frame_index requires a resolved target duration")
+            if frame_index == -1:
+                resolved = aligned_frame_count - 1
+            elif 0 <= frame_index < aligned_frame_count:
+                resolved = frame_index
+            else:
+                raise ValueError(
+                    f"{cpath}.frame_index must be -1 or in "
+                    f"[0, {aligned_frame_count}) after 17n+5 frame alignment, "
+                    f"got {frame_index}"
+                )
+            if resolved in seen_frame_indices:
+                raise ValueError(
+                    f"{cpath}.frame_index resolves to {resolved}, already "
+                    f"bound by conditions[{seen_frame_indices[resolved]}]"
+                )
+            seen_frame_indices[resolved] = index
+            # Preserve the request-level semantic index.  In particular, -1 is
+            # the canonical last-frame sentinel; the resolved pixel frame is
+            # carried separately by MiniMaxH3ResolvedPlan.
+            entry["frame_index"] = frame_index
+        elif cond.get("frame_index") is not None:
+            raise ValueError(f"{cpath}.frame_index is not allowed for role={role!r}")
+        start_time_seconds = _optional_nonnegative_finite_float(
+            cond.get("start_time_seconds"), f"{cpath}.start_time_seconds"
+        )
+        if start_time_seconds is not None:
+            if cond_type not in {"video", "video_audio"}:
+                raise ValueError(f"{cpath}.start_time_seconds is only allowed for video or video_audio references")
+            entry["start_time_seconds"] = start_time_seconds
+        normalized.append(entry)
+    return normalized
+
+
+def _validate_fl2va_conditions(conditions: Sequence[Mapping[str, Any]]) -> None:
+    """Enforce the public FL contract after per-entry schema validation."""
+
+    frame_indices = tuple(condition.get("frame_index") for condition in conditions)
+    if frame_indices not in MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES:
+        raise ValueError(
+            "conditions for task 'fl2va' must be one or two ordered "
+            "image/keyframe entries with frame_index [0], [-1], or [0, -1], "
+            f"got {list(frame_indices)!r}"
+        )
+
+
+def _validate_ref2va_conditions(conditions: Sequence[Mapping[str, Any]]) -> None:
+    if len(conditions) > MINIMAX_H3_REF2VA_MAX_FILES:
+        raise ValueError(
+            f"conditions allows at most {MINIMAX_H3_REF2VA_MAX_FILES} files for task 'ref2va', got {len(conditions)}"
+        )
+    image_count = sum(condition["type"] == "image" for condition in conditions)
+    video_count = sum(condition["type"] in {"video", "video_audio"} for condition in conditions)
+    audio_count = sum(condition["type"] in {"audio", "video_audio"} for condition in conditions)
+    if image_count > MINIMAX_H3_REF2VA_MAX_IMAGES:
+        raise ValueError(
+            f"conditions allows at most {MINIMAX_H3_REF2VA_MAX_IMAGES} image references, got {image_count}"
+        )
+    if video_count > MINIMAX_H3_REF2VA_MAX_VIDEOS:
+        raise ValueError(
+            f"conditions allows at most {MINIMAX_H3_REF2VA_MAX_VIDEOS} video references, got {video_count}"
+        )
+    if audio_count > MINIMAX_H3_REF2VA_MAX_AUDIO:
+        raise ValueError(f"conditions allows at most {MINIMAX_H3_REF2VA_MAX_AUDIO} audio references, got {audio_count}")
+    has_visual = any(condition["type"] in {"image", "video", "video_audio"} for condition in conditions)
+    if audio_count and not has_visual:
+        raise ValueError("conditions audio references require at least one image or video reference")
+
+
+def minimax_h3_validate_reference_media_facts(
+    conditions: Sequence[Mapping[str, Any]],
+    *,
+    video_duration_seconds_by_condition: Mapping[int, float],
+    audio_duration_seconds_by_condition: Mapping[int, float],
+) -> None:
+    """Validate Ref2VA clip and aggregate durations after local media probing."""
+
+    video_total = 0.0
+    audio_total = 0.0
+    for index, condition in enumerate(conditions):
+        condition_type = condition.get("type")
+        if condition_type in {"video", "video_audio"}:
+            video_total += _validated_reference_duration(
+                video_duration_seconds_by_condition,
+                index=index,
+                stream_name="video",
+            )
+        if condition_type in {"audio", "video_audio"}:
+            audio_total += _validated_reference_duration(
+                audio_duration_seconds_by_condition,
+                index=index,
+                stream_name="audio",
+            )
+    if video_total > MINIMAX_H3_REF2VA_MAX_TOTAL_SECONDS:
+        raise ValueError(
+            f"reference video total duration must not exceed {MINIMAX_H3_REF2VA_MAX_TOTAL_SECONDS:g} seconds, "
+            f"got {video_total:g}"
+        )
+    if audio_total > MINIMAX_H3_REF2VA_MAX_TOTAL_SECONDS:
+        raise ValueError(
+            f"reference audio total duration must not exceed {MINIMAX_H3_REF2VA_MAX_TOTAL_SECONDS:g} seconds, "
+            f"got {audio_total:g}"
+        )
+
+
+def _validated_reference_duration(
+    durations: Mapping[int, float],
+    *,
+    index: int,
+    stream_name: str,
+) -> float:
+    if index not in durations:
+        raise ValueError(f"conditions[{index}] is missing probed {stream_name} duration")
+    duration = durations[index]
+    if isinstance(duration, bool) or not isinstance(duration, (int, float)) or not math.isfinite(duration):
+        raise ValueError(f"conditions[{index}] {stream_name} duration must be a finite number")
+    duration = float(duration)
+    if not MINIMAX_H3_REF2VA_MIN_CLIP_SECONDS <= duration <= MINIMAX_H3_REF2VA_MAX_CLIP_SECONDS:
+        raise ValueError(
+            f"conditions[{index}] {stream_name} duration must be in "
+            f"[{MINIMAX_H3_REF2VA_MIN_CLIP_SECONDS:g}, {MINIMAX_H3_REF2VA_MAX_CLIP_SECONDS:g}] seconds, "
+            f"got {duration:g}"
+        )
+    return duration
+
+
+def minimax_h3_validate_canonical_request(
+    *,
+    task: Any,
+    prompt: Any,
+    conditions: Any,
+    target: Any,
+    flow_shift: Any = None,
+    audio_flow_shift: Any = None,
+    seed: Any = None,
+    **_extra_kwargs: Any,
+) -> dict[str, Any]:
+    """Validate and normalize a `minimax_h3.request/v1` canonical request.
+
+    Returns the normalized canonical dict; raises ValueError with a field
+    path on any violation. Conditions order is preserved (it is semantic:
+    prompt ordinal labels reference it). seed=0 is a legal value.
+    """
+    # Accept transport wrappers and compatibility kwargs at this boundary, but
+    # never copy them into the canonical request.
+    del _extra_kwargs
+    # Normalize the task name before profile lookup so offline callers match
+    # the adapter behaviour.
+    task_name = canonical_minimax_h3_task(_require_str(task, "task"))
+    profile = minimax_h3_task_profile(task_name)
+    prompt_text = _require_str(prompt, "prompt")
+
+    normalized_target = _validate_target(target, profile=profile)
+    requested_frame_count = None
+    if normalized_target.get("duration_seconds") is not None:
+        requested_frame_count = int(round(float(normalized_target["duration_seconds"]) * MINIMAX_H3_SUPPORTED_FPS))
+    normalized_conditions = _validate_conditions(
+        conditions,
+        profile=profile,
+        frame_count=requested_frame_count,
+    )
+    if profile.task == MINIMAX_H3_TASK_FL2VA:
+        _validate_fl2va_conditions(normalized_conditions)
+    elif profile.task == MINIMAX_H3_TASK_REF2VA:
+        _validate_ref2va_conditions(normalized_conditions)
+    # ref2va accepts ordered material streams containing any mix of
+    # image/audio/video/video_audio references. Type admission is handled by
+    # the task profile; temporal ambiguity is validated later when target
+    # duration is omitted.
+    if not profile.video_reference_supported:
+        for index, cond in enumerate(normalized_conditions):
+            if cond["type"] in ("video", "video_audio"):
+                raise ValueError(
+                    f"conditions[{index}]: video references are not supported "
+                    f"in v1 for task {profile.task!r} (image/audio only)"
+                )
+    if normalized_target.get("duration_seconds") is None:
+        # Only reachable for duration_from_audio_reference profiles.
+        duration_sources = [cond for cond in normalized_conditions if cond["type"] in ("audio", "video", "video_audio")]
+        if not duration_sources:
+            raise ValueError(
+                "target.duration_seconds is required, or exactly one "
+                "audio reference to derive duration from (including "
+                f"video/video_audio soundtracks; task {profile.task!r})"
+            )
+        if len(duration_sources) > 1:
+            raise ValueError("target.duration_seconds is required when multiple audio-bearing references are provided")
+
+    canonical: dict[str, Any] = {
+        "schema": MINIMAX_H3_REQUEST_SCHEMA,
+        "task": task_name,
+        "prompt": prompt_text,
+        "conditions": normalized_conditions,
+        "target": normalized_target,
+    }
+    normalized_flow_shift = _optional_positive_finite_float(flow_shift, "flow_shift")
+    normalized_audio_flow_shift = _optional_positive_finite_float(audio_flow_shift, "audio_flow_shift")
+    if normalized_flow_shift is not None:
+        canonical["flow_shift"] = normalized_flow_shift
+    if normalized_audio_flow_shift is not None:
+        canonical["audio_flow_shift"] = normalized_audio_flow_shift
+    if seed is not None:
+        normalized_seed = _require_int(seed, "seed")
+        if normalized_seed < 0:
+            raise ValueError(f"seed must be non-negative, got {normalized_seed}")
+        if normalized_seed > MINIMAX_H3_MAX_SIGNED_SEED:
+            raise ValueError(f"seed must not exceed the signed int64 maximum, got {normalized_seed}")
+        canonical["seed"] = normalized_seed
+    return canonical
+
+
+__all__ = [
+    "MINIMAX_H3_REQUEST_SCHEMA",
+    "MINIMAX_H3_MAX_SIGNED_SEED",
+    "MINIMAX_H3_SUPPORTED_FPS",
+    "minimax_h3_validate_canonical_request",
+    "minimax_h3_validate_reference_media_facts",
+]
diff --git a/telefuser/pipelines/minimax_h3/denoising.py b/telefuser/pipelines/minimax_h3/denoising.py
new file mode 100644
index 00000000..b9fa00bc
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/denoising.py
@@ -0,0 +1,565 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Packed single-branch MiniMax H3 denoising stage."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+
+from telefuser.core.base_stage import BaseStage, with_model_offload
+from telefuser.core.config import ModelRuntimeConfig, WeightOffloadType
+from telefuser.core.module_manager import ModuleManager
+from telefuser.distributed.device_mesh import create_device_mesh_from_config, get_ulysses_rank, get_ulysses_world_size
+from telefuser.distributed.fsdp import shard_model_fsdp2_inference
+from telefuser.platforms import current_platform
+from telefuser.utils.logging import logger
+
+from .condition_noise import (
+    minimax_h3_audio_cond_noise_aug_rows,
+    minimax_h3_imgvid_cond_noise_aug_rows,
+)
+from .packed_sequence import (
+    minimax_h3_packed_sequence,
+    minimax_h3_packed_sequence_ref2va_blocks,
+)
+from .packed_tokens import (
+    minimax_h3_patchify_video_latent,
+    minimax_h3_unpack_audio_tokens,
+    minimax_h3_unpatchify_video_tokens,
+)
+from .resolved_plan import MiniMaxH3ResolvedPlan
+from .scheduler import MiniMaxH3EulerAncestralEta0SchedulerAdapter
+from .text_encoding import MiniMaxH3TextCondition
+from .time_request import minimax_h3_time_shift_sigmas
+from .vae import MiniMaxH3PreparedCondition
+
+MINIMAX_H3_IMGVID_COND_TIMESTEP = 0.999
+MINIMAX_H3_AUDIO_REF_COND_TIMESTEP = 1.0
+
+
+@torch.inference_mode()
+def _minimax_h3_update_target_rows_(
+    state: torch.Tensor,
+    velocity: torch.Tensor,
+    *,
+    sigma_t: torch.Tensor,
+    sigma_curr: float,
+    sigma_ratio: torch.Tensor,
+    one_minus_sigma_ratio: torch.Tensor,
+    denoised_scratch: torch.Tensor,
+) -> None:
+    """Apply the Euler eta=0 update while reusing output and scratch storage."""
+    torch.mul(sigma_t, velocity, out=denoised_scratch)
+    torch.add(state, denoised_scratch, out=denoised_scratch)
+    if sigma_curr == 0.0:
+        return
+    torch.mul(one_minus_sigma_ratio, denoised_scratch, out=velocity)
+    torch.mul(sigma_ratio, state, out=state)
+    torch.add(state, velocity, out=state)
+
+
+def _build_local_embedding_layout(
+    *,
+    seq_len: int,
+    text_pos: torch.Tensor,
+    img_pos: torch.Tensor,
+    audio_pos: torch.Tensor,
+    world_size: int,
+    rank: int,
+    device: torch.device,
+) -> dict[str, int | torch.Tensor]:
+    """Resolve request-static packed rows owned by one Ulysses rank."""
+    if seq_len % world_size:
+        raise ValueError(f"packed seq_len {seq_len} must divide Ulysses degree {world_size}")
+    local_seq_len = seq_len // world_size
+    row_start = rank * local_seq_len
+    row_stop = row_start + local_seq_len
+
+    def local_ids(positions: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        source_ids = torch.nonzero((positions >= row_start) & (positions < row_stop), as_tuple=False).view(-1)
+        global_ids = positions.index_select(0, source_ids)
+        return source_ids.to(device), global_ids.to(device)
+
+    text_source_ids, text_global_ids = local_ids(text_pos)
+    _, img_global_ids = local_ids(img_pos)
+    _, audio_global_ids = local_ids(audio_pos)
+    return {
+        "row_start": row_start,
+        "row_stop": row_stop,
+        "text_source_ids": text_source_ids,
+        "text_row_ids": text_global_ids - row_start,
+        "img_global_ids": img_global_ids,
+        "img_row_ids": img_global_ids - row_start,
+        "audio_global_ids": audio_global_ids,
+        "audio_row_ids": audio_global_ids - row_start,
+    }
+
+
+@dataclass(frozen=True)
+class MiniMaxH3DenoiseResult:
+    video_latent: torch.Tensor
+    audio_latent: torch.Tensor
+    packed: dict[str, torch.Tensor]
+    runtime_metrics: dict[str, float | int]
+
+
+@dataclass(frozen=True)
+class MiniMaxH3DenoiseRemainder:
+    """Parent-consumed denoising outputs that do not enter video decoding."""
+
+    audio_latent: torch.Tensor
+    packed: dict[str, torch.Tensor]
+    runtime_metrics: dict[str, float | int]
+
+
+class MiniMaxH3DenoisingStage(BaseStage):
+    def __init__(self, module_manager: ModuleManager, model_runtime_config: ModelRuntimeConfig) -> None:
+        super().__init__("minimax_h3_denoising", model_runtime_config)
+        self.transformer = module_manager.fetch_module("minimax_h3_transformer")
+        if self.transformer is None:
+            raise ValueError("ModuleManager must contain 'minimax_h3_transformer'")
+        self.scheduler = MiniMaxH3EulerAncestralEta0SchedulerAdapter()
+        self.model_names = ["transformer"]
+        self._request_serial = 0
+
+    def parallel_models(self) -> None:
+        parallel_config = self.model_runtime_config.parallel_config
+        unsupported = {
+            "cfg_degree": parallel_config.cfg_degree,
+            "sp_ring_degree": parallel_config.sp_ring_degree,
+            "pp_degree": parallel_config.pp_degree,
+        }
+        invalid = {name: degree for name, degree in unsupported.items() if degree != 1}
+        if invalid:
+            raise NotImplementedError(f"MiniMax H3 does not support these parallel degrees yet: {invalid}")
+        device_mesh = create_device_mesh_from_config(parallel_config)
+        self.transformer.device_mesh = device_mesh
+        self.transformer.set_attention_config(self.model_runtime_config.attention_config)
+        if parallel_config.tp_degree > 1:
+            if parallel_config.enable_fsdp:
+                raise ValueError("MiniMax H3 DiT tensor parallelism cannot be combined with FSDP")
+            if self.model_runtime_config.offload_config.offload_type != WeightOffloadType.NO_CPU_OFFLOAD:
+                raise ValueError("MiniMax H3 DiT tensor parallelism cannot be combined with model CPU offload")
+            logger.info(f"Enabling tensor parallelism for {self.name}")
+            self.transformer.enable_tp(device_mesh)
+            self.transformer.to(self.device)
+            self.onload_models_flag = True
+            current_platform.empty_cache()
+        if parallel_config.sp_ulysses_degree > 1:
+            self.transformer.enable_usp(device_mesh)
+        if parallel_config.enable_fsdp:
+            if self.model_runtime_config.offload_config.offload_type != WeightOffloadType.NO_CPU_OFFLOAD:
+                raise ValueError("MiniMax H3 FSDP inference cannot be combined with model CPU offload")
+            logger.info(f"Enabling block FSDP2 for {self.name}")
+            fp32_parameters = [
+                parameter for parameter in self.transformer.parameters() if parameter.dtype == torch.float32
+            ]
+            self.transformer = shard_model_fsdp2_inference(
+                module=self.transformer,
+                device_mesh=device_mesh,
+                wrap_module_names=self.transformer.get_fsdp_module_names(),
+                ignored_states=fp32_parameters,
+            )
+            self.onload_models_flag = True
+            current_platform.empty_cache()
+
+    @staticmethod
+    def _reference_blocks(
+        conditions: list[MiniMaxH3PreparedCondition],
+    ) -> tuple[list[dict[str, object]], torch.Tensor | None, torch.Tensor | None]:
+        blocks: list[dict[str, object]] = []
+        visual: list[torch.Tensor] = []
+        audio: list[torch.Tensor] = []
+        for condition in conditions:
+            if condition.kind == "image":
+                if condition.visual_rows is None:
+                    raise ValueError("reference image is missing visual VAE rows")
+                blocks.append(
+                    {
+                        "kind": "image",
+                        "latent_h": condition.latent_h,
+                        "latent_w": condition.latent_w,
+                    }
+                )
+                visual.append(condition.visual_rows)
+            elif condition.kind == "audio":
+                if condition.audio_rows is None:
+                    raise ValueError("reference audio is missing audio VAE rows")
+                blocks.append({"kind": "audio", "ref_audio_t": condition.ref_audio_t})
+                audio.append(condition.audio_rows)
+            elif condition.kind in {"video", "video_audio"}:
+                if condition.visual_rows is None:
+                    raise ValueError("reference video is missing visual VAE rows")
+                blocks.append(
+                    {
+                        "kind": condition.kind,
+                        "ref_audio_t": condition.ref_audio_t,
+                        "latent_t": condition.latent_t,
+                        "latent_h": condition.latent_h,
+                        "latent_w": condition.latent_w,
+                    }
+                )
+                visual.append(condition.visual_rows)
+                if condition.audio_rows is not None:
+                    audio.append(condition.audio_rows)
+            else:
+                raise ValueError(f"unsupported reference block kind {condition.kind!r}")
+        visual_rows = None if not visual else torch.cat(visual, dim=0)
+        audio_rows = None if not audio else torch.cat(audio, dim=0)
+        return blocks, visual_rows, audio_rows
+
+    @with_model_offload(["transformer"])
+    @torch.inference_mode()
+    def denoise(
+        self,
+        *,
+        plan: MiniMaxH3ResolvedPlan,
+        text: MiniMaxH3TextCondition | dict[str, torch.Tensor],
+        conditions: list[MiniMaxH3PreparedCondition] | list[dict[str, Any]],
+        num_inference_steps: int,
+        _transport_video: bool = False,
+    ) -> MiniMaxH3DenoiseResult:
+        if isinstance(text, dict):
+            text = MiniMaxH3TextCondition(**text)
+        conditions = [
+            MiniMaxH3PreparedCondition(**condition) if isinstance(condition, dict) else condition
+            for condition in conditions
+        ]
+        shape = plan.shape
+        latent_t = int(shape["video_latent_t"])
+        latent_h = int(shape["height"]) // 16
+        latent_w = int(shape["width"]) // 16
+        audio_t = int(shape["audio_latent_t"])
+        seed = 42 if plan.seed is None else int(plan.seed)
+        if num_inference_steps < 2:
+            raise ValueError("num_inference_steps must be at least 2")
+
+        ref_blocks: list[dict[str, object]] | None = None
+        if plan.task == "ref2va":
+            ref_blocks, visual_cond, audio_cond = self._reference_blocks(conditions)
+            packed = minimax_h3_packed_sequence_ref2va_blocks(
+                text_len=text.text_len,
+                latent_t=latent_t,
+                latent_h=latent_h,
+                latent_w=latent_w,
+                audio_t=audio_t,
+                ref_blocks=ref_blocks,
+            )
+        else:
+            visual_conditions = [condition for condition in conditions if condition.visual_rows is not None]
+            visual_cond = (
+                None
+                if not visual_conditions
+                else torch.cat([condition.visual_rows for condition in visual_conditions], dim=0)
+            )
+            audio_cond = None
+            semantic_indices = tuple(
+                int(condition.material.frame_index)
+                for condition in visual_conditions
+                if condition.material.frame_index is not None
+            )
+            packed = minimax_h3_packed_sequence(
+                text_len=text.text_len,
+                latent_t=latent_t,
+                latent_h=latent_h,
+                latent_w=latent_w,
+                audio_t=audio_t,
+                include_keyframe_cond=bool(visual_conditions),
+                keyframe_frame_indices=semantic_indices if visual_conditions else None,
+                frame_count=int(shape["frame_count"]) if visual_conditions else None,
+            )
+
+        token_tags = packed["token_tags"].clone()
+        token_tags[: text.text_len] = text.token_tags
+        if bool(((token_tags < -1) | (token_tags >= 3)).any().item()):
+            raise ValueError(
+                "MiniMax H3 token_tags must contain only padding (-1), video (0), text (1), or audio (2) values"
+            )
+        condition_shapes = [
+            (condition.latent_t, condition.latent_h, condition.latent_w)
+            for condition in conditions
+            if condition.visual_rows is not None
+        ]
+        if visual_cond is not None:
+            visual_cond = minimax_h3_imgvid_cond_noise_aug_rows(
+                visual_cond,
+                condition_shapes=condition_shapes,
+                target_latent_t=latent_t,
+                imgvid_cond_num_frames=len(condition_shapes),
+                seed=seed,
+                noise_aug=MINIMAX_H3_IMGVID_COND_TIMESTEP,
+            )
+        audio_lengths = [condition.ref_audio_t for condition in conditions if condition.audio_rows is not None]
+        if audio_cond is not None:
+            audio_cond = minimax_h3_audio_cond_noise_aug_rows(
+                audio_cond,
+                condition_audio_t=audio_lengths,
+                seed=seed,
+                noise_aug=MINIMAX_H3_AUDIO_REF_COND_TIMESTEP,
+            )
+
+        video_generator = torch.Generator(device="cpu").manual_seed(seed)
+        video_native = torch.randn(
+            1,
+            24,
+            latent_t,
+            latent_h,
+            latent_w,
+            generator=video_generator,
+            dtype=torch.float32,
+        )
+        video_target = minimax_h3_patchify_video_latent(video_native, patch_size=(1, 2, 2))
+        audio_generator = torch.Generator(device="cpu").manual_seed(seed)
+        audio_target = torch.randn(audio_t * 2, 32, generator=audio_generator, dtype=torch.float32)
+
+        device = next(self.transformer.parameters()).device
+        if device.type == "cuda":
+            torch.cuda.reset_peak_memory_stats(device)
+        reset_communication_metrics = getattr(self.transformer, "reset_communication_metrics", None)
+        if callable(reset_communication_metrics):
+            reset_communication_metrics()
+        denoising_started = time.perf_counter()
+        video_rows = torch.zeros(len(packed["img_pos"]), 96, dtype=torch.float32, device=device)
+        audio_rows = torch.zeros(len(packed["audio_pos"]), 32, dtype=torch.float32, device=device)
+        video_update_cpu = packed["update_mask"]
+        audio_update_cpu = packed.get("audio_update_mask", torch.ones(len(packed["audio_pos"]), dtype=torch.bool))
+        video_update = video_update_cpu.to(device)
+        audio_update = audio_update_cpu.to(device)
+        video_rows[video_update] = video_target.to(device)
+        audio_rows[audio_update] = audio_target.to(device)
+        if visual_cond is not None:
+            video_rows[~video_update] = visual_cond.to(device)
+        if audio_cond is not None:
+            audio_rows[~audio_update] = audio_cond.to(device)
+
+        video_shift = plan.flow_shift or plan.default_flow_shift
+        audio_shift = plan.audio_flow_shift or plan.default_audio_flow_shift
+        video_sigmas = minimax_h3_time_shift_sigmas(num_steps=num_inference_steps, shift_scale=video_shift)
+        audio_sigmas = minimax_h3_time_shift_sigmas(num_steps=num_inference_steps, shift_scale=audio_shift)
+        img_pos_cpu = packed["img_pos"]
+        audio_pos_cpu = packed["audio_pos"]
+        img_pos = img_pos_cpu.to(device)
+        audio_pos = audio_pos_cpu.to(device)
+        text_pos_cpu = packed["text_pos"]
+        text_pos = text_pos_cpu.to(device)
+        target_img_pos = img_pos[video_update]
+        target_video_row_start = int((~video_update_cpu).sum())
+        target_audio_row_start = int((~audio_update_cpu).sum())
+        condition_img_pos = img_pos_cpu[~video_update_cpu]
+        target_audio_pos = audio_pos_cpu[audio_update_cpu]
+        condition_audio_pos = audio_pos_cpu[~audio_update_cpu]
+
+        seq_len = int(packed["seq_len"])
+        x = torch.zeros(1, seq_len, 96, dtype=torch.float32, device=device)
+        audio_x = torch.zeros(1, seq_len, 32, dtype=torch.float32, device=device)
+        img_position_ids = packed["img_position_ids"].unsqueeze(0).float().to(device)
+        prompt_embeds = text.hidden_states.to(device)
+        cu_seqlens = packed["cu_seqlens"].to(device)
+        block_token_tags_full = token_tags.to(device).clamp_min(0)
+        use_ulysses = bool(getattr(self.transformer, "usp_flag", False))
+        device_mesh = getattr(self.transformer, "device_mesh", None)
+        ulysses_world_size = get_ulysses_world_size(device_mesh) if use_ulysses else 1
+        ulysses_rank = get_ulysses_rank(device_mesh) if use_ulysses else 0
+        local_seq_len = seq_len // ulysses_world_size
+        local_row_start = ulysses_rank * local_seq_len
+        local_row_stop = local_row_start + local_seq_len
+        block_token_tags = block_token_tags_full[local_row_start:local_row_stop]
+        local_embedding_layout = None
+        if ulysses_world_size > 1:
+            local_embedding_layout = _build_local_embedding_layout(
+                seq_len=seq_len,
+                text_pos=text_pos_cpu,
+                img_pos=img_pos_cpu,
+                audio_pos=audio_pos_cpu,
+                world_size=ulysses_world_size,
+                rank=ulysses_rank,
+                device=device,
+            )
+
+        timestep_plan: list[tuple[torch.Tensor, torch.Tensor, torch.Tensor]] = []
+        row_timesteps = torch.empty(seq_len, dtype=torch.float32)
+        for step in range(len(video_sigmas) - 1):
+            t_video = float(1.0 - video_sigmas[step])
+            t_audio = float(1.0 - audio_sigmas[step])
+            row_timesteps.fill_(t_video)
+            row_timesteps[condition_img_pos] = max(t_video, MINIMAX_H3_IMGVID_COND_TIMESTEP)
+            row_timesteps[target_audio_pos] = t_audio
+            row_timesteps[condition_audio_pos] = max(t_audio, MINIMAX_H3_AUDIO_REF_COND_TIMESTEP)
+            unique_timesteps_cpu, inverse_indices_cpu = torch.unique(
+                row_timesteps,
+                sorted=True,
+                return_inverse=True,
+            )
+            inverse_indices = inverse_indices_cpu.to(device)
+            block_combined_indices = block_token_tags + (inverse_indices[local_row_start:local_row_stop] * 3)
+            timestep_plan.append(
+                (
+                    unique_timesteps_cpu.to(device),
+                    inverse_indices,
+                    block_combined_indices,
+                )
+            )
+
+        video_step_t = torch.tensor(
+            [float(1.0 - sigma) for sigma in video_sigmas[:-1]],
+            dtype=torch.float32,
+            device=device,
+        )
+        audio_step_t = torch.tensor(
+            [float(1.0 - sigma) for sigma in audio_sigmas[:-1]],
+            dtype=torch.float32,
+            device=device,
+        )
+        video_sigmas_device = torch.tensor(video_sigmas, dtype=torch.float32, device=device)
+        audio_sigmas_device = torch.tensor(audio_sigmas, dtype=torch.float32, device=device)
+        video_sigma_ratios = video_sigmas_device[1:] / video_sigmas_device[:-1]
+        audio_sigma_ratios = audio_sigmas_device[1:] / audio_sigmas_device[:-1]
+        video_one_minus_sigma_ratios = 1.0 - video_sigma_ratios
+        audio_one_minus_sigma_ratios = 1.0 - audio_sigma_ratios
+        video_target_slice = slice(target_video_row_start, None)
+        audio_target_slice = slice(target_audio_row_start, None)
+        video_mask_is_suffix = torch.equal(
+            video_update_cpu,
+            torch.arange(video_update_cpu.numel()) >= target_video_row_start,
+        )
+        audio_mask_is_suffix = torch.equal(
+            audio_update_cpu,
+            torch.arange(audio_update_cpu.numel()) >= target_audio_row_start,
+        )
+        optimized_update = (
+            video_mask_is_suffix and audio_mask_is_suffix and "step_denoising" not in self.scheduler.__dict__
+        )
+        video_denoised_scratch = torch.empty_like(video_rows[video_target_slice])
+        audio_denoised_scratch = torch.empty_like(audio_rows[audio_target_slice])
+        self._request_serial += 1
+        static_cache_key = self._request_serial
+
+        for step in range(len(video_sigmas) - 1):
+            t_video = float(1.0 - video_sigmas[step])
+            t_audio = float(1.0 - audio_sigmas[step])
+            unique_timesteps, inverse_indices, block_combined_indices = timestep_plan[step]
+            if step == 0 or not (video_mask_is_suffix and audio_mask_is_suffix):
+                x[0].index_copy_(0, img_pos, video_rows)
+                audio_x[0].index_copy_(0, audio_pos, audio_rows)
+            else:
+                x[0].index_copy_(0, target_img_pos, video_rows[video_target_slice])
+                audio_x[0].index_copy_(0, audio_pos[audio_update], audio_rows[audio_target_slice])
+            video_velocity, audio_velocity = self.transformer(
+                x=x,
+                audio_x=audio_x,
+                img_position_ids=img_position_ids,
+                unique_timesteps=unique_timesteps,
+                inverse_indices=inverse_indices,
+                update_mask=video_update,
+                update_audio_mask=audio_update,
+                prompt_embeds=prompt_embeds,
+                img_pos_info={"position_ids": img_pos},
+                audio_pos_info={"position_ids": audio_pos},
+                text_pos_info={"position_ids": text_pos},
+                img_pos_for_infer_output_info={"position_ids": target_img_pos},
+                packed_seq_params={"cu_seqlens_q": cu_seqlens},
+                block_token_tags=block_token_tags,
+                block_combined_indices=block_combined_indices,
+                local_embedding_layout=local_embedding_layout,
+                static_cache_key=static_cache_key,
+                skip_mask_out_condition=True,
+            )
+            audio_target_velocity = audio_velocity[audio_target_slice]
+            if optimized_update:
+                _minimax_h3_update_target_rows_(
+                    video_rows[video_target_slice],
+                    video_velocity.float(),
+                    sigma_t=video_sigmas_device[step],
+                    sigma_curr=video_sigmas[step],
+                    sigma_ratio=video_sigma_ratios[step],
+                    one_minus_sigma_ratio=video_one_minus_sigma_ratios[step],
+                    denoised_scratch=video_denoised_scratch,
+                )
+                _minimax_h3_update_target_rows_(
+                    audio_rows[audio_target_slice],
+                    audio_target_velocity.float(),
+                    sigma_t=audio_sigmas_device[step],
+                    sigma_curr=audio_sigmas[step],
+                    sigma_ratio=audio_sigma_ratios[step],
+                    one_minus_sigma_ratio=audio_one_minus_sigma_ratios[step],
+                    denoised_scratch=audio_denoised_scratch,
+                )
+            else:
+                stepped = self.scheduler.step_denoising(
+                    input_visual_latent=video_rows[video_update],
+                    input_audio_latent=audio_rows[audio_update],
+                    timestep=video_step_t[step],
+                    video_timestep=video_step_t[step],
+                    audio_timestep=audio_step_t[step],
+                    noise_pred_visual=video_velocity,
+                    noise_pred_audio=audio_target_velocity,
+                    sigma_curr=video_sigmas[step],
+                    sigma_next=video_sigmas[step + 1],
+                    video_sigma_curr=video_sigmas[step],
+                    video_sigma_next=video_sigmas[step + 1],
+                    audio_sigma_curr=audio_sigmas[step],
+                    audio_sigma_next=audio_sigmas[step + 1],
+                )
+                video_rows[video_update] = stepped["output_visual_latent"]
+                audio_rows[audio_update] = stepped["output_audio_latent"]
+
+        video_tokens = video_rows[video_update]
+        if not _transport_video:
+            video_tokens = video_tokens.cpu()
+        video_latent = minimax_h3_unpatchify_video_tokens(
+            video_tokens,
+            latent_shape=(latent_t, latent_h // 2, latent_w // 2, 24),
+            patch_size=(1, 2, 2),
+        )
+        audio_latent = minimax_h3_unpack_audio_tokens(
+            audio_rows[audio_update].cpu(),
+            audio_t=audio_t * 2,
+            audio_channel=2,
+        )
+        if device.type == "cuda":
+            torch.cuda.synchronize(device)
+            peak_allocated = int(torch.cuda.max_memory_allocated(device))
+            peak_reserved = int(torch.cuda.max_memory_reserved(device))
+        else:
+            peak_allocated = 0
+            peak_reserved = 0
+        get_communication_seconds = getattr(self.transformer, "communication_seconds", None)
+        communication_seconds = float(get_communication_seconds()) if callable(get_communication_seconds) else 0.0
+        runtime_metrics: dict[str, float | int] = {
+            "denoising_seconds": time.perf_counter() - denoising_started,
+            "peak_allocated_bytes": peak_allocated,
+            "peak_reserved_bytes": peak_reserved,
+            "communication_seconds": communication_seconds,
+        }
+        return MiniMaxH3DenoiseResult(video_latent, audio_latent, packed, runtime_metrics)
+
+    def denoise_for_video_vae(
+        self,
+        *,
+        plan: MiniMaxH3ResolvedPlan,
+        text: MiniMaxH3TextCondition | dict[str, torch.Tensor],
+        conditions: list[MiniMaxH3PreparedCondition] | list[dict[str, Any]],
+        num_inference_steps: int,
+    ) -> dict[str, Any]:
+        """Keep the video latent on device while returning parent-consumed outputs separately."""
+        result = self.denoise(
+            plan=plan,
+            text=text,
+            conditions=conditions,
+            num_inference_steps=num_inference_steps,
+            _transport_video=True,
+        )
+        return {
+            "video_latent": result.video_latent,
+            "remainder": MiniMaxH3DenoiseRemainder(
+                audio_latent=result.audio_latent,
+                packed=result.packed,
+                runtime_metrics=result.runtime_metrics,
+            ),
+        }
+
+
+__all__ = ["MiniMaxH3DenoiseRemainder", "MiniMaxH3DenoiseResult", "MiniMaxH3DenoisingStage"]
diff --git a/telefuser/pipelines/minimax_h3/example_utils.py b/telefuser/pipelines/minimax_h3/example_utils.py
new file mode 100644
index 00000000..77481cda
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/example_utils.py
@@ -0,0 +1,300 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Shared local-checkpoint loader and artifact writer for MiniMax H3 examples."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import tempfile
+import urllib.parse
+from pathlib import Path
+from typing import Any
+
+import torch
+
+from telefuser.core.config import (
+    AttentionConfig,
+    AttnImplType,
+    ModelRuntimeConfig,
+    OffloadConfig,
+    ParallelConfig,
+    WeightOffloadType,
+)
+from telefuser.core.module_manager import ModuleManager
+from telefuser.models.minimax_h3_audio_vae import MiniMaxH3AudioVAE
+from telefuser.models.minimax_h3_dit import MiniMaxH3DiT
+from telefuser.models.minimax_h3_encoder import MiniMaxH3Encoder
+from telefuser.models.minimax_h3_video_vae import MiniMaxH3VideoVAE
+from telefuser.pipelines.minimax_h3.pipeline import (
+    MiniMaxH3Generation,
+    MiniMaxH3Pipeline,
+    MiniMaxH3PipelineConfig,
+)
+from telefuser.pipelines.minimax_h3.task_profiles import partition_for_task
+from telefuser.utils.audio import save_wav
+from telefuser.utils.video import save_video
+
+MINIMAX_H3_EXAMPLE_DATA = Path(__file__).resolve().parents[3] / "examples" / "data" / "minimax-h3"
+MINIMAX_H3_DEFAULT_FL2VA_IMAGE = MINIMAX_H3_EXAMPLE_DATA / "fl2va-reference.png"
+MINIMAX_H3_DEFAULT_REF2VA_VIDEO = MINIMAX_H3_EXAMPLE_DATA / "ref2va-reference.mp4"
+MINIMAX_H3_DEFAULT_REF2VA_AUDIO = MINIMAX_H3_EXAMPLE_DATA / "ref2va-voice.mp3"
+MINIMAX_H3_DEFAULT_REQUEST = MINIMAX_H3_EXAMPLE_DATA / "ref2va.json"
+
+_REQUEST_KEYS = frozenset(
+    {
+        "task",
+        "prompt",
+        "conditions",
+        "target",
+        "seed",
+        "flow_shift",
+        "audio_flow_shift",
+        "num_inference_steps",
+    }
+)
+
+
+def load_minimax_h3_request(request_path: str | Path) -> dict[str, Any]:
+    """Load a JSON request and resolve relative material paths beside it."""
+    path = Path(request_path).expanduser().resolve()
+    with path.open(encoding="utf-8") as request_file:
+        request = json.load(request_file)
+    if not isinstance(request, dict):
+        raise ValueError("MiniMax H3 request JSON must contain an object")
+    unknown = set(request) - _REQUEST_KEYS
+    if unknown:
+        raise ValueError(f"MiniMax H3 request JSON has unknown fields: {sorted(unknown)}")
+    missing = {"task", "prompt", "target"} - set(request)
+    if missing:
+        raise ValueError(f"MiniMax H3 request JSON is missing fields: {sorted(missing)}")
+
+    resolved = dict(request)
+    conditions = request.get("conditions", [])
+    if not isinstance(conditions, list):
+        raise ValueError("MiniMax H3 request conditions must be a list")
+    resolved_conditions: list[Any] = []
+    for index, condition in enumerate(conditions):
+        if not isinstance(condition, dict):
+            raise ValueError(f"MiniMax H3 request conditions[{index}] must be an object")
+        item = dict(condition)
+        uri = item.get("uri")
+        if isinstance(uri, str) and uri and not urllib.parse.urlparse(uri).scheme and not Path(uri).is_absolute():
+            item["uri"] = str((path.parent / uri).resolve())
+        resolved_conditions.append(item)
+    resolved["conditions"] = resolved_conditions
+    return resolved
+
+
+def partition_for_minimax_h3_request(request: dict[str, Any]) -> str:
+    """Return the original checkpoint partition required by a request."""
+    return partition_for_task(request.get("task")).upper()
+
+
+def _checkpoint_shards(component: Path) -> list[str]:
+    shards = sorted(str(path) for path in component.glob("model-*.safetensors"))
+    if not shards:
+        raise FileNotFoundError(f"no model safetensor shards found in {component}")
+    return shards
+
+
+def load_minimax_h3_pipeline(
+    model_root: str | Path,
+    *,
+    partition: str,
+    device: str = "cuda:0",
+    num_inference_steps: int = 50,
+    ulysses_degree: int = 1,
+    tp_degree: int = 1,
+    text_encoder_tp_degree: int | None = None,
+    enable_fsdp: bool | None = None,
+    attn_impl: AttnImplType | str = AttnImplType.FLASH_ATTN_4,
+) -> MiniMaxH3Pipeline:
+    if partition not in {"FL2VA", "Ref2VA"}:
+        raise ValueError("partition must be 'FL2VA' or 'Ref2VA'")
+    if ulysses_degree not in {1, 2, 4}:
+        raise ValueError("ulysses_degree must be 1, 2, or 4")
+    if tp_degree not in {1, 2, 4}:
+        raise ValueError("tp_degree must be 1, 2, or 4")
+    world_size = ulysses_degree * tp_degree
+    if world_size not in {1, 2, 4}:
+        raise ValueError("ulysses_degree * tp_degree must be 1, 2, or 4")
+    resolved_encoder_tp = world_size if text_encoder_tp_degree is None else text_encoder_tp_degree
+    if resolved_encoder_tp not in {1, 2, 4}:
+        raise ValueError("text_encoder_tp_degree must be 1, 2, or 4")
+    resolved_enable_fsdp = world_size == 4 and tp_degree == 1 if enable_fsdp is None else enable_fsdp
+    if resolved_enable_fsdp and (world_size == 1 or tp_degree > 1):
+        raise ValueError("enable_fsdp requires multi-GPU sequence parallelism without tensor parallelism")
+    if isinstance(attn_impl, str):
+        try:
+            attn_impl = AttnImplType[attn_impl]
+        except KeyError as exc:
+            raise ValueError(f"unsupported attention implementation: {attn_impl}") from exc
+    component_root = Path(model_root) / partition
+    if not component_root.is_dir():
+        raise FileNotFoundError(f"MiniMax H3 partition not found: {component_root}")
+    runtime_device = torch.device(device)
+    use_resident_modules = world_size > 1 or resolved_enable_fsdp
+    resident_offload = OffloadConfig(
+        offload_type=(
+            WeightOffloadType.NO_CPU_OFFLOAD if use_resident_modules else WeightOffloadType.MODEL_CPU_OFFLOAD
+        ),
+        pin_cpu_memory=False,
+    )
+    text_parallel = (
+        ParallelConfig(
+            device_ids=list(range(resolved_encoder_tp)),
+            tp_degree=resolved_encoder_tp,
+            timeout=1800,
+        )
+        if resolved_encoder_tp > 1
+        else ParallelConfig(
+            device_ids=list(range(world_size)),
+            sp_ulysses_degree=world_size,
+            enable_fsdp=resolved_enable_fsdp,
+            timeout=1800,
+        )
+    )
+    text_runtime = ModelRuntimeConfig(
+        device_type=runtime_device.type,
+        device_id=runtime_device.index or 0,
+        torch_dtype=torch.bfloat16,
+        offload_config=resident_offload,
+        parallel_config=text_parallel,
+    )
+    dit_runtime = ModelRuntimeConfig(
+        device_type=runtime_device.type,
+        device_id=runtime_device.index or 0,
+        torch_dtype=torch.bfloat16,
+        offload_config=resident_offload,
+        attention_config=AttentionConfig.dense_attention(attn_impl),
+        parallel_config=ParallelConfig(
+            device_ids=list(range(world_size)),
+            sp_ulysses_degree=ulysses_degree,
+            tp_degree=tp_degree,
+            enable_fsdp=resolved_enable_fsdp,
+            timeout=1800,
+        ),
+    )
+    video_vae_runtime = ModelRuntimeConfig(
+        device_type=runtime_device.type,
+        device_id=runtime_device.index or 0,
+        torch_dtype=torch.float32,
+        offload_config=resident_offload,
+        parallel_config=ParallelConfig(
+            device_ids=list(range(world_size)),
+            tp_degree=world_size,
+            timeout=1800,
+        ),
+    )
+    audio_vae_runtime = ModelRuntimeConfig(
+        device_type=runtime_device.type,
+        device_id=runtime_device.index or 0,
+        torch_dtype=torch.float32,
+        offload_config=resident_offload,
+    )
+
+    manager = ModuleManager(device="cpu", torch_dtype=torch.bfloat16)
+    transformer_dir = component_root / "transformer"
+    manager.load_model(
+        _checkpoint_shards(transformer_dir),
+        device="cpu",
+        torch_dtype=torch.bfloat16,
+        low_cpu_mem_usage=True,
+        name="minimax_h3_transformer",
+        model_class=MiniMaxH3DiT,
+        converter_kwargs={"config_path": transformer_dir / "config.json"},
+    )
+    encoder_dir = component_root / "text_encoder"
+    manager.load_model(
+        _checkpoint_shards(encoder_dir),
+        device="cpu",
+        torch_dtype=torch.bfloat16,
+        low_cpu_mem_usage=True,
+        name="minimax_h3_text_encoder",
+        model_class=MiniMaxH3Encoder,
+        converter_kwargs={"config_path": encoder_dir},
+    )
+    video_vae_dir = component_root / "video_vae"
+    manager.load_model(
+        str(video_vae_dir / "source" / "model.safetensors"),
+        device="cpu",
+        torch_dtype=torch.float32,
+        low_cpu_mem_usage=True,
+        name="minimax_h3_video_vae",
+        model_class=MiniMaxH3VideoVAE,
+        converter_kwargs={"config_path": video_vae_dir},
+    )
+    audio_vae_dir = component_root / "audio_vae"
+    manager.load_model(
+        str(audio_vae_dir / "model.safetensors"),
+        device="cpu",
+        torch_dtype=torch.float32,
+        low_cpu_mem_usage=True,
+        name="minimax_h3_audio_vae",
+        model_class=MiniMaxH3AudioVAE,
+        converter_kwargs={"config_path": audio_vae_dir},
+    )
+
+    pipeline = MiniMaxH3Pipeline(device=device)
+    pipeline.init(
+        manager,
+        MiniMaxH3PipelineConfig(
+            processor_path=str(component_root / "processor"),
+            text_encoder_config=text_runtime,
+            dit_config=dit_runtime,
+            video_vae_config=video_vae_runtime,
+            audio_vae_config=audio_vae_runtime,
+            num_inference_steps=num_inference_steps,
+        ),
+    )
+    return pipeline
+
+
+def save_generation(result: MiniMaxH3Generation, output_path: str | Path) -> None:
+    output = Path(output_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    frames = result.video[0].mul(255).clamp(0, 255).to(torch.uint8)
+    waveform = result.audio[0]
+    with tempfile.TemporaryDirectory() as directory:
+        video_path = Path(directory) / "video.mp4"
+        audio_path = Path(directory) / "audio.wav"
+        save_wav(waveform, result.audio_sample_rate, str(audio_path))
+        save_video(
+            frames,
+            str(video_path),
+            fps=float(result.video_fps),
+            quality=6,
+        )
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-y",
+                "-i",
+                str(video_path),
+                "-i",
+                str(audio_path),
+                "-map",
+                "0:v:0",
+                "-map",
+                "1:a:0",
+                "-c:v",
+                "copy",
+                "-c:a",
+                "aac",
+                str(output),
+            ],
+            check=True,
+            capture_output=True,
+        )
+
+
+__all__ = [
+    "MINIMAX_H3_DEFAULT_FL2VA_IMAGE",
+    "MINIMAX_H3_DEFAULT_REF2VA_AUDIO",
+    "MINIMAX_H3_DEFAULT_REF2VA_VIDEO",
+    "MINIMAX_H3_DEFAULT_REQUEST",
+    "load_minimax_h3_pipeline",
+    "load_minimax_h3_request",
+    "partition_for_minimax_h3_request",
+    "save_generation",
+]
diff --git a/telefuser/pipelines/minimax_h3/material_io.py b/telefuser/pipelines/minimax_h3/material_io.py
new file mode 100644
index 00000000..70d75201
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/material_io.py
@@ -0,0 +1,145 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Bounded material localization and probing for MiniMax H3 requests."""
+
+from __future__ import annotations
+
+import json
+import math
+import shutil
+import subprocess
+import tempfile
+import urllib.parse
+import urllib.request
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator
+
+MINIMAX_H3_MAX_MATERIAL_BYTES = 2 * 1024**3
+
+
+@dataclass(frozen=True)
+class MiniMaxH3MaterialFacts:
+    width: int | None = None
+    height: int | None = None
+    duration_seconds: float | None = None
+    video_duration_seconds: float | None = None
+    audio_duration_seconds: float | None = None
+    sample_rate: int | None = None
+    has_audio: bool = False
+
+
+@contextmanager
+def minimax_h3_localize_material(uri: str) -> Iterator[Path]:
+    """Yield a local path for a file path, file URI, or bounded HTTP(S) URI."""
+    parsed = urllib.parse.urlparse(uri)
+    if parsed.scheme in ("", "file"):
+        path = Path(urllib.request.url2pathname(parsed.path) if parsed.scheme == "file" else uri).expanduser()
+        if not path.is_file():
+            raise FileNotFoundError(f"MiniMax H3 material not found: {path}")
+        yield path
+        return
+    if parsed.scheme not in {"http", "https"}:
+        raise ValueError(f"unsupported MiniMax H3 material URI scheme {parsed.scheme!r}")
+
+    suffix = Path(parsed.path).suffix
+    temp_dir = Path(tempfile.mkdtemp(prefix="telefuser-minimax-h3-"))
+    target = temp_dir / f"material{suffix}"
+    try:
+        request = urllib.request.Request(uri, headers={"User-Agent": "TeleFuser/1"})
+        with urllib.request.urlopen(request, timeout=60) as response, target.open("wb") as output:
+            declared = response.headers.get("Content-Length")
+            if declared is not None and int(declared) > MINIMAX_H3_MAX_MATERIAL_BYTES:
+                raise ValueError("MiniMax H3 material exceeds the 2 GiB download limit")
+            copied = 0
+            while chunk := response.read(1024 * 1024):
+                copied += len(chunk)
+                if copied > MINIMAX_H3_MAX_MATERIAL_BYTES:
+                    raise ValueError("MiniMax H3 material exceeds the 2 GiB download limit")
+                output.write(chunk)
+        yield target
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def _probe_av(path: Path) -> dict:
+    command = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration:stream=index,codec_type,width,height,sample_rate,duration",
+        "-of",
+        "json",
+        str(path),
+    ]
+    result = subprocess.run(command, check=True, capture_output=True, text=True)
+    return json.loads(result.stdout)
+
+
+def _positive_duration(value: object, *, stream_name: str, path: Path) -> float | None:
+    if value is None:
+        return None
+    try:
+        duration = float(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"{stream_name} duration is invalid for {path}: {value!r}") from exc
+    if not math.isfinite(duration) or duration <= 0:
+        raise ValueError(f"{stream_name} duration must be positive and finite for {path}, got {duration!r}")
+    return duration
+
+
+def minimax_h3_probe_material(path: Path, condition_type: str) -> MiniMaxH3MaterialFacts:
+    if condition_type == "image":
+        from PIL import Image, ImageOps
+
+        with Image.open(path) as source:
+            image = ImageOps.exif_transpose(source)
+            return MiniMaxH3MaterialFacts(width=int(image.width), height=int(image.height))
+    if condition_type not in {"audio", "video", "video_audio"}:
+        raise ValueError(f"unsupported MiniMax H3 condition type {condition_type!r}")
+    payload = _probe_av(path)
+    streams = payload.get("streams") or []
+    video = next((stream for stream in streams if stream.get("codec_type") == "video"), None)
+    audio = next((stream for stream in streams if stream.get("codec_type") == "audio"), None)
+    if condition_type in {"video", "video_audio"} and video is None:
+        raise ValueError(f"{condition_type} material has no video stream: {path}")
+    if condition_type in {"audio", "video_audio"} and audio is None:
+        raise ValueError(f"{condition_type} material has no audio stream: {path}")
+    duration_value = _positive_duration((payload.get("format") or {}).get("duration"), stream_name="media", path=path)
+    video_duration_value = _positive_duration(
+        None if video is None else video.get("duration"), stream_name="video", path=path
+    )
+    audio_duration_value = _positive_duration(
+        None if audio is None else audio.get("duration"), stream_name="audio", path=path
+    )
+    if video_duration_value is None:
+        video_duration_value = duration_value
+    if audio_duration_value is None:
+        audio_duration_value = duration_value
+    if duration_value is None:
+        duration_value = video_duration_value or audio_duration_value
+    if duration_value is None:
+        raise ValueError(f"media duration is unavailable: {path}")
+    if video is not None and video_duration_value is None:
+        raise ValueError(f"video duration is unavailable: {path}")
+    if audio is not None and audio_duration_value is None:
+        raise ValueError(f"audio duration is unavailable: {path}")
+    sample_rate = None if audio is None or audio.get("sample_rate") is None else int(audio["sample_rate"])
+    return MiniMaxH3MaterialFacts(
+        width=None if video is None else int(video["width"]),
+        height=None if video is None else int(video["height"]),
+        duration_seconds=duration_value,
+        video_duration_seconds=None if video is None else video_duration_value,
+        audio_duration_seconds=None if audio is None else audio_duration_value,
+        sample_rate=sample_rate,
+        has_audio=audio is not None,
+    )
+
+
+__all__ = [
+    "MINIMAX_H3_MAX_MATERIAL_BYTES",
+    "MiniMaxH3MaterialFacts",
+    "minimax_h3_localize_material",
+    "minimax_h3_probe_material",
+]
diff --git a/telefuser/pipelines/minimax_h3/packed_sequence.py b/telefuser/pipelines/minimax_h3/packed_sequence.py
new file mode 100644
index 00000000..5e148837
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/packed_sequence.py
@@ -0,0 +1,476 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 packed-sequence materialization from the validated workspace
+builder, covering fl2va and t2va layouts.
+
+Layout: [text L | imgvid_cond C | audio A(=t*2ch) | video_target V | pad P].
+Builder rules:
+- block-derived position infos, update masks, token tags, and cu_seqlens
+- img_position_ids fp64 grid: text rows (row_idx,0,0); video/cond t counter
+  continues text_len with temporal interp spans (frame_rescale 5/3 x
+  frame_per_token (1,4,4,4,4)); each spatial sqrt_area axis uses evenly spaced
+  coordinates excluding the right endpoint, then scales them by INTERP;
+  audio channel-major blocks pinned to the w-grid extremes.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+import numpy as np
+import torch
+
+from telefuser.pipelines.minimax_h3.task_profiles import (
+    MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES,
+)
+
+MINIMAX_H3_PACKED_SEQUENCE_ALIGNMENT = 64
+
+_INTERP = 32
+_T_GROUP = 5
+_FRAME_PER_TOKEN = (1, 4, 4, 4, 4)
+_FRAME_RESCALE = 5.0 / 3.0
+_PATCH_H = 2
+_PATCH_W = 2
+
+
+def _keyframe_cond_frame_indices(
+    *,
+    include_keyframe_cond: bool,
+    keyframe_frame_indices: list[int] | tuple[int, ...] | None,
+) -> list[int]:
+    if not include_keyframe_cond:
+        if keyframe_frame_indices is not None:
+            raise ValueError("keyframe_frame_indices must be omitted when keyframe cond is not included")
+        return []
+    if keyframe_frame_indices is None:
+        raise ValueError("strict fl2va packed layout requires keyframe_frame_indices")
+    if any(isinstance(value, bool) or not isinstance(value, int) for value in keyframe_frame_indices):
+        raise ValueError("strict fl2va packed layout requires integer keyframe_frame_indices")
+    out = list(keyframe_frame_indices)
+    if tuple(out) not in MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES:
+        raise ValueError(
+            "strict fl2va packed layout requires keyframe_frame_indices in "
+            f"{MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES!r}, got {out!r}"
+        )
+    return out
+
+
+def _resolve_keyframe_frame_indices(
+    frame_indices: Sequence[int],
+    *,
+    frame_count: int | None,
+) -> list[int]:
+    if frame_indices and frame_count is None:
+        raise ValueError("frame_count is required when keyframe_frame_indices are provided")
+    if frame_count is None:
+        return []
+    if frame_count <= 0:
+        raise ValueError("frame_count must be positive")
+    seen: dict[int, int] = {}
+    resolved: list[int] = []
+    for block_index, semantic_index in enumerate(frame_indices):
+        if semantic_index == -1:
+            resolved_index = frame_count - 1
+        elif 0 <= semantic_index < frame_count:
+            resolved_index = semantic_index
+        else:
+            raise ValueError(f"keyframe frame index {semantic_index} must be -1 or in [0, {frame_count})")
+        previous = seen.get(resolved_index)
+        if previous is not None:
+            raise ValueError(
+                f"keyframe frame index at block {block_index} resolves to "
+                f"{resolved_index}, already bound by block {previous}"
+            )
+        seen[resolved_index] = block_index
+        resolved.append(resolved_index)
+    return resolved
+
+
+def _temporal_position_span(temporal_length: int) -> float:
+    """Temporal position span for patch_t=1, in fp64.
+
+    NOTE: intentionally NOT merged with ``_video_t_span``. This variant sums
+    via numpy (pairwise summation), matching the fl2va anchor computation,
+    while ``_video_t_span`` sums sequentially, matching the ref2va
+    t-origin accumulation. The two orders diverge in the last ulp
+    from n=16 onward, so each path must keep its own summation order.
+    """
+    spans = np.ones(int(temporal_length), dtype=np.float64) * _FRAME_RESCALE
+    for token_index in range(_T_GROUP):
+        spans[token_index::_T_GROUP] *= _FRAME_PER_TOKEN[token_index]
+    return float(spans.sum())
+
+
+def minimax_h3_packed_sequence(
+    *,
+    text_len: int,
+    latent_t: int,
+    latent_h: int,
+    latent_w: int,
+    audio_t: int,
+    audio_channel: int = 2,
+    include_keyframe_cond: bool,
+    keyframe_frame_indices: list[int] | tuple[int, ...] | None = None,
+    frame_count: int | None = None,
+) -> dict[str, Any]:
+    """Build the packed-sequence structural fields for one CFG branch.
+
+    The used length is padded up to a multiple of 64.
+    """
+    ph, pw = latent_h // _PATCH_H, latent_w // _PATCH_W
+    frame_rows = ph * pw
+    cond_frame_indices = _keyframe_cond_frame_indices(
+        include_keyframe_cond=include_keyframe_cond,
+        keyframe_frame_indices=keyframe_frame_indices,
+    )
+    resolved_cond_frame_indices = _resolve_keyframe_frame_indices(
+        cond_frame_indices,
+        frame_count=frame_count,
+    )
+    cond_rows = len(cond_frame_indices) * frame_rows
+    video_rows = latent_t * frame_rows
+    audio_rows = audio_t * audio_channel
+    used = text_len + cond_rows + audio_rows + video_rows
+    seq_len = (
+        (used + MINIMAX_H3_PACKED_SEQUENCE_ALIGNMENT - 1)
+        // MINIMAX_H3_PACKED_SEQUENCE_ALIGNMENT
+        * MINIMAX_H3_PACKED_SEQUENCE_ALIGNMENT
+    )
+
+    text_sl = slice(0, text_len)
+    cond_sl = slice(text_len, text_len + cond_rows)
+    audio_sl = slice(cond_sl.stop, cond_sl.stop + audio_rows)
+    video_sl = slice(audio_sl.stop, audio_sl.stop + video_rows)
+    target_img_pos = torch.arange(video_sl.start, video_sl.stop)
+    img_pos = torch.cat([torch.arange(cond_sl.start, cond_sl.stop), target_img_pos]) if cond_rows else target_img_pos
+    update_mask = torch.zeros(img_pos.shape[0], dtype=torch.bool)
+    update_mask[cond_rows:] = True
+    audio_pos = torch.arange(audio_sl.start, audio_sl.stop)
+    text_pos = torch.arange(0, text_len)
+
+    g = torch.zeros(seq_len, 3, dtype=torch.float64)
+    g[text_sl, 0] = torch.arange(text_len, dtype=torch.float64)
+
+    t_grid = _video_t_grid(latent_t, float(text_len))
+    sqrt_area = np.sqrt(latent_h * latent_w)
+    h_grid = _axis_from_sqrt_area(latent_h, _PATCH_H, sqrt_area)
+    w_grid = _axis_from_sqrt_area(latent_w, _PATCH_W, sqrt_area)
+    hh, ww = torch.meshgrid(h_grid, w_grid, indexing="ij")
+    frame = torch.stack([hh.reshape(-1), ww.reshape(-1)], dim=-1)
+    video_g = g[video_sl].view(latent_t, frame_rows, 3)
+    video_g[:, :, 0] = t_grid[:, None]
+    video_g[:, :, 1:] = frame[None]
+    for block_index, pixel_index in enumerate(resolved_cond_frame_indices):
+        sl = slice(
+            cond_sl.start + block_index * frame_rows,
+            cond_sl.start + (block_index + 1) * frame_rows,
+        )
+        if pixel_index == 0:
+            cond_t = float(text_len)
+        elif frame_count is not None and pixel_index == frame_count - 1:
+            cond_t = float(text_len) + _temporal_position_span(latent_t) - _FRAME_RESCALE
+        else:
+            raise ValueError(
+                f"fl2va packed layout only supports first/last keyframe anchors, got resolved frame index {pixel_index}"
+            )
+        g[sl, 0] = cond_t
+        g[sl, 1:] = frame
+    audio_t_grid = float(text_len) + torch.arange(audio_t, dtype=torch.float64)
+    g[audio_sl, 0] = audio_t_grid.repeat(audio_channel)
+    g[audio_sl.start : audio_sl.start + audio_t, 2] = float(w_grid[0])
+    g[audio_sl.start + audio_t : audio_sl.stop, 2] = float(w_grid[-1])
+
+    token_tags = torch.full((seq_len,), -1, dtype=torch.long)  # PADDING
+    token_tags[text_sl] = 1  # TEXT (fl2va image-segment override happens upstream)
+    token_tags[audio_sl] = 2  # AUDIO
+    token_tags[img_pos] = 0  # VIDEO
+
+    cu = torch.tensor([0, used, seq_len], dtype=torch.int32)
+    return {
+        "seq_len": seq_len,
+        "img_pos": img_pos,
+        "audio_pos": audio_pos,
+        "text_pos": text_pos,
+        "update_mask": update_mask,
+        "img_position_ids": g,
+        "token_tags": token_tags,
+        "cu_seqlens": cu,
+    }
+
+
+def _positive_int(
+    block: Mapping[str, object],
+    key: str,
+    path: str,
+    *,
+    allow_zero: bool = False,
+) -> int:
+    value = block.get(key)
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(f"{path}.{key} must be an integer")
+    if value < 0 or (value == 0 and not allow_zero):
+        predicate = "non-negative" if allow_zero else "positive"
+        raise ValueError(f"{path}.{key} must be {predicate}")
+    return int(value)
+
+
+def _axis_from_sqrt_area(dim: int, patch: int, sqrt_area: float) -> torch.Tensor:
+    ratio = dim / sqrt_area
+    left = (1.0 - ratio) * 1.0 / 2.0
+    right = left + ratio * 1.0
+    grid = np.linspace(left, right, dim // patch, endpoint=False) * _INTERP
+    return torch.from_numpy(grid).to(torch.float64)
+
+
+def _video_t_grid(n: int, origin: float) -> torch.Tensor:
+    spans = torch.tensor(
+        [_FRAME_RESCALE * _FRAME_PER_TOKEN[k % _T_GROUP] for k in range(n)],
+        dtype=torch.float64,
+    )
+    return origin + torch.cat([torch.zeros(1, dtype=torch.float64), spans[:-1].cumsum(0)])
+
+
+def _video_t_span(n: int) -> float:
+    # Sequential fp64 summation on purpose — see _temporal_position_span for
+    # why the two span implementations must not be unified.
+    return sum(_FRAME_RESCALE * _FRAME_PER_TOKEN[k % _T_GROUP] for k in range(n))
+
+
+def _range_for_slice(sl: slice) -> torch.Tensor:
+    return torch.arange(sl.start, sl.stop, dtype=torch.long)
+
+
+def _cat_ranges(parts: list[torch.Tensor]) -> torch.Tensor:
+    if len(parts) == 1:
+        return parts[0]
+    if parts:
+        return torch.cat(parts)
+    return torch.empty(0, dtype=torch.long)
+
+
+def minimax_h3_packed_sequence_ref2va_blocks(
+    *,
+    text_len: int,
+    latent_t: int,
+    latent_h: int,
+    latent_w: int,
+    audio_t: int,
+    ref_blocks: Sequence[Mapping[str, object]],
+    audio_channel: int = 2,
+    seq_len: int | None = None,
+) -> dict[str, Any]:
+    """General ref2va-family packed layout.
+
+    ``ref_blocks`` are consumed in request/plan order:
+    - ``{"kind": "image", "latent_h": H, "latent_w": W}``
+    - ``{"kind": "audio", "ref_audio_t": T}``
+    - ``{"kind": "video"|"video_audio", "ref_audio_t": T,
+       "latent_t": RT, "latent_h": RH, "latent_w": RW}``
+
+    Video-bearing blocks pack their audio rows immediately before their video
+    rows; both share the same temporal origin and advance by the longer of the
+    audio and video spans. Standalone audio advances the target origin by its
+    own T, and image blocks advance it by one integer slot.
+    """
+    if not isinstance(ref_blocks, Sequence) or isinstance(ref_blocks, (str, bytes)):
+        raise ValueError("ref_blocks must be a sequence")
+
+    parsed: list[dict[str, object]] = []
+    ref_visual_rows = 0
+    ref_audio_rows = 0
+    for index, raw in enumerate(ref_blocks):
+        path = f"ref_blocks[{index}]"
+        if not isinstance(raw, Mapping):
+            raise ValueError(f"{path} must be an object")
+        kind = raw.get("kind", raw.get("type"))
+        if not isinstance(kind, str) or not kind:
+            raise ValueError(f"{path}.kind must be a non-empty string")
+        if kind == "image":
+            rh = _positive_int(raw, "latent_h", path)
+            rw = _positive_int(raw, "latent_w", path)
+            rows = (rh // _PATCH_H) * (rw // _PATCH_W)
+            item = {"kind": kind, "latent_h": rh, "latent_w": rw, "rows": rows}
+            ref_visual_rows += rows
+        elif kind == "audio":
+            rt = _positive_int(raw, "ref_audio_t", path, allow_zero=True)
+            rows = rt * audio_channel
+            item = {"kind": kind, "ref_audio_t": rt, "audio_rows": rows}
+            ref_audio_rows += rows
+        elif kind in ("video", "video_audio"):
+            rt = _positive_int(raw, "ref_audio_t", path, allow_zero=True)
+            vt = _positive_int(raw, "latent_t", path)
+            vh = _positive_int(raw, "latent_h", path)
+            vw = _positive_int(raw, "latent_w", path)
+            frame_rows = (vh // _PATCH_H) * (vw // _PATCH_W)
+            audio_rows = rt * audio_channel
+            video_rows = vt * frame_rows
+            item = {
+                "kind": kind,
+                "ref_audio_t": rt,
+                "latent_t": vt,
+                "latent_h": vh,
+                "latent_w": vw,
+                "frame_rows": frame_rows,
+                "audio_rows": audio_rows,
+                "video_rows": video_rows,
+            }
+            ref_audio_rows += audio_rows
+            ref_visual_rows += video_rows
+        else:
+            raise ValueError(f"{path}.kind unsupported for ref2va: {kind!r}")
+        parsed.append(item)
+
+    ph, pw = latent_h // _PATCH_H, latent_w // _PATCH_W
+    frame_rows = ph * pw
+    video_rows = latent_t * frame_rows
+    audio_rows = audio_t * audio_channel
+    ref_rows = ref_visual_rows + ref_audio_rows
+    used = text_len + ref_rows + audio_rows + video_rows
+    if seq_len is None:
+        seq_len = (
+            (used + MINIMAX_H3_PACKED_SEQUENCE_ALIGNMENT - 1)
+            // MINIMAX_H3_PACKED_SEQUENCE_ALIGNMENT
+            * MINIMAX_H3_PACKED_SEQUENCE_ALIGNMENT
+        )
+    if seq_len < used:
+        raise ValueError(f"seq_len {seq_len} < used rows {used}")
+
+    text_sl = slice(0, text_len)
+    cursor = text_len
+    block_slices: list[dict[str, object]] = []
+    for item in parsed:
+        kind = str(item["kind"])
+        if kind == "image":
+            rows = int(item["rows"])
+            visual_sl = slice(cursor, cursor + rows)
+            cursor = visual_sl.stop
+            block_slices.append({**item, "visual_sl": visual_sl})
+        elif kind == "audio":
+            rows = int(item["audio_rows"])
+            audio_sl = slice(cursor, cursor + rows)
+            cursor = audio_sl.stop
+            block_slices.append({**item, "audio_sl": audio_sl})
+        else:
+            a_rows = int(item["audio_rows"])
+            v_rows = int(item["video_rows"])
+            audio_sl = slice(cursor, cursor + a_rows)
+            visual_sl = slice(audio_sl.stop, audio_sl.stop + v_rows)
+            cursor = visual_sl.stop
+            block_slices.append({**item, "audio_sl": audio_sl, "visual_sl": visual_sl})
+
+    audio_sl = slice(cursor, cursor + audio_rows)
+    video_sl = slice(audio_sl.stop, audio_sl.stop + video_rows)
+    ref_img_pos_parts: list[torch.Tensor] = []
+    ref_audio_pos_parts: list[torch.Tensor] = []
+    g = torch.zeros(seq_len, 3, dtype=torch.float64)
+    g[text_sl, 0] = torch.arange(text_len, dtype=torch.float64)
+
+    target_area = np.sqrt(latent_h * latent_w)
+    h_grid = _axis_from_sqrt_area(latent_h, _PATCH_H, target_area)
+    w_grid = _axis_from_sqrt_area(latent_w, _PATCH_W, target_area)
+    hh, ww = torch.meshgrid(h_grid, w_grid, indexing="ij")
+    target_frame = torch.stack([hh.reshape(-1), ww.reshape(-1)], dim=-1)
+
+    t_cursor = float(text_len)
+    for item in block_slices:
+        kind = str(item["kind"])
+        if kind == "image":
+            visual_sl = item["visual_sl"]
+            assert isinstance(visual_sl, slice)
+            ref_img_pos_parts.append(_range_for_slice(visual_sl))
+            rh = int(item["latent_h"])
+            rw = int(item["latent_w"])
+            area = np.sqrt(rh * rw)
+            ref_hh, ref_ww = torch.meshgrid(
+                _axis_from_sqrt_area(rh, _PATCH_H, area),
+                _axis_from_sqrt_area(rw, _PATCH_W, area),
+                indexing="ij",
+            )
+            g[visual_sl, 0] = t_cursor
+            g[visual_sl, 1] = ref_hh.reshape(-1)
+            g[visual_sl, 2] = ref_ww.reshape(-1)
+            t_cursor += 1.0
+        elif kind == "audio":
+            audio_ref_sl = item["audio_sl"]
+            assert isinstance(audio_ref_sl, slice)
+            ref_t = int(item["ref_audio_t"])
+            ref_audio_pos_parts.append(_range_for_slice(audio_ref_sl))
+            ref_t_grid = t_cursor + torch.arange(ref_t, dtype=torch.float64)
+            g[audio_ref_sl, 0] = ref_t_grid.repeat(audio_channel)
+            if ref_t:
+                g[audio_ref_sl.start : audio_ref_sl.start + ref_t, 2] = float(w_grid[0])
+                g[audio_ref_sl.start + ref_t : audio_ref_sl.stop, 2] = float(w_grid[-1])
+            t_cursor += float(ref_t)
+        else:
+            audio_ref_sl = item["audio_sl"]
+            visual_sl = item["visual_sl"]
+            assert isinstance(audio_ref_sl, slice)
+            assert isinstance(visual_sl, slice)
+            ref_t = int(item["ref_audio_t"])
+            vt = int(item["latent_t"])
+            vh = int(item["latent_h"])
+            vw = int(item["latent_w"])
+            ref_audio_pos_parts.append(_range_for_slice(audio_ref_sl))
+            ref_img_pos_parts.append(_range_for_slice(visual_sl))
+
+            ref_area = np.sqrt(vh * vw)
+            rv_h_grid = _axis_from_sqrt_area(vh, _PATCH_H, ref_area)
+            rv_w_grid = _axis_from_sqrt_area(vw, _PATCH_W, ref_area)
+            rv_hh, rv_ww = torch.meshgrid(rv_h_grid, rv_w_grid, indexing="ij")
+
+            ref_t_grid = t_cursor + torch.arange(ref_t, dtype=torch.float64)
+            g[audio_ref_sl, 0] = ref_t_grid.repeat(audio_channel)
+            if ref_t:
+                g[audio_ref_sl.start : audio_ref_sl.start + ref_t, 2] = float(rv_w_grid[0])
+                g[audio_ref_sl.start + ref_t : audio_ref_sl.stop, 2] = float(rv_w_grid[-1])
+
+            rv_frame = torch.stack([rv_hh.reshape(-1), rv_ww.reshape(-1)], dim=-1)
+            rv_g = g[visual_sl].view(vt, int(item["frame_rows"]), 3)
+            rv_g[:, :, 0] = _video_t_grid(vt, t_cursor)[:, None]
+            rv_g[:, :, 1:] = rv_frame[None]
+            t_cursor += max(float(ref_t), _video_t_span(vt))
+
+    audio_t_grid = t_cursor + torch.arange(audio_t, dtype=torch.float64)
+    g[audio_sl, 0] = audio_t_grid.repeat(audio_channel)
+    g[audio_sl.start : audio_sl.start + audio_t, 2] = float(w_grid[0])
+    g[audio_sl.start + audio_t : audio_sl.stop, 2] = float(w_grid[-1])
+
+    video_g = g[video_sl].view(latent_t, frame_rows, 3)
+    video_g[:, :, 0] = _video_t_grid(latent_t, t_cursor)[:, None]
+    video_g[:, :, 1:] = target_frame[None]
+
+    target_img_pos = _range_for_slice(video_sl)
+    target_audio_pos = _range_for_slice(audio_sl)
+    img_pos = _cat_ranges(ref_img_pos_parts + [target_img_pos])
+    audio_pos = _cat_ranges(ref_audio_pos_parts + [target_audio_pos])
+
+    update_mask = torch.zeros(img_pos.shape[0], dtype=torch.bool)
+    update_mask[ref_visual_rows:] = True
+    audio_update_mask = torch.zeros(audio_pos.shape[0], dtype=torch.bool)
+    audio_update_mask[ref_audio_rows:] = True
+    text_pos = torch.arange(0, text_len)
+
+    token_tags = torch.full((seq_len,), -1, dtype=torch.long)  # PADDING
+    token_tags[text_sl] = 1  # TEXT
+    token_tags[audio_pos] = 2  # AUDIO (refs + target)
+    token_tags[img_pos] = 0  # VIDEO (refs + target)
+
+    cu = torch.tensor([0, used, seq_len], dtype=torch.int32)
+    return {
+        "seq_len": seq_len,
+        "img_pos": img_pos,
+        "audio_pos": audio_pos,
+        "text_pos": text_pos,
+        "update_mask": update_mask,
+        "audio_update_mask": audio_update_mask,
+        "img_position_ids": g,
+        "token_tags": token_tags,
+        "cu_seqlens": cu,
+    }
+
+
+__all__ = [
+    "minimax_h3_packed_sequence",
+    "minimax_h3_packed_sequence_ref2va_blocks",
+]
diff --git a/telefuser/pipelines/minimax_h3/packed_tokens.py b/telefuser/pipelines/minimax_h3/packed_tokens.py
new file mode 100644
index 00000000..b4a82926
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/packed_tokens.py
@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+
+
+def _int_tuple(value: Sequence[int], name: str, length: int) -> tuple[int, ...]:
+    if len(value) != length:
+        raise ValueError(f"{name} must have length {length}, got {list(value)!r}")
+    out = tuple(int(item) for item in value)
+    if any(item <= 0 for item in out):
+        raise ValueError(f"{name} values must be positive, got {list(value)!r}")
+    return out
+
+
+def _rank(tensor: torch.Tensor, name: str, rank: int) -> None:
+    if tensor.ndim != rank:
+        raise ValueError(f"{name} must be rank {rank}, got shape={list(tensor.shape)}")
+
+
+def minimax_h3_patchify_video_latent(
+    latent: torch.Tensor,
+    *,
+    patch_size: Sequence[int],
+) -> torch.Tensor:
+    """Pack SGLang video latent [B,C,T,H,W] into DiT token rows."""
+
+    _rank(latent, "video latent", 5)
+    pt, ph, pw = _int_tuple(patch_size, "patch_size", 3)
+    batch, channel, full_t, full_h, full_w = (int(dim) for dim in latent.shape)
+    if full_t % pt or full_h % ph or full_w % pw:
+        raise ValueError(
+            "video latent spatial/time dims must be divisible by patch_size: "
+            f"shape={list(latent.shape)}, patch_size={[pt, ph, pw]}"
+        )
+    t, h, w = full_t // pt, full_h // ph, full_w // pw
+    packed = latent.reshape(batch, channel, t, pt, h, ph, w, pw)
+    packed = torch.einsum("nctrhpwq->nthwcrpq", packed)
+    return packed.reshape(batch * t * h * w, channel * pt * ph * pw).contiguous()
+
+
+def minimax_h3_unpatchify_video_tokens(
+    rows: torch.Tensor,
+    *,
+    latent_shape: Sequence[int],
+    patch_size: Sequence[int],
+) -> torch.Tensor:
+    """Unpack DiT video token rows into SGLang latent [B,C,T,H,W]."""
+
+    _rank(rows, "video token rows", 2)
+    t, h, w, channel = _int_tuple(latent_shape, "latent_shape", 4)
+    pt, ph, pw = _int_tuple(patch_size, "patch_size", 3)
+    expected_dim = pt * ph * pw * channel
+    if int(rows.shape[-1]) != expected_dim:
+        raise ValueError(
+            f"video token dim {int(rows.shape[-1])} != patch volume * channel "
+            f"{expected_dim} for latent_shape={list(latent_shape)}, "
+            f"patch_size={[pt, ph, pw]}"
+        )
+    rows_per_sample = t * h * w
+    if int(rows.shape[0]) % rows_per_sample:
+        raise ValueError(
+            f"video rows {int(rows.shape[0])} must be divisible by t*h*w "
+            f"{rows_per_sample} for latent_shape={list(latent_shape)}"
+        )
+    packed = rows.reshape(-1, t, h, w, channel, pt, ph, pw)
+    latent = torch.einsum("nthwcrpq->nctrhpwq", packed)
+    return latent.reshape(-1, channel, t * pt, h * ph, w * pw).contiguous()
+
+
+def minimax_h3_unpack_audio_tokens(
+    rows: torch.Tensor,
+    *,
+    audio_t: int,
+    audio_channel: int,
+) -> torch.Tensor:
+    """Unpack DiT audio token rows into SGLang audio VAE latent [C,latent_dim,T]."""
+
+    _rank(rows, "audio token rows", 2)
+    audio_t = int(audio_t)
+    audio_channel = int(audio_channel)
+    if audio_t <= 0 or audio_channel <= 0:
+        raise ValueError(f"audio_t and audio_channel must be positive, got {audio_t=} {audio_channel=}")
+    if int(rows.shape[0]) != audio_t:
+        raise ValueError(f"audio rows {int(rows.shape[0])} != audio_t {audio_t}")
+    if audio_t % audio_channel:
+        raise ValueError(f"audio_t must be divisible by audio_channel, got {audio_t=} {audio_channel=}")
+    native = rows.reshape(audio_channel, audio_t // audio_channel, int(rows.shape[-1]))
+    return native.permute(0, 2, 1).contiguous()
+
+
+__all__ = [
+    "minimax_h3_patchify_video_latent",
+    "minimax_h3_unpack_audio_tokens",
+    "minimax_h3_unpatchify_video_tokens",
+]
diff --git a/telefuser/pipelines/minimax_h3/pipeline.py b/telefuser/pipelines/minimax_h3/pipeline.py
new file mode 100644
index 00000000..af4ca829
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/pipeline.py
@@ -0,0 +1,470 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 local T2VA, FL2VA, and Ref2VA pipeline."""
+
+from __future__ import annotations
+
+import time
+from contextlib import ExitStack
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.distributed as dist
+from transformers import AutoProcessor
+
+from telefuser.core.base_pipeline import BasePipeline
+from telefuser.core.config import ModelRuntimeConfig
+from telefuser.core.module_manager import ModuleManager
+from telefuser.worker import ParallelWorker, WorkerTensorChannel
+
+from .data import (
+    minimax_h3_validate_canonical_request,
+    minimax_h3_validate_reference_media_facts,
+)
+from .denoising import MiniMaxH3DenoisingStage
+from .material_io import (
+    MiniMaxH3MaterialFacts,
+    minimax_h3_localize_material,
+    minimax_h3_probe_material,
+)
+from .resolved_plan import (
+    MiniMaxH3ResolvedPlan,
+    minimax_h3_resolve_plan,
+    minimax_h3_resolve_spatial_shape,
+)
+from .text_encoding import MiniMaxH3TextEncodingStage
+from .vae import MiniMaxH3AudioVAEStage, MiniMaxH3PreparedCondition, MiniMaxH3VideoVAEStage
+
+
+def _fp32_runtime_config() -> ModelRuntimeConfig:
+    return ModelRuntimeConfig(torch_dtype=torch.float32)
+
+
+@dataclass
+class MiniMaxH3PipelineConfig:
+    processor_path: str
+    text_encoder_config: ModelRuntimeConfig = field(default_factory=ModelRuntimeConfig)
+    dit_config: ModelRuntimeConfig = field(default_factory=ModelRuntimeConfig)
+    video_vae_config: ModelRuntimeConfig = field(default_factory=_fp32_runtime_config)
+    audio_vae_config: ModelRuntimeConfig = field(default_factory=_fp32_runtime_config)
+    num_inference_steps: int = 50
+
+    def __post_init__(self) -> None:
+        if not self.processor_path:
+            raise ValueError("processor_path is required")
+        if self.num_inference_steps < 2:
+            raise ValueError("num_inference_steps must be at least 2")
+
+
+@dataclass(frozen=True)
+class MiniMaxH3Generation:
+    video: torch.Tensor
+    audio: torch.Tensor
+    video_fps: int
+    audio_sample_rate: int
+    plan: MiniMaxH3ResolvedPlan
+    packed_sequence_length: int
+    runtime_metrics: dict[str, float | int]
+
+
+class MiniMaxH3Pipeline(BasePipeline):
+    def __init__(self, device: str | torch.device = "cuda", torch_dtype: torch.dtype = torch.bfloat16) -> None:
+        super().__init__(device=device, torch_dtype=torch_dtype)
+        self.config: MiniMaxH3PipelineConfig | None = None
+        self.text_stage: MiniMaxH3TextEncodingStage | ParallelWorker | None = None
+        self.video_vae_stage: MiniMaxH3VideoVAEStage | ParallelWorker | None = None
+        self.audio_vae_stage: MiniMaxH3AudioVAEStage | None = None
+        self.denoising_stage: MiniMaxH3DenoisingStage | ParallelWorker | None = None
+        self._worker_tensor_channels: list[WorkerTensorChannel] = []
+        self._uses_direct_text_handoff = False
+        self._uses_direct_visual_handoff = False
+        self._uses_direct_video_latent_handoff = False
+
+    def init(self, module_manager: ModuleManager, config: MiniMaxH3PipelineConfig) -> None:
+        self.config = config
+        processor = AutoProcessor.from_pretrained(
+            config.processor_path,
+            local_files_only=True,
+            trust_remote_code=False,
+        )
+        text_stage = MiniMaxH3TextEncodingStage(
+            module_manager,
+            config.text_encoder_config,
+            processor=processor,
+        )
+        video_vae_stage = MiniMaxH3VideoVAEStage(
+            module_manager,
+            config.video_vae_config,
+        )
+        self.audio_vae_stage = MiniMaxH3AudioVAEStage(module_manager, config.audio_vae_config)
+        denoising_stage = MiniMaxH3DenoisingStage(module_manager, config.dit_config)
+
+        standalone_workers = not dist.is_initialized()
+        text_parallel = standalone_workers and config.text_encoder_config.parallel_config.world_size > 1
+        video_vae_parallel = standalone_workers and config.video_vae_config.parallel_config.world_size > 1
+        denoising_parallel = standalone_workers and config.dit_config.parallel_config.world_size > 1
+        text_to_denoise_channel = None
+        visual_to_denoise_channel = None
+        denoise_to_video_vae_channel = None
+        if denoising_parallel:
+            denoise_world_size = config.dit_config.parallel_config.world_size
+            if text_parallel:
+                text_to_denoise_channel = WorkerTensorChannel(
+                    denoise_world_size,
+                    timeout=max(
+                        config.text_encoder_config.parallel_config.timeout,
+                        config.dit_config.parallel_config.timeout,
+                    ),
+                )
+                self._worker_tensor_channels.append(text_to_denoise_channel)
+            if video_vae_parallel:
+                visual_to_denoise_channel = WorkerTensorChannel(
+                    denoise_world_size,
+                    timeout=max(
+                        config.video_vae_config.parallel_config.timeout,
+                        config.dit_config.parallel_config.timeout,
+                    ),
+                )
+                denoise_to_video_vae_channel = WorkerTensorChannel(
+                    config.video_vae_config.parallel_config.world_size,
+                    timeout=max(
+                        config.video_vae_config.parallel_config.timeout,
+                        config.dit_config.parallel_config.timeout,
+                    ),
+                )
+                self._worker_tensor_channels.extend((visual_to_denoise_channel, denoise_to_video_vae_channel))
+
+        if text_parallel:
+            self.text_stage = ParallelWorker(
+                text_stage,
+                tensor_output_channel=text_to_denoise_channel,
+                tensor_output_methods=("encode_for_denoising",) if text_to_denoise_channel is not None else (),
+            )
+        else:
+            self.text_stage = text_stage
+            if dist.is_initialized():
+                text_stage.parallel_models()
+        if video_vae_parallel:
+            self.video_vae_stage = ParallelWorker(
+                video_vae_stage,
+                tensor_output_channel=visual_to_denoise_channel,
+                tensor_output_methods=("encode_visual_for_denoising",) if visual_to_denoise_channel is not None else (),
+                tensor_input_channels=(denoise_to_video_vae_channel,)
+                if denoise_to_video_vae_channel is not None
+                else (),
+            )
+        else:
+            self.video_vae_stage = video_vae_stage
+            if dist.is_initialized():
+                video_vae_stage.parallel_models()
+        if denoising_parallel:
+            self.denoising_stage = ParallelWorker(
+                denoising_stage,
+                tensor_output_channel=denoise_to_video_vae_channel,
+                tensor_output_methods=("denoise_for_video_vae",) if denoise_to_video_vae_channel is not None else (),
+                tensor_input_channels=tuple(
+                    channel for channel in (text_to_denoise_channel, visual_to_denoise_channel) if channel is not None
+                ),
+            )
+        else:
+            self.denoising_stage = denoising_stage
+            if dist.is_initialized():
+                denoising_stage.parallel_models()
+        self._uses_direct_text_handoff = text_to_denoise_channel is not None
+        self._uses_direct_visual_handoff = visual_to_denoise_channel is not None
+        self._uses_direct_video_latent_handoff = denoise_to_video_vae_channel is not None
+        self._model_info = module_manager.get_model_info()
+
+    def _get_stages(self) -> list[object]:
+        return [
+            stage
+            for stage in (self.text_stage, self.video_vae_stage, self.audio_vae_stage, self.denoising_stage)
+            if stage is not None
+        ]
+
+    def stop(self) -> None:
+        # Release the two producer-to-DiT IPC mappings before their producer
+        # workers exit. The DiT-to-VAE channel makes fully consumer-first
+        # shutdown impossible without a worker-level release command.
+        stages = (self.denoising_stage, self.text_stage, self.video_vae_stage, self.audio_vae_stage)
+        for stage in stages:
+            if stage is None:
+                continue
+            close = getattr(stage, "close", None)
+            if callable(close):
+                close()
+        for channel in self._worker_tensor_channels:
+            channel.close()
+
+    @staticmethod
+    def _resolve_stage_result(value: Any) -> Any:
+        return value() if callable(value) else value
+
+    def _synchronize(self) -> None:
+        device = torch.device(self.device)
+        if device.type == "cuda":
+            torch.cuda.synchronize(device)
+
+    def _timed_call(self, function: Any, /, *args: Any, **kwargs: Any) -> tuple[Any, float]:
+        self._synchronize()
+        started = time.perf_counter()
+        value = function(*args, **kwargs)
+        value = self._resolve_stage_result(value)
+        self._synchronize()
+        return value, time.perf_counter() - started
+
+    @staticmethod
+    def _resolve_deferred_plan(
+        canonical: dict[str, Any],
+        facts: dict[int, MiniMaxH3MaterialFacts],
+    ) -> tuple[dict[str, Any], MiniMaxH3ResolvedPlan]:
+        MiniMaxH3Pipeline._validate_reference_start_times(canonical, facts)
+        if canonical["target"].get("duration_seconds") is None:
+            duration_sources = [
+                (index, condition)
+                for index, condition in enumerate(canonical["conditions"])
+                if condition["type"] in {"audio", "video", "video_audio"} and facts[index].has_audio
+            ]
+            if len(duration_sources) != 1:
+                raise ValueError(
+                    "audio-derived target duration requires exactly one probed "
+                    f"condition with an audio stream, got {len(duration_sources)}"
+                )
+            index, condition = duration_sources[0]
+            duration = facts[index].audio_duration_seconds
+            if duration is None:
+                raise ValueError(f"conditions[{index}] has no positive probed audio duration")
+            effective = duration - float(condition.get("start_time_seconds", 0.0))
+            canonical = minimax_h3_validate_canonical_request(
+                task=canonical["task"],
+                prompt=canonical["prompt"],
+                conditions=canonical["conditions"],
+                target={**canonical["target"], "duration_seconds": effective},
+                flow_shift=canonical.get("flow_shift"),
+                audio_flow_shift=canonical.get("audio_flow_shift"),
+                seed=canonical.get("seed"),
+            )
+        plan = minimax_h3_resolve_plan(canonical)
+        if plan.shape.get("geometry") == "deferred":
+            first = plan.materials[0]
+            item_facts = facts[int(first.condition_index)]
+            if item_facts.width is None or item_facts.height is None:
+                raise ValueError("deferred FL2VA geometry requires image width and height")
+            shape = dict(plan.shape)
+            shape.update(
+                minimax_h3_resolve_spatial_shape(
+                    width=item_facts.width,
+                    height=item_facts.height,
+                )
+            )
+            plan = replace(plan, shape=shape)
+        if plan.shape.get("geometry") != "resolved_v2":
+            raise ValueError("MiniMax H3 target geometry must resolve before model execution")
+        return canonical, plan
+
+    @staticmethod
+    def _validate_reference_start_times(
+        canonical: dict[str, Any],
+        facts: dict[int, MiniMaxH3MaterialFacts],
+    ) -> None:
+        for index, condition in enumerate(canonical["conditions"]):
+            start = float(condition.get("start_time_seconds", 0.0))
+            if start == 0.0:
+                continue
+            item_facts = facts[index]
+            video_duration = item_facts.video_duration_seconds
+            if video_duration is None or start >= video_duration:
+                raise ValueError(f"conditions[{index}].start_time_seconds must be less than the video duration")
+            if item_facts.has_audio:
+                audio_duration = item_facts.audio_duration_seconds
+                if audio_duration is None or start >= audio_duration:
+                    raise ValueError(
+                        f"conditions[{index}].start_time_seconds must be less than the soundtrack duration"
+                    )
+
+    @staticmethod
+    def _condition_labels(
+        prepared: list[MiniMaxH3PreparedCondition],
+    ) -> list[tuple[str, int]]:
+        counters = {"image": 0, "audio": 0, "video": 0}
+        labels: list[tuple[str, int]] = []
+        for condition in prepared:
+            if condition.kind == "image":
+                counters["image"] += 1
+                labels.append(("image", counters["image"]))
+            elif condition.kind == "audio":
+                counters["audio"] += 1
+                labels.append(("audio", counters["audio"]))
+            elif condition.kind in {"video", "video_audio"}:
+                if condition.has_audio:
+                    counters["audio"] += 1
+                    labels.append(("audio", counters["audio"]))
+                counters["video"] += 1
+                labels.append(("video", counters["video"]))
+        return labels
+
+    @staticmethod
+    def _condition_transport_payload(condition: MiniMaxH3PreparedCondition) -> dict[str, Any]:
+        return condition.as_denoising_payload()
+
+    @torch.inference_mode()
+    def __call__(
+        self,
+        *,
+        task: str,
+        prompt: str,
+        conditions: list[dict[str, Any]] | None,
+        target: dict[str, Any],
+        seed: int | None = None,
+        flow_shift: float | None = None,
+        audio_flow_shift: float | None = None,
+        num_inference_steps: int | None = None,
+    ) -> MiniMaxH3Generation:
+        if (
+            self.config is None
+            or self.text_stage is None
+            or self.video_vae_stage is None
+            or self.audio_vae_stage is None
+            or self.denoising_stage is None
+        ):
+            raise RuntimeError("MiniMaxH3Pipeline.init must be called before generation")
+        self._synchronize()
+        pipeline_started = time.perf_counter()
+        canonical = minimax_h3_validate_canonical_request(
+            task=task,
+            prompt=prompt,
+            conditions=[] if conditions is None else conditions,
+            target=target,
+            seed=seed,
+            flow_shift=flow_shift,
+            audio_flow_shift=audio_flow_shift,
+        )
+        with ExitStack() as stack:
+            media_started = time.perf_counter()
+            paths: dict[int, Path] = {}
+            facts: dict[int, MiniMaxH3MaterialFacts] = {}
+            for index, condition in enumerate(canonical["conditions"]):
+                path = stack.enter_context(minimax_h3_localize_material(condition["uri"]))
+                paths[index] = path
+                facts[index] = minimax_h3_probe_material(path, condition["type"])
+            if canonical["task"] == "ref2va":
+                video_duration_facts = {
+                    index: float(item.video_duration_seconds)
+                    for index, item in facts.items()
+                    if item.video_duration_seconds is not None
+                }
+                audio_duration_facts = {
+                    index: float(item.audio_duration_seconds)
+                    for index, item in facts.items()
+                    if item.audio_duration_seconds is not None
+                }
+                minimax_h3_validate_reference_media_facts(
+                    canonical["conditions"],
+                    video_duration_seconds_by_condition=video_duration_facts,
+                    audio_duration_seconds_by_condition=audio_duration_facts,
+                )
+            canonical, plan = self._resolve_deferred_plan(canonical, facts)
+            prepared = MiniMaxH3VideoVAEStage.prepare_media(plan, paths, facts)
+            self._synchronize()
+            media_preparation_seconds = time.perf_counter() - media_started
+            images = [item.image for item in prepared if item.image is not None]
+            videos = [item.video_frames for item in prepared if item.video_frames is not None]
+            text_method = (
+                self.text_stage.encode_for_denoising if self._uses_direct_text_handoff else self.text_stage.encode
+            )
+            text, text_encoding_seconds = self._timed_call(
+                text_method,
+                task=plan.task,
+                prompt=plan.prompt,
+                images=images,
+                videos=videos,
+                condition_labels=self._condition_labels(prepared),
+            )
+            visual_encoding_seconds = 0.0
+            condition_payloads: list[dict[str, Any]] | None = None
+            if any(item.image is not None or item.video_frames is not None for item in prepared):
+                if self._uses_direct_visual_handoff:
+                    condition_payloads, visual_encoding_seconds = self._timed_call(
+                        self.video_vae_stage.encode_visual_for_denoising, prepared
+                    )
+                else:
+                    prepared, visual_encoding_seconds = self._timed_call(self.video_vae_stage.encode_visual, prepared)
+            duration_seconds = float(plan.shape["frame_count"]) / float(plan.shape["fps"])
+            audio_encoding_seconds = 0.0
+            if any(item.has_audio for item in prepared):
+                prepared, audio_encoding_seconds = self._timed_call(
+                    self.audio_vae_stage.encode_audio, prepared, paths, facts, duration_seconds
+                )
+            if self._uses_direct_visual_handoff:
+                if condition_payloads is None:
+                    condition_payloads = [self._condition_transport_payload(condition) for condition in prepared]
+                else:
+                    condition_payloads = [
+                        {
+                            **payload,
+                            "audio_rows": condition.audio_rows,
+                            "ref_audio_t": condition.ref_audio_t,
+                            "has_audio": condition.has_audio,
+                        }
+                        for payload, condition in zip(condition_payloads, prepared, strict=True)
+                    ]
+                denoising_conditions: list[MiniMaxH3PreparedCondition] | list[dict[str, Any]] = condition_payloads
+            else:
+                denoising_conditions = prepared
+            steps = self.config.num_inference_steps if num_inference_steps is None else num_inference_steps
+            if isinstance(steps, bool) or not isinstance(steps, int) or steps < 2:
+                raise ValueError("num_inference_steps must be an integer of at least 2")
+            if self._uses_direct_video_latent_handoff:
+                transported, denoising_stage_seconds = self._timed_call(
+                    self.denoising_stage.denoise_for_video_vae,
+                    plan=plan,
+                    text=text,
+                    conditions=denoising_conditions,
+                    num_inference_steps=steps,
+                )
+                video_latent = transported["video_latent"]
+                denoised = transported["remainder"]
+            else:
+                denoised, denoising_stage_seconds = self._timed_call(
+                    self.denoising_stage.denoise,
+                    plan=plan,
+                    text=text,
+                    conditions=denoising_conditions,
+                    num_inference_steps=steps,
+                )
+                video_latent = denoised.video_latent
+            video_device, video_decoding_seconds = self._timed_call(self.video_vae_stage.decode_video, video_latent)
+            # Materialize exactly once in the caller. For a parallel VAE worker,
+            # video_device arrives through CUDA IPC without routing 1.5 GB of
+            # FP32 frames through multiprocessing shared-memory serialization.
+            video = video_device.cpu()
+            audio, audio_decoding_seconds = self._timed_call(self.audio_vae_stage.decode_audio, denoised.audio_latent)
+            pipeline_seconds = time.perf_counter() - pipeline_started
+            runtime_metrics = {
+                **denoised.runtime_metrics,
+                "media_preparation_seconds": media_preparation_seconds,
+                "text_encoding_seconds": text_encoding_seconds,
+                "visual_encoding_seconds": visual_encoding_seconds,
+                "audio_encoding_seconds": audio_encoding_seconds,
+                "denoising_stage_seconds": denoising_stage_seconds,
+                "video_decoding_seconds": video_decoding_seconds,
+                "audio_decoding_seconds": audio_decoding_seconds,
+                "pipeline_seconds": pipeline_seconds,
+            }
+            return MiniMaxH3Generation(
+                video=video[:, : int(plan.shape["frame_count"])],
+                audio=audio,
+                video_fps=24,
+                audio_sample_rate=32_000,
+                plan=plan,
+                packed_sequence_length=int(denoised.packed["seq_len"]),
+                runtime_metrics=runtime_metrics,
+            )
+
+
+__all__ = [
+    "MiniMaxH3Generation",
+    "MiniMaxH3Pipeline",
+    "MiniMaxH3PipelineConfig",
+]
diff --git a/telefuser/pipelines/minimax_h3/presentation.py b/telefuser/pipelines/minimax_h3/presentation.py
new file mode 100644
index 00000000..9dcd383f
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/presentation.py
@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 Qwen presentation building.
+
+Builds the positive presentation token stream:
+- fl2va: '<Picture 1>: ' label + vision block (<|vision_start|> +
+  N*<|image_pad|> + <|vision_end|>) + prompt text.
+- t2va: prompt text only (no vision block).
+Prompt text passes through verbatim (no stripping or rewriting).
+
+All presentation variants are emitted through the shared ``_Presentation``
+accumulator so ids and AdaLN token tags cannot drift apart.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import torch
+
+VISION_START = "<|vision_start|>"
+VISION_END = "<|vision_end|>"
+IMAGE_PAD = "<|image_pad|>"
+VIDEO_PAD = "<|video_pad|>"
+
+_TEXT_TAG = 1
+_VIDEO_TAG = 0
+
+
+def _text_ids(tokenizer: Any, text: str) -> list[int]:
+    return list(tokenizer(text, add_special_tokens=False)["input_ids"])
+
+
+def _vision_block_ids(tokenizer: Any, pad_token: str, count: int) -> list[int]:
+    return (
+        [tokenizer.convert_tokens_to_ids(VISION_START)]
+        + [tokenizer.convert_tokens_to_ids(pad_token)] * int(count)
+        + [tokenizer.convert_tokens_to_ids(VISION_END)]
+    )
+
+
+class _Presentation:
+    """Accumulates aligned (ids, token_tags) presentation segments."""
+
+    def __init__(self) -> None:
+        self.ids: list[int] = []
+        self.tags: list[int] = []
+
+    def text(self, token_ids: list[int]) -> None:
+        self.ids += token_ids
+        self.tags += [_TEXT_TAG] * len(token_ids)
+
+    def vision(self, token_ids: list[int]) -> None:
+        self.ids += token_ids
+        self.tags += [_VIDEO_TAG] * len(token_ids)
+
+    def build(self) -> tuple[torch.Tensor, torch.Tensor]:
+        return (
+            torch.tensor(self.ids, dtype=torch.long),
+            torch.tensor(self.tags, dtype=torch.long),
+        )
+
+
+def _timestamped_video_blocks(
+    presentation: _Presentation,
+    tokenizer: Any,
+    *,
+    counts: Sequence[int],
+    timestamps: Sequence[float],
+    context: str,
+) -> None:
+    """Emit per-temporal-block ``<{t:.1f} seconds>`` text + VIDEO vision."""
+
+    counts = [int(value) for value in counts]
+    timestamps = [float(value) for value in timestamps]
+    if not counts or len(counts) != len(timestamps):
+        raise ValueError(f"{context}video block token counts and timestamps must align")
+    for count, timestamp in zip(counts, timestamps):
+        if count <= 0:
+            raise ValueError(f"{context}video block token count must be positive")
+        presentation.text(_text_ids(tokenizer, f"<{timestamp:.1f} seconds>"))
+        presentation.vision(_vision_block_ids(tokenizer, VIDEO_PAD, count))
+
+
+def minimax_h3_text_only_ids(tokenizer: Any, prompt: str) -> torch.Tensor:
+    """t2va presentation: verbatim prompt, no special tokens."""
+    if not prompt:
+        raise ValueError("prompt must be non-empty")
+    return torch.tensor(_text_ids(tokenizer, prompt), dtype=torch.long)
+
+
+def minimax_h3_multi_image_presentation(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    image_token_counts: list[int],
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if not image_token_counts:
+        raise ValueError("image_token_counts must be non-empty")
+    presentation = _Presentation()
+    for index, count in enumerate(image_token_counts, start=1):
+        if int(count) <= 0:
+            raise ValueError("image_token_count must be positive")
+        presentation.text(_text_ids(tokenizer, f"<Picture {index}>: "))
+        presentation.vision(_vision_block_ids(tokenizer, IMAGE_PAD, count))
+    presentation.text(_text_ids(tokenizer, prompt))
+    return presentation.build()
+
+
+def minimax_h3_ref2va_presentation(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    condition_labels: list[tuple[str, int]],
+    image_token_count: int | list[int] | None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """ref2va positive presentation:
+
+    per condition in request order — image i: ``<Picture i>: `` label followed
+    by the vision block; audio j: ``<Audio j>: `` label only (audio content
+    never enters Qwen) — then the verbatim prompt. Returns (ids, token_tags)
+    with the vision block tagged VIDEO(0) and everything else TEXT(1).
+
+    condition_labels: [("image", 1), ("audio", 1), ...] with 1-based ordinals
+    per type.
+    """
+    return minimax_h3_ref2va_video_presentation(
+        tokenizer,
+        prompt=prompt,
+        condition_labels=condition_labels,
+        image_token_count=image_token_count,
+        video_block_token_counts=None,
+        video_block_timestamps=None,
+    )
+
+
+def _as_int_list(value: int | Sequence[int] | None, *, name: str) -> list[int]:
+    if value is None:
+        return []
+    if isinstance(value, int):
+        return [int(value)]
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise ValueError(f"{name} must be an int or a sequence of ints")
+    return [int(item) for item in value]
+
+
+def _as_nested_int_list(
+    value: Sequence[int] | Sequence[Sequence[int]] | None,
+    *,
+    name: str,
+) -> list[list[int]]:
+    if value is None:
+        return []
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise ValueError(f"{name} must be a sequence")
+    if len(value) == 0:
+        return []
+    first = value[0]
+    if isinstance(first, Sequence) and not isinstance(first, (str, bytes)):
+        out: list[list[int]] = []
+        for group in value:
+            if not isinstance(group, Sequence) or isinstance(group, (str, bytes)):
+                raise ValueError(f"{name} must not mix nested and flat entries")
+            out.append([int(item) for item in group])
+        return out
+    return [[int(item) for item in value]]
+
+
+def _as_nested_float_list(
+    value: Sequence[float] | Sequence[Sequence[float]] | None,
+    *,
+    name: str,
+) -> list[list[float]]:
+    if value is None:
+        return []
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        raise ValueError(f"{name} must be a sequence")
+    if len(value) == 0:
+        return []
+    first = value[0]
+    if isinstance(first, Sequence) and not isinstance(first, (str, bytes)):
+        out: list[list[float]] = []
+        for group in value:
+            if not isinstance(group, Sequence) or isinstance(group, (str, bytes)):
+                raise ValueError(f"{name} must not mix nested and flat entries")
+            out.append([float(item) for item in group])
+        return out
+    return [[float(item) for item in value]]
+
+
+def minimax_h3_ref2va_video_presentation(
+    tokenizer: Any,
+    *,
+    prompt: str,
+    condition_labels: list[tuple[str, int]],
+    image_token_count: int | list[int] | None,
+    video_block_token_counts: list[int] | list[list[int]] | None,
+    video_block_timestamps: list[float] | list[list[float]] | None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """ref2va (optionally with video refs) positive presentation:
+
+    per condition in request order —
+    - image i:  ``<Picture i>: `` label + one image vision block;
+    - audio j:  ``<Audio j>: `` label only (audio content never enters Qwen);
+    - video k:  ``<Video k>: `` label, then per temporal block a timestamp
+      text ``<{t:.1f} seconds>`` followed by a VIDEO vision block
+      (<|vision_start|> + <|video_pad|> x n + <|vision_end|>). Timestamps are
+      the mean of each merged frame pair (Qwen3VL temporal merge 2; odd frame
+      counts repeat the last frame), emitting the
+      ``<0.2 seconds>`` ..
+      ``<4.0 seconds>`` sequence — note Python bankers-rounding at .1f.
+    then the verbatim prompt. Vision blocks are tagged VIDEO(0), everything
+    else TEXT(1).
+    """
+    if not prompt:
+        raise ValueError("prompt must be non-empty")
+    presentation = _Presentation()
+    image_token_counts = _as_int_list(image_token_count, name="image_token_count")
+    video_counts_by_ref = _as_nested_int_list(
+        video_block_token_counts,
+        name="video_block_token_counts",
+    )
+    video_timestamps_by_ref = _as_nested_float_list(
+        video_block_timestamps,
+        name="video_block_timestamps",
+    )
+    if len(video_counts_by_ref) != len(video_timestamps_by_ref):
+        raise ValueError("video block token counts and timestamps must align")
+    image_seen = 0
+    video_seen = 0
+    for cond_type, ordinal in condition_labels:
+        if cond_type == "image":
+            image_seen += 1
+            if image_seen > len(image_token_counts):
+                raise ValueError("image_token_count required for an image reference")
+            count = int(image_token_counts[image_seen - 1])
+            if count <= 0:
+                raise ValueError("image_token_count required for an image reference")
+            presentation.text(_text_ids(tokenizer, f"<Picture {ordinal}>: "))
+            presentation.vision(_vision_block_ids(tokenizer, IMAGE_PAD, count))
+        elif cond_type == "audio":
+            presentation.text(_text_ids(tokenizer, f"<Audio {ordinal}>: "))
+        elif cond_type == "video":
+            video_seen += 1
+            if video_seen > len(video_counts_by_ref):
+                raise ValueError("video reference requires block token counts and timestamps")
+            counts = video_counts_by_ref[video_seen - 1]
+            timestamps = video_timestamps_by_ref[video_seen - 1]
+            if not counts or not timestamps:
+                raise ValueError("video reference requires block token counts and timestamps")
+            presentation.text(_text_ids(tokenizer, f"<Video {ordinal}>: "))
+            _timestamped_video_blocks(
+                presentation,
+                tokenizer,
+                counts=counts,
+                timestamps=timestamps,
+                context="",
+            )
+        else:
+            raise ValueError(f"unsupported ref2va condition type {cond_type!r}")
+    if image_seen != len(image_token_counts):
+        raise ValueError("unused image_token_count entries")
+    if video_seen != len(video_counts_by_ref):
+        raise ValueError("unused video block token count entries")
+    presentation.text(_text_ids(tokenizer, prompt))
+    return presentation.build()
+
+
+__all__ = [
+    "minimax_h3_multi_image_presentation",
+    "minimax_h3_ref2va_presentation",
+    "minimax_h3_ref2va_video_presentation",
+    "minimax_h3_text_only_ids",
+]
diff --git a/telefuser/pipelines/minimax_h3/resolved_plan.py b/telefuser/pipelines/minimax_h3/resolved_plan.py
new file mode 100644
index 00000000..0023c691
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/resolved_plan.py
@@ -0,0 +1,312 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 ResolvedPlan: the data-only per-request execution plan.
+
+`minimax_h3_resolve_plan` turns a validated canonical request (see
+request_validation.py) into the data-only plan consumed by stages 1-8.
+Stages never branch on task names; skips must be explicit in the plan.
+
+Scope notes (adapt_shape_v1):
+- all target and material-derived ratios use the single adaptive spatial
+  resolver exported by this module. It starts from a 768px nominal short edge,
+  applies the 768x1344 soft area cap, then rounds both axes independently to
+  the nearest 32px grid.
+- ``auto`` uses the task profile: t2va/ref2va resolve to the 16:9 policy
+  default, while fl2va defers geometry until material probe facts are
+  available. Consumers must fail fast if required evidence is missing.
+- per-modality request overrides and task defaults are retained separately so
+  the timestep stage can apply request > model config > task default priority.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from telefuser.pipelines.minimax_h3.constants import (
+    MINIMAX_H3_CANVAS_MULTIPLE,
+    MINIMAX_H3_SUPPORTED_FPS,
+)
+from telefuser.pipelines.minimax_h3.task_profiles import minimax_h3_task_profile
+from telefuser.pipelines.minimax_h3.time_request import (
+    minimax_h3_align_frame_count,
+    minimax_h3_audio_latent_t,
+    minimax_h3_video_latent_t,
+)
+
+MINIMAX_H3_SHAPE_POLICY_VERSION = "adapt_shape_v1"
+MINIMAX_H3_BASE_SHORT_EDGE = 768
+MINIMAX_H3_MAX_PIXELS = MINIMAX_H3_BASE_SHORT_EDGE * 1344
+MINIMAX_H3_MIN_ASPECT_RATIO = 1.0 / 4.0
+MINIMAX_H3_MAX_ASPECT_RATIO = 4.0
+
+
+@dataclass(frozen=True)
+class MiniMaxH3MaterialPlanItem:
+    condition_index: int
+    role: str
+    condition_type: str
+    uri: str
+    material_chain: str
+    # Request-level semantic frame index.  -1 remains the last-frame sentinel.
+    frame_index: int | None = None
+    # Concrete pixel-frame index after target 17n+5 alignment.
+    resolved_frame_index: int | None = None
+    # Per-reference seek applied identically to the visual and audio streams.
+    start_time_seconds: float = 0.0
+
+
+@dataclass(frozen=True)
+class MiniMaxH3ResolvedPlan:
+    task: str
+    prompt: str
+    seed: int | None
+    materials: tuple[MiniMaxH3MaterialPlanItem, ...]
+    default_flow_shift: float
+    default_audio_flow_shift: float
+    flow_shift: float | None
+    audio_flow_shift: float | None
+    shape: dict
+
+
+def _parse_aspect_ratio(value: str) -> tuple[int, int]:
+    parts = value.split(":")
+    if len(parts) != 2:
+        raise ValueError(f"target.aspect_ratio must be 'W:H' or 'auto', got {value!r}")
+    try:
+        w, h = int(parts[0]), int(parts[1])
+    except ValueError as exc:
+        raise ValueError(f"target.aspect_ratio must be integer 'W:H', got {value!r}") from exc
+    if w <= 0 or h <= 0:
+        raise ValueError(f"target.aspect_ratio components must be positive, got {value!r}")
+    return w, h
+
+
+def _nearest_multiple(value: float, multiple: int) -> int:
+    return max(multiple, int(round(float(value) / multiple)) * multiple)
+
+
+def _validate_base_short_edge(value: Any) -> int:
+    try:
+        short_edge = int(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError("target.short_edge must be 768") from exc
+    if short_edge != MINIMAX_H3_BASE_SHORT_EDGE or value != short_edge:
+        raise ValueError(f"target.short_edge must be 768 for MiniMax H3 shape policy v2, got {value!r}")
+    return short_edge
+
+
+def minimax_h3_resolve_spatial_shape(
+    *,
+    width: int | float,
+    height: int | float,
+    base_short_edge: int = MINIMAX_H3_BASE_SHORT_EDGE,
+) -> dict[str, Any]:
+    """Resolve one display ratio with the ``adapt_shape_v1`` math.
+
+    This is the only implementation of adaptive target geometry. Callers may
+    pass an explicit aspect-ratio pair or probed display dimensions; only the
+    ratio is significant. The supported ratio range is inclusive 1:4 to 4:1.
+    The returned dimensions are always 32px aligned; nearest-grid rounding may
+    leave the final area slightly above the pre-round soft pixel budget.
+    """
+    base_short_edge = _validate_base_short_edge(base_short_edge)
+    try:
+        source_width = float(width)
+        source_height = float(height)
+    except (TypeError, ValueError) as exc:
+        raise ValueError("shape width and height must be positive finite numbers") from exc
+    if (
+        not math.isfinite(source_width)
+        or not math.isfinite(source_height)
+        or source_width <= 0.0
+        or source_height <= 0.0
+    ):
+        raise ValueError("shape width and height must be positive finite numbers")
+
+    ratio = source_width / source_height
+    if not math.isfinite(ratio) or ratio <= 0.0:
+        raise ValueError("shape ratio must be a positive finite number")
+    if not MINIMAX_H3_MIN_ASPECT_RATIO <= ratio <= MINIMAX_H3_MAX_ASPECT_RATIO:
+        raise ValueError(
+            "adapt_shape_v1 ratio must be within the inclusive range "
+            f"1:4 to 4:1, got {source_width:g}:{source_height:g}"
+        )
+
+    if ratio >= 1.0:
+        nominal_width = float(base_short_edge) * ratio
+        nominal_height = float(base_short_edge)
+    else:
+        nominal_width = float(base_short_edge)
+        nominal_height = float(base_short_edge) / ratio
+    nominal_area = nominal_width * nominal_height
+    if nominal_area > MINIMAX_H3_MAX_PIXELS:
+        size_mode = "area"
+        scale = math.sqrt(float(MINIMAX_H3_MAX_PIXELS) / nominal_area)
+        nominal_width *= scale
+        nominal_height *= scale
+    else:
+        size_mode = "short_edge"
+
+    resolved_width = _nearest_multiple(nominal_width, MINIMAX_H3_CANVAS_MULTIPLE)
+    resolved_height = _nearest_multiple(nominal_height, MINIMAX_H3_CANVAS_MULTIPLE)
+
+    return {
+        "geometry": "resolved_v2",
+        "shape_policy_version": MINIMAX_H3_SHAPE_POLICY_VERSION,
+        "base_short_edge": base_short_edge,
+        "effective_short_edge": min(resolved_width, resolved_height),
+        "size_mode": size_mode,
+        "max_pixels": MINIMAX_H3_MAX_PIXELS,
+        "multiple": MINIMAX_H3_CANVAS_MULTIPLE,
+        "rounding": "nearest",
+        "width": resolved_width,
+        "height": resolved_height,
+    }
+
+
+def _resolve_shape(
+    target: Mapping[str, Any],
+    *,
+    geometry_source: str,
+    auto_aspect_ratio: str | None = None,
+    auto_geometry_source: str | None = None,
+) -> dict[str, Any]:
+    fps = MINIMAX_H3_SUPPORTED_FPS
+    if "duration_seconds" not in target:
+        # ref2va duration_from_audio_reference: temporal shape resolves at
+        # material time from the reference audio probe. Validation
+        # guarantees an audio condition exists.
+        shape: dict[str, Any] = {
+            "fps": fps,
+            "temporal": "deferred_from_audio_reference",
+            "geometry_source": geometry_source,
+        }
+        return _resolve_spatial(
+            shape,
+            target,
+            auto_aspect_ratio=auto_aspect_ratio,
+            auto_geometry_source=auto_geometry_source,
+        )
+    frame_count = minimax_h3_align_frame_count(int(round(float(target["duration_seconds"]) * fps)))
+    duration_seconds = frame_count / fps
+    shape = {
+        "fps": fps,
+        "frame_count": frame_count,
+        "video_latent_t": minimax_h3_video_latent_t(frame_count),
+        "audio_latent_t": minimax_h3_audio_latent_t(duration_seconds),
+        "geometry_source": geometry_source,
+    }
+    return _resolve_spatial(
+        shape,
+        target,
+        auto_aspect_ratio=auto_aspect_ratio,
+        auto_geometry_source=auto_geometry_source,
+    )
+
+
+def _resolve_spatial(
+    shape: dict[str, Any],
+    target: Mapping[str, Any],
+    *,
+    auto_aspect_ratio: str | None,
+    auto_geometry_source: str | None,
+) -> dict[str, Any]:
+    aspect_ratio = str(target["aspect_ratio"])
+    base_short_edge = _validate_base_short_edge(target.get("short_edge"))
+    if aspect_ratio == "auto":
+        if auto_aspect_ratio is None:
+            # Deferred: canvas comes from material/model geometry at prepare time.
+            shape["geometry"] = "deferred"
+            shape["geometry_source"] = auto_geometry_source or shape["geometry_source"]
+            shape["shape_policy_version"] = MINIMAX_H3_SHAPE_POLICY_VERSION
+            shape["base_short_edge"] = base_short_edge
+            shape["size_mode"] = "deferred"
+            return shape
+        aspect_ratio = auto_aspect_ratio
+        shape["geometry_source"] = auto_geometry_source or "policy_default"
+    ar_w, ar_h = _parse_aspect_ratio(aspect_ratio)
+    shape.update(
+        minimax_h3_resolve_spatial_shape(
+            width=ar_w,
+            height=ar_h,
+            base_short_edge=base_short_edge,
+        )
+    )
+    return shape
+
+
+def minimax_h3_resolve_plan(canonical: Mapping[str, Any]) -> MiniMaxH3ResolvedPlan:
+    """Canonical request (already validated) -> ResolvedPlan."""
+    if not isinstance(canonical, Mapping):
+        raise ValueError("canonical request must be a mapping")
+    allowed_keys = {
+        "schema",
+        "task",
+        "prompt",
+        "conditions",
+        "target",
+        "seed",
+        "flow_shift",
+        "audio_flow_shift",
+    }
+    unknown = set(canonical) - allowed_keys
+    if unknown:
+        raise ValueError(f"canonical request has unknown fields: {sorted(unknown)}")
+    for key in ("schema", "task", "prompt", "conditions", "target"):
+        if key not in canonical:
+            raise ValueError(f"canonical request missing {key!r}")
+    profile = minimax_h3_task_profile(str(canonical["task"]))
+    shape = _resolve_shape(
+        canonical["target"],
+        geometry_source=profile.geometry_source,
+        auto_aspect_ratio=profile.auto_aspect_ratio,
+        auto_geometry_source=profile.auto_geometry_source,
+    )
+
+    materials: list[MiniMaxH3MaterialPlanItem] = []
+    for index, cond in enumerate(canonical["conditions"]):
+        rule = profile.rule_for(role=str(cond["role"]), condition_type=str(cond["type"]))
+        frame_index = cond.get("frame_index")
+        resolved_frame_index = None
+        if rule.requires_frame_index:
+            semantic_frame_index = int(frame_index)
+            frame_count = int(shape["frame_count"])
+            resolved_frame_index = frame_count - 1 if semantic_frame_index == -1 else semantic_frame_index
+        materials.append(
+            MiniMaxH3MaterialPlanItem(
+                condition_index=index,
+                role=str(cond["role"]),
+                condition_type=str(cond["type"]),
+                uri=str(cond["uri"]),
+                material_chain=rule.material_chain,
+                frame_index=frame_index,
+                resolved_frame_index=resolved_frame_index,
+                start_time_seconds=float(cond.get("start_time_seconds", 0.0)),
+            )
+        )
+
+    return MiniMaxH3ResolvedPlan(
+        task=profile.task,
+        prompt=str(canonical["prompt"]),
+        seed=canonical.get("seed"),
+        materials=tuple(materials),
+        default_flow_shift=float(profile.default_flow_shift),
+        default_audio_flow_shift=float(profile.default_audio_flow_shift),
+        flow_shift=(float(canonical["flow_shift"]) if canonical.get("flow_shift") is not None else None),
+        audio_flow_shift=(
+            float(canonical["audio_flow_shift"]) if canonical.get("audio_flow_shift") is not None else None
+        ),
+        shape=shape,
+    )
+
+
+__all__ = [
+    "MINIMAX_H3_BASE_SHORT_EDGE",
+    "MINIMAX_H3_CANVAS_MULTIPLE",
+    "MINIMAX_H3_MAX_PIXELS",
+    "MiniMaxH3ResolvedPlan",
+    "minimax_h3_resolve_plan",
+    "minimax_h3_resolve_spatial_shape",
+]
diff --git a/telefuser/pipelines/minimax_h3/scheduler.py b/telefuser/pipelines/minimax_h3/scheduler.py
new file mode 100644
index 00000000..b5022578
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/scheduler.py
@@ -0,0 +1,207 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import torch
+
+
+def _require_finite_tensor(tensor: torch.Tensor, name: str) -> None:
+    if not bool(torch.isfinite(tensor).all().item()):
+        raise ValueError(f"{name} must be finite")
+
+
+def _validate_unit_timestep(timestep: torch.Tensor, name: str) -> None:
+    if not isinstance(timestep, torch.Tensor):
+        raise ValueError(f"{name} must be a torch.Tensor")
+    if not torch.is_floating_point(timestep):
+        raise ValueError(f"{name} must be a floating point tensor")
+    _require_finite_tensor(timestep, name)
+    out_of_range = (timestep < 0) | (timestep > 1)
+    if bool(out_of_range.any().item()):
+        raise ValueError(f"{name} must be in [0, 1]")
+
+
+def _validate_sigma(value: float, name: str) -> float:
+    sigma = float(value)
+    if not math.isfinite(sigma):
+        raise ValueError(f"{name} must be finite")
+    if sigma < 0.0:
+        raise ValueError(f"{name} must be non-negative")
+    return sigma
+
+
+def _validate_timestep_sigma_pair(
+    timestep: torch.Tensor,
+    sigma_curr: float,
+    name: str,
+) -> float:
+    _validate_unit_timestep(timestep, f"{name}_timestep")
+    sigma = _validate_sigma(sigma_curr, f"{name}_sigma_curr")
+    expected = 1.0 - timestep.detach().to(dtype=torch.float32)
+    actual = torch.full_like(expected, sigma)
+    if not torch.allclose(actual, expected, rtol=1e-5, atol=1e-5):
+        raise ValueError(f"{name}_sigma_curr must equal 1 - {name}_timestep")
+    return sigma
+
+
+def minimax_h3_rf_v_to_x0(
+    xt: torch.Tensor,
+    v: torch.Tensor,
+    timestep: torch.Tensor,
+) -> torch.Tensor:
+    if xt.shape != v.shape:
+        raise ValueError(f"xt and v shapes must match, got {xt.shape} vs {v.shape}")
+    if not torch.is_floating_point(xt):
+        raise ValueError("xt must be a floating point tensor")
+    if not torch.is_floating_point(v):
+        raise ValueError("v must be a floating point tensor")
+    _require_finite_tensor(xt, "xt")
+    _require_finite_tensor(v, "v")
+    _validate_unit_timestep(timestep, "timestep")
+    x0 = _minimax_h3_rf_v_to_x0(xt, v, timestep)
+    _require_finite_tensor(x0, "x0")
+    return x0
+
+
+def _minimax_h3_rf_v_to_x0(
+    xt: torch.Tensor,
+    v: torch.Tensor,
+    timestep: torch.Tensor,
+) -> torch.Tensor:
+    cond_t = timestep.to(device=xt.device, dtype=xt.dtype)
+    while cond_t.ndim < xt.ndim:
+        cond_t = cond_t.unsqueeze(-1)
+    sigma_t = 1 - cond_t
+    return xt + sigma_t * v
+
+
+def minimax_h3_euler_eta0_step(
+    state: torch.Tensor,
+    denoised: torch.Tensor,
+    *,
+    sigma_curr: float,
+    sigma_next: float,
+) -> torch.Tensor:
+    if state.shape != denoised.shape:
+        raise ValueError(f"state and denoised shapes must match, got {state.shape} vs {denoised.shape}")
+    if not torch.is_floating_point(state):
+        raise ValueError("state must be a floating point tensor")
+    if not torch.is_floating_point(denoised):
+        raise ValueError("denoised must be a floating point tensor")
+    _require_finite_tensor(state, "state")
+    _require_finite_tensor(denoised, "denoised")
+    sigma_curr = _validate_sigma(sigma_curr, "sigma_curr")
+    sigma_next = _validate_sigma(sigma_next, "sigma_next")
+    if sigma_curr == 0.0 and sigma_next != 0.0:
+        raise ValueError("sigma_next must be 0 when sigma_curr is 0")
+    out = _minimax_h3_euler_eta0_step(
+        state,
+        denoised,
+        sigma_curr=sigma_curr,
+        sigma_next=sigma_next,
+    )
+    _require_finite_tensor(out, "euler_eta0_step output")
+    return out
+
+
+def _minimax_h3_euler_eta0_step(
+    state: torch.Tensor,
+    denoised: torch.Tensor,
+    *,
+    sigma_curr: float,
+    sigma_next: float,
+    sigma_ratio: torch.Tensor | None = None,
+) -> torch.Tensor:
+    if sigma_curr == 0.0:
+        return state
+    compute_dtype = torch.float32
+    if state.dtype not in (torch.float16, torch.bfloat16):
+        compute_dtype = state.dtype
+    if sigma_ratio is None:
+        sigma_curr_t = state.new_tensor(sigma_curr, dtype=compute_dtype)
+        sigma_next_t = state.new_tensor(sigma_next, dtype=compute_dtype)
+        ratio = sigma_next_t / sigma_curr_t
+    else:
+        ratio = sigma_ratio.to(device=state.device, dtype=compute_dtype)
+    out = ratio * state.to(dtype=compute_dtype) + (1.0 - ratio) * denoised.to(dtype=compute_dtype)
+    return out.to(dtype=state.dtype)
+
+
+class MiniMaxH3EulerAncestralEta0SchedulerAdapter:
+    def __init__(self, **config: Any) -> None:
+        if config:
+            raise ValueError(f"{type(self).__name__} does not accept config fields: {sorted(config)}")
+
+    def step_denoising(
+        self,
+        *,
+        input_visual_latent: torch.Tensor,
+        input_audio_latent: torch.Tensor,
+        timestep: torch.Tensor,
+        noise_pred_visual: torch.Tensor,
+        noise_pred_audio: torch.Tensor,
+        sigma_curr: float,
+        sigma_next: float,
+        video_timestep: torch.Tensor | None = None,
+        audio_timestep: torch.Tensor | None = None,
+        video_sigma_curr: float | None = None,
+        video_sigma_next: float | None = None,
+        audio_sigma_curr: float | None = None,
+        audio_sigma_next: float | None = None,
+    ) -> dict[str, torch.Tensor]:
+        visual_timestep = timestep if video_timestep is None else video_timestep
+        audio_timestep = timestep if audio_timestep is None else audio_timestep
+        visual_sigma_curr = sigma_curr if video_sigma_curr is None else video_sigma_curr
+        visual_sigma_next = sigma_next if video_sigma_next is None else video_sigma_next
+        audio_sigma_curr = sigma_curr if audio_sigma_curr is None else audio_sigma_curr
+        audio_sigma_next = sigma_next if audio_sigma_next is None else audio_sigma_next
+        if input_visual_latent.shape != noise_pred_visual.shape:
+            raise ValueError("input_visual_latent and noise_pred_visual shapes must match")
+        if input_audio_latent.shape != noise_pred_audio.shape:
+            raise ValueError("input_audio_latent and noise_pred_audio shapes must match")
+        visual_sigma_curr = _validate_timestep_sigma_pair(
+            visual_timestep,
+            visual_sigma_curr,
+            "video",
+        )
+        audio_sigma_curr = _validate_timestep_sigma_pair(
+            audio_timestep,
+            audio_sigma_curr,
+            "audio",
+        )
+        visual_sigma_next = _validate_sigma(visual_sigma_next, "video_sigma_next")
+        audio_sigma_next = _validate_sigma(audio_sigma_next, "audio_sigma_next")
+
+        denoised_visual = _minimax_h3_rf_v_to_x0(
+            input_visual_latent,
+            noise_pred_visual,
+            visual_timestep,
+        )
+        denoised_audio = _minimax_h3_rf_v_to_x0(
+            input_audio_latent,
+            noise_pred_audio,
+            audio_timestep,
+        )
+        return {
+            "output_visual_latent": _minimax_h3_euler_eta0_step(
+                input_visual_latent,
+                denoised_visual,
+                sigma_curr=visual_sigma_curr,
+                sigma_next=visual_sigma_next,
+            ),
+            "output_audio_latent": _minimax_h3_euler_eta0_step(
+                input_audio_latent,
+                denoised_audio,
+                sigma_curr=audio_sigma_curr,
+                sigma_next=audio_sigma_next,
+            ),
+        }
+
+
+__all__ = [
+    "MiniMaxH3EulerAncestralEta0SchedulerAdapter",
+    "minimax_h3_euler_eta0_step",
+    "minimax_h3_rf_v_to_x0",
+]
diff --git a/telefuser/pipelines/minimax_h3/task_profiles.py b/telefuser/pipelines/minimax_h3/task_profiles.py
new file mode 100644
index 00000000..fd998a82
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/task_profiles.py
@@ -0,0 +1,246 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 task profiles.
+
+Data table driving request validation and plan resolution for the three v1
+tasks (t2va / fl2va / ref2va). One row per task; stages and the request
+projector consume rows instead of branching on task names.
+
+Design summary: keyframes bind target geometry; references remain independent.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import MappingProxyType
+
+MINIMAX_H3_CONDITION_ROLE_KEYFRAME = "keyframe"
+MINIMAX_H3_CONDITION_ROLE_REFERENCE = "reference"
+
+MINIMAX_H3_TASK_T2VA = "t2va"
+MINIMAX_H3_TASK_FL2VA = "fl2va"
+MINIMAX_H3_TASK_REF2VA = "ref2va"
+
+# Public dispatcher contract.  SGLang only needs the stable task mapping.
+MINIMAX_H3_TASK_PARTITIONS = MappingProxyType(
+    {
+        "t2va": "fl2va",
+        "fl2va": "fl2va",
+        "ref2va": "ref2va",
+    }
+)
+
+
+def canonical_minimax_h3_task(task: str) -> str:
+    """Normalize and validate a public task name."""
+
+    if not isinstance(task, str) or not task.strip():
+        raise ValueError("MiniMax H3 task must be a non-empty string")
+    normalized = task.strip().lower()
+    if normalized not in MINIMAX_H3_TASK_PARTITIONS:
+        raise ValueError(f"unsupported MiniMax H3 task {task!r}")
+    return normalized
+
+
+def partition_for_task(task: str) -> str:
+    """Return the deployment partition serving *task*."""
+
+    return MINIMAX_H3_TASK_PARTITIONS[canonical_minimax_h3_task(task)]
+
+
+MINIMAX_H3_FINITE_ASPECT_RATIOS = (
+    "21:9",
+    "16:9",
+    "4:3",
+    "1:1",
+    "3:4",
+    "9:16",
+)
+
+# ``fl2va`` remains the single public task name for all keyframe variants:
+# first-frame-only, last-frame-only, and first+last.  Keep the accepted
+# semantic signatures centralized so validation and every downstream sink can
+# reject middle/reversed/stale payloads consistently.
+MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES: tuple[tuple[int, ...], ...] = (
+    (0,),
+    (-1,),
+    (0, -1),
+)
+
+# Canonical material-chain names are part of the direct runtime plan.
+# Profile validation keeps only the wire-level allowlist here.
+MINIMAX_H3_CANONICAL_MATERIAL_CHAINS = frozenset(
+    {
+        "image.target_canvas",
+        "image.reference_preserve",
+        "video.reference_preserve",
+        "video_audio.reference_preserve",
+        "audio",
+    }
+)
+
+
+@dataclass(frozen=True)
+class MiniMaxH3ConditionRule:
+    """Per-(role, type) admission + routing rule."""
+
+    role: str
+    condition_type: str
+    material_chain: str
+    requires_frame_index: bool = False
+
+
+@dataclass(frozen=True)
+class MiniMaxH3TaskProfile:
+    """One row of the task table."""
+
+    task: str
+    conditions_required: bool
+    condition_rules: tuple[MiniMaxH3ConditionRule, ...]
+    default_flow_shift: float
+    default_audio_flow_shift: float
+    aspect_ratio_forced_auto: bool
+    geometry_source: str  # "explicit_target" | "first_keyframe" | "model_default"
+    # For ref2va video, target may omit duration_seconds
+    # when an audio reference is present — duration derives from the
+    # reference audio probe and is then checked against the shared 4-15s range.
+    duration_from_audio_reference: bool = False
+    # Some deployments keep video references disabled while retaining the
+    # routing rule for projection/contract compatibility.
+    video_reference_supported: bool = True
+    min_condition_count: int | None = None
+    max_condition_count: int | None = None
+    # Resolution policy for target.aspect_ratio="auto".  A concrete ratio
+    # resolves immediately; None keeps geometry deferred to the named source.
+    auto_aspect_ratio: str | None = None
+    auto_geometry_source: str | None = None
+
+    def rule_for(self, *, role: str, condition_type: str) -> MiniMaxH3ConditionRule:
+        for rule in self.condition_rules:
+            if rule.role == role and rule.condition_type == condition_type:
+                return rule
+        raise ValueError(f"task {self.task!r} does not allow condition role={role!r} type={condition_type!r}")
+
+
+MINIMAX_H3_TASK_PROFILES: dict[str, MiniMaxH3TaskProfile] = {
+    MINIMAX_H3_TASK_T2VA: MiniMaxH3TaskProfile(
+        task=MINIMAX_H3_TASK_T2VA,
+        conditions_required=False,
+        condition_rules=(),
+        default_flow_shift=12.0,
+        default_audio_flow_shift=3.0,
+        aspect_ratio_forced_auto=False,
+        geometry_source="explicit_target",
+        auto_aspect_ratio="16:9",
+        auto_geometry_source="policy_default",
+    ),
+    MINIMAX_H3_TASK_FL2VA: MiniMaxH3TaskProfile(
+        task=MINIMAX_H3_TASK_FL2VA,
+        conditions_required=True,
+        condition_rules=(
+            MiniMaxH3ConditionRule(
+                role=MINIMAX_H3_CONDITION_ROLE_KEYFRAME,
+                condition_type="image",
+                material_chain="image.target_canvas",
+                requires_frame_index=True,
+            ),
+        ),
+        default_flow_shift=12.0,
+        default_audio_flow_shift=3.0,
+        # FL follows the resolved target geometry projected by the caller.
+        # Its first/last keyframes are prepared against that target canvas.
+        aspect_ratio_forced_auto=False,
+        geometry_source="explicit_target",
+        min_condition_count=1,
+        max_condition_count=2,
+        auto_geometry_source="first_keyframe",
+    ),
+    MINIMAX_H3_TASK_REF2VA: MiniMaxH3TaskProfile(
+        task=MINIMAX_H3_TASK_REF2VA,
+        conditions_required=True,
+        condition_rules=(
+            MiniMaxH3ConditionRule(
+                role=MINIMAX_H3_CONDITION_ROLE_REFERENCE,
+                condition_type="image",
+                material_chain="image.reference_preserve",
+            ),
+            MiniMaxH3ConditionRule(
+                role=MINIMAX_H3_CONDITION_ROLE_REFERENCE,
+                condition_type="video",
+                material_chain="video.reference_preserve",
+                # ref2va video: the reference video's ORIGINAL soundtrack is the
+                # audio reference; -17 rows cover the full pre-truncation track.
+                # Route the same material into the audio encoder.
+            ),
+            MiniMaxH3ConditionRule(
+                role=MINIMAX_H3_CONDITION_ROLE_REFERENCE,
+                condition_type="video_audio",
+                material_chain="video_audio.reference_preserve",
+            ),
+            MiniMaxH3ConditionRule(
+                role=MINIMAX_H3_CONDITION_ROLE_REFERENCE,
+                condition_type="audio",
+                material_chain="audio",
+            ),
+        ),
+        default_flow_shift=12.0,
+        default_audio_flow_shift=3.0,
+        # ref2va video may use an explicit aspect ratio such as "7:4":
+        # ref2va allows explicit aspect ratios; "auto" falls back to the
+        # policy default (references never bind target geometry).
+        aspect_ratio_forced_auto=False,
+        geometry_source="explicit_target",
+        duration_from_audio_reference=True,
+        auto_aspect_ratio="16:9",
+        auto_geometry_source="policy_default",
+        # ref2va video uses a subject image plus a reference video with soundtrack.
+        video_reference_supported=True,
+    ),
+}
+
+
+def minimax_h3_task_profile(task: str) -> MiniMaxH3TaskProfile:
+    profile = MINIMAX_H3_TASK_PROFILES.get(task)
+    if profile is None:
+        raise ValueError(f"unknown minimax_h3 task {task!r}; supported: {sorted(MINIMAX_H3_TASK_PROFILES)}")
+    return profile
+
+
+def _validate_profiles() -> None:
+    for task, profile in MINIMAX_H3_TASK_PROFILES.items():
+        if profile.task != task:
+            raise ValueError(f"profile key/task mismatch: {task} vs {profile.task}")
+        roles = {rule.role for rule in profile.condition_rules}
+        if len(roles) > 1:
+            raise ValueError(f"task {task}: condition roles must not mix, got {sorted(roles)}")
+        if profile.min_condition_count is not None and profile.min_condition_count <= 0:
+            raise ValueError(f"task {task}: min_condition_count must be positive")
+        if profile.max_condition_count is not None and profile.max_condition_count <= 0:
+            raise ValueError(f"task {task}: max_condition_count must be positive")
+        if (
+            profile.min_condition_count is not None
+            and profile.max_condition_count is not None
+            and profile.min_condition_count > profile.max_condition_count
+        ):
+            raise ValueError(f"task {task}: min_condition_count exceeds max_condition_count")
+        for rule in profile.condition_rules:
+            if rule.material_chain not in MINIMAX_H3_CANONICAL_MATERIAL_CHAINS:
+                raise ValueError(f"task {task}: unknown material chain {rule.material_chain!r}")
+
+
+_validate_profiles()
+
+__all__ = [
+    "MINIMAX_H3_CONDITION_ROLE_KEYFRAME",
+    "MINIMAX_H3_FINITE_ASPECT_RATIOS",
+    "MINIMAX_H3_FL2VA_KEYFRAME_SIGNATURES",
+    "MINIMAX_H3_CONDITION_ROLE_REFERENCE",
+    "MINIMAX_H3_CANONICAL_MATERIAL_CHAINS",
+    "MINIMAX_H3_TASK_FL2VA",
+    "MINIMAX_H3_TASK_PROFILES",
+    "MINIMAX_H3_TASK_REF2VA",
+    "MINIMAX_H3_TASK_T2VA",
+    "MiniMaxH3TaskProfile",
+    "canonical_minimax_h3_task",
+    "minimax_h3_task_profile",
+    "partition_for_task",
+]
diff --git a/telefuser/pipelines/minimax_h3/text_encoding.py b/telefuser/pipelines/minimax_h3/text_encoding.py
new file mode 100644
index 00000000..fc4ced3d
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/text_encoding.py
@@ -0,0 +1,246 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Qwen3-VL layer-50 conditioning stage for MiniMax H3."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import torch
+
+from telefuser.core.base_stage import BaseStage, with_model_offload
+from telefuser.core.config import ModelRuntimeConfig, WeightOffloadType
+from telefuser.core.module_manager import ModuleManager
+from telefuser.distributed.device_mesh import create_device_mesh_from_config
+from telefuser.distributed.fsdp import shard_model_fsdp2_inference
+from telefuser.platforms import current_platform
+from telefuser.utils.logging import logger
+
+from .presentation import (
+    minimax_h3_multi_image_presentation,
+    minimax_h3_ref2va_presentation,
+    minimax_h3_ref2va_video_presentation,
+    minimax_h3_text_only_ids,
+)
+
+
+@dataclass(frozen=True)
+class MiniMaxH3TextCondition:
+    hidden_states: torch.Tensor
+    token_tags: torch.Tensor
+
+    @property
+    def text_len(self) -> int:
+        return int(self.hidden_states.shape[0])
+
+
+class MiniMaxH3TextEncodingStage(BaseStage):
+    def __init__(
+        self,
+        module_manager: ModuleManager,
+        model_runtime_config: ModelRuntimeConfig,
+        *,
+        processor: Any,
+    ) -> None:
+        super().__init__("minimax_h3_text_encoding", model_runtime_config)
+        self.text_encoder = module_manager.fetch_module("minimax_h3_text_encoder")
+        if self.text_encoder is None:
+            raise ValueError("ModuleManager must contain 'minimax_h3_text_encoder'")
+        self.processor = processor
+        self.tokenizer = processor.tokenizer
+        self.model_names = ["text_encoder"]
+
+    def parallel_models(self) -> None:
+        parallel_config = self.model_runtime_config.parallel_config
+        unsupported = {
+            "cfg_degree": parallel_config.cfg_degree,
+            "sp_ring_degree": parallel_config.sp_ring_degree,
+            "pp_degree": parallel_config.pp_degree,
+        }
+        invalid = {name: degree for name, degree in unsupported.items() if degree != 1}
+        if invalid:
+            raise NotImplementedError(f"MiniMax H3 text encoder does not support these parallel degrees: {invalid}")
+        if parallel_config.tp_degree <= 1 and not parallel_config.enable_fsdp:
+            raise NotImplementedError("MiniMax H3 multi-GPU text encoding requires TP or FSDP inference")
+        device_mesh = create_device_mesh_from_config(parallel_config)
+        if parallel_config.tp_degree > 1:
+            if parallel_config.sp_ulysses_degree > 1:
+                raise ValueError("MiniMax H3 text encoder TP requires a dedicated one-dimensional TP mesh")
+            if parallel_config.enable_fsdp:
+                raise ValueError("MiniMax H3 text encoder TP cannot be combined with FSDP")
+            if self.model_runtime_config.offload_config.offload_type != WeightOffloadType.NO_CPU_OFFLOAD:
+                raise ValueError("MiniMax H3 text encoder TP cannot be combined with model CPU offload")
+            logger.info(f"Enabling tensor parallelism for {self.name}")
+            self.text_encoder.enable_tp(device_mesh)
+            self.text_encoder.to(self.device)
+        else:
+            if self.model_runtime_config.offload_config.offload_type != WeightOffloadType.NO_CPU_OFFLOAD:
+                raise ValueError("MiniMax H3 text encoder FSDP inference cannot be combined with model CPU offload")
+            logger.info(f"Enabling block FSDP2 for {self.name}")
+            self.text_encoder = shard_model_fsdp2_inference(
+                module=self.text_encoder,
+                device_mesh=device_mesh,
+                wrap_module_names=self.text_encoder.get_fsdp_module_names(),
+            )
+        self.onload_models_flag = True
+        current_platform.empty_cache()
+
+    @with_model_offload(["text_encoder"])
+    @torch.inference_mode()
+    def encode(
+        self,
+        *,
+        task: str,
+        prompt: str,
+        images: list[Any],
+        videos: list[torch.Tensor],
+        condition_labels: list[tuple[str, int]],
+    ) -> MiniMaxH3TextCondition:
+        condition = self._encode_impl(
+            task=task,
+            prompt=prompt,
+            images=images,
+            videos=videos,
+            condition_labels=condition_labels,
+        )
+        return MiniMaxH3TextCondition(condition.hidden_states.cpu(), condition.token_tags.cpu())
+
+    @with_model_offload(["text_encoder"])
+    @torch.inference_mode()
+    def encode_for_denoising(
+        self,
+        *,
+        task: str,
+        prompt: str,
+        images: list[Any],
+        videos: list[torch.Tensor],
+        condition_labels: list[tuple[str, int]],
+    ) -> dict[str, torch.Tensor]:
+        """Keep hidden states on the producer device while transporting control metadata on CPU."""
+        condition = self._encode_impl(
+            task=task,
+            prompt=prompt,
+            images=images,
+            videos=videos,
+            condition_labels=condition_labels,
+        )
+        return {
+            "hidden_states": condition.hidden_states,
+            "token_tags": condition.token_tags.cpu(),
+        }
+
+    def _encode_impl(
+        self,
+        *,
+        task: str,
+        prompt: str,
+        images: list[Any],
+        videos: list[torch.Tensor],
+        condition_labels: list[tuple[str, int]],
+    ) -> MiniMaxH3TextCondition:
+        if task == "t2va":
+            ids = minimax_h3_text_only_ids(self.tokenizer, prompt)
+            tags = torch.ones(ids.shape[0], dtype=torch.long)
+            hidden = self.text_encoder.encode_ids(ids)
+            return MiniMaxH3TextCondition(hidden, tags)
+        if task == "fl2va":
+            return self._encode_images(prompt, images)
+        if task != "ref2va":
+            raise ValueError(f"unsupported MiniMax H3 task {task!r}")
+        return self._encode_references(prompt, images, videos, condition_labels)
+
+    def _encode_images(self, prompt: str, images: list[Any]) -> MiniMaxH3TextCondition:
+        if not images:
+            raise ValueError("fl2va text conditioning requires keyframe images")
+        vision = self.processor.image_processor(images=images, return_tensors="pt")
+        grids = vision["image_grid_thw"]
+        merge = int(self.processor.image_processor.merge_size) ** 2
+        counts = [int(grids[index].prod().item()) // merge for index in range(len(images))]
+        ids, tags = minimax_h3_multi_image_presentation(
+            self.tokenizer,
+            prompt=prompt,
+            image_token_counts=counts,
+        )
+        hidden = self.text_encoder.encode_ids(
+            ids,
+            pixel_values=vision["pixel_values"],
+            image_grid_thw=grids,
+        )
+        return MiniMaxH3TextCondition(hidden, tags)
+
+    @staticmethod
+    def _sample_video(frames: torch.Tensor) -> tuple[torch.Tensor, list[float]]:
+        if frames.ndim != 4 or frames.shape[-1] != 3 or frames.shape[0] == 0:
+            raise ValueError("reference video frames must be non-empty [T,H,W,3]")
+        sampled = frames[::12]
+        timestamps = [index / 2.0 for index in range(int(sampled.shape[0]))]
+        if len(timestamps) % 2:
+            timestamps.append(timestamps[-1])
+        block_timestamps = [(timestamps[index] + timestamps[index + 1]) / 2.0 for index in range(0, len(timestamps), 2)]
+        return sampled.permute(0, 3, 1, 2), block_timestamps
+
+    def _encode_references(
+        self,
+        prompt: str,
+        images: list[Any],
+        videos: list[torch.Tensor],
+        condition_labels: list[tuple[str, int]],
+    ) -> MiniMaxH3TextCondition:
+        pixel_values = image_grids = None
+        image_counts: list[int] = []
+        if images:
+            vision = self.processor.image_processor(images=images, return_tensors="pt")
+            pixel_values = vision["pixel_values"]
+            image_grids = vision["image_grid_thw"]
+            merge = int(self.processor.image_processor.merge_size) ** 2
+            image_counts = [int(image_grids[index].prod().item()) // merge for index in range(len(images))]
+
+        pixel_values_videos = video_grids = None
+        video_counts: list[list[int]] = []
+        video_timestamps: list[list[float]] = []
+        if videos:
+            sampled = [self._sample_video(frames) for frames in videos]
+            video_output = self.processor.video_processor(
+                videos=[item[0] for item in sampled],
+                do_sample_frames=False,
+                input_data_format="channels_first",
+                return_tensors="pt",
+            )
+            pixel_values_videos = video_output["pixel_values_videos"]
+            video_grids = video_output["video_grid_thw"]
+            merge = int(self.processor.image_processor.merge_size) ** 2
+            for index, (_, timestamps) in enumerate(sampled):
+                blocks = int(video_grids[index, 0])
+                per_block = int(video_grids[index, 1]) * int(video_grids[index, 2]) // merge
+                if blocks != len(timestamps):
+                    raise ValueError("Qwen video grid and timestamp block counts disagree")
+                video_counts.append([per_block] * blocks)
+                video_timestamps.append(timestamps)
+
+        if videos:
+            ids, tags = minimax_h3_ref2va_video_presentation(
+                self.tokenizer,
+                prompt=prompt,
+                condition_labels=condition_labels,
+                image_token_count=image_counts or None,
+                video_block_token_counts=video_counts,
+                video_block_timestamps=video_timestamps,
+            )
+        else:
+            ids, tags = minimax_h3_ref2va_presentation(
+                self.tokenizer,
+                prompt=prompt,
+                condition_labels=condition_labels,
+                image_token_count=image_counts or None,
+            )
+        hidden = self.text_encoder.encode_ids(
+            ids,
+            pixel_values=pixel_values,
+            image_grid_thw=image_grids,
+            pixel_values_videos=pixel_values_videos,
+            video_grid_thw=video_grids,
+        )
+        return MiniMaxH3TextCondition(hidden, tags)
+
+
+__all__ = ["MiniMaxH3TextCondition", "MiniMaxH3TextEncodingStage"]
diff --git a/telefuser/pipelines/minimax_h3/time_request.py b/telefuser/pipelines/minimax_h3/time_request.py
new file mode 100644
index 00000000..e6fb5f39
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/time_request.py
@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+
+def minimax_h3_align_frame_count(frame_count: int) -> int:
+    """Snap ``frame_count`` up to the MiniMax H3 17n+5 frame boundary."""
+    if frame_count <= 0:
+        return 1
+    current = int(frame_count)
+    return current + (5 - current) % 17
+
+
+def minimax_h3_video_latent_t(frame_count: int) -> int:
+    if frame_count <= 5:
+        return 2
+    return ((int(frame_count) - 5) // 17) * 5 + 2
+
+
+def minimax_h3_frame_count_from_video_latent_t(out_t: int) -> int:
+    if out_t == 1:
+        return 1
+    if out_t < 2 or (out_t - 2) % 5 != 0:
+        raise ValueError("MiniMax H3 video latent T must be 1 or match 5n+2")
+    return 17 * ((int(out_t) - 2) // 5) + 5
+
+
+def minimax_h3_audio_latent_t(duration_seconds: float) -> int:
+    # Rounding happens at the 40 Hz audio latent boundary.
+    return int(round(float(duration_seconds) * 40.0))
+
+
+def minimax_h3_time_shift_sigmas(
+    *,
+    num_steps: int = 50,
+    shift_scale: float = 6.0,
+) -> list[float]:
+    if shift_scale <= 0:
+        raise ValueError("MiniMax H3 shift_scale must be > 0")
+    if num_steps <= 0:
+        raise ValueError("MiniMax H3 num_steps must be > 0")
+
+    import torch
+
+    # The rectified-flow sigma range is fixed at [1.0, 0.0].
+    base = torch.linspace(
+        1.0,
+        0.0,
+        int(num_steps),
+        device="cpu",
+        dtype=torch.float32,
+    )
+    shifted = float(shift_scale) * base / (1 + (float(shift_scale) - 1) * base)
+    shifted, _ = torch.unique_consecutive(shifted, return_counts=True)
+    # A one-point request is still exactly one point.  Normal serving uses
+    # multiple points, but preserving the requested cardinality keeps
+    # ``num_inference_steps`` the sole schedule-size control.
+    if num_steps > 1 and shifted[-1].item() > 0.0:
+        shifted = torch.cat([shifted, torch.tensor([0.0], dtype=shifted.dtype)])
+    return [float(value) for value in shifted.tolist()]
diff --git a/telefuser/pipelines/minimax_h3/vae.py b/telefuser/pipelines/minimax_h3/vae.py
new file mode 100644
index 00000000..958b2032
--- /dev/null
+++ b/telefuser/pipelines/minimax_h3/vae.py
@@ -0,0 +1,378 @@
+# SPDX-License-Identifier: Apache-2.0
+"""MiniMax H3 media preparation and modality-specific VAE stages."""
+
+from __future__ import annotations
+
+import contextlib
+import math
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from PIL import Image, ImageOps
+
+from telefuser.core.base_stage import BaseStage, with_model_offload
+from telefuser.core.config import ModelRuntimeConfig, WeightOffloadType
+from telefuser.core.module_manager import ModuleManager
+from telefuser.distributed.device_mesh import create_device_mesh_from_config, get_tp_group
+from telefuser.platforms import current_platform
+
+from .canvas import (
+    minimax_h3_prepare_keyframe_canvas,
+    minimax_h3_stretch_keyframe_canvas,
+)
+from .material_io import MiniMaxH3MaterialFacts
+from .packed_tokens import minimax_h3_patchify_video_latent
+from .resolved_plan import (
+    MiniMaxH3MaterialPlanItem,
+    MiniMaxH3ResolvedPlan,
+    minimax_h3_resolve_spatial_shape,
+)
+
+MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE = 2048
+
+
+@dataclass(frozen=True)
+class MiniMaxH3PreparedCondition:
+    material: MiniMaxH3MaterialPlanItem
+    kind: str
+    image: Image.Image | None = None
+    video_frames: torch.Tensor | None = None
+    visual_rows: torch.Tensor | None = None
+    audio_rows: torch.Tensor | None = None
+    latent_t: int = 0
+    latent_h: int = 0
+    latent_w: int = 0
+    ref_audio_t: int = 0
+    has_audio: bool = False
+
+    def as_denoising_payload(self) -> dict[str, Any]:
+        """Drop source media while preserving denoising inputs for tensor transport."""
+        return {
+            "material": self.material,
+            "kind": self.kind,
+            "visual_rows": self.visual_rows,
+            "audio_rows": self.audio_rows,
+            "latent_t": self.latent_t,
+            "latent_h": self.latent_h,
+            "latent_w": self.latent_w,
+            "ref_audio_t": self.ref_audio_t,
+            "has_audio": self.has_audio,
+        }
+
+
+@contextlib.contextmanager
+def _scoped_seed(seed: int, device: torch.device):
+    devices = [device] if device.type == "cuda" else []
+    with torch.random.fork_rng(devices=devices):
+        torch.manual_seed(seed)
+        if device.type == "cuda":
+            torch.cuda.manual_seed(seed)
+        yield
+
+
+def _reference_image_size(width: int, height: int) -> tuple[int, int]:
+    if width <= 0 or height <= 0 or width > 4 * height or height > 4 * width:
+        raise ValueError("reference image ratio must be within the inclusive range 1:4 to 4:1")
+    scale = MINIMAX_H3_REFERENCE_IMAGE_SHORT_EDGE / min(width, height)
+    target_width = max(32, int(round(width * scale / 32)) * 32)
+    target_height = max(32, int(round(height * scale / 32)) * 32)
+    return target_width, target_height
+
+
+def _decode_video(
+    path: Path,
+    *,
+    width: int,
+    height: int,
+    frame_count: int,
+    start_time_seconds: float,
+) -> torch.Tensor:
+    command = ["ffmpeg", "-v", "error"]
+    if start_time_seconds > 0:
+        command += ["-ss", f"{start_time_seconds:.9g}"]
+    command += [
+        "-i",
+        str(path),
+        "-an",
+        "-vf",
+        f"fps=24,scale={width}:{height}:flags=lanczos,setsar=1",
+        "-frames:v",
+        str(frame_count),
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "rgb24",
+        "pipe:1",
+    ]
+    payload = subprocess.run(command, check=True, capture_output=True).stdout
+    frame_bytes = width * height * 3
+    if not payload or len(payload) % frame_bytes:
+        raise ValueError(f"ffmpeg returned invalid reference video bytes for {path}")
+    array = np.frombuffer(payload, dtype=np.uint8).reshape(-1, height, width, 3).copy()
+    return torch.from_numpy(array)
+
+
+def _decode_audio(
+    path: Path,
+    *,
+    source_rate: int,
+    start_time_seconds: float,
+    max_duration_seconds: float,
+) -> torch.Tensor:
+    command = ["ffmpeg", "-v", "error"]
+    if start_time_seconds > 0:
+        command += ["-ss", f"{start_time_seconds:.9g}"]
+    command += [
+        "-i",
+        str(path),
+        "-map",
+        "0:a:0",
+        "-vn",
+        "-ac",
+        "2",
+        "-ar",
+        str(source_rate),
+        "-t",
+        f"{max_duration_seconds:.9g}",
+        "-f",
+        "f32le",
+        "pipe:1",
+    ]
+    payload = subprocess.run(command, check=True, capture_output=True).stdout
+    if not payload or len(payload) % (2 * torch.float32.itemsize):
+        raise ValueError(f"ffmpeg returned invalid reference audio bytes for {path}")
+    waveform = torch.from_numpy(np.frombuffer(payload, dtype=np.float32).reshape(-1, 2).T.copy())
+    if source_rate != 32_000:
+        import torchaudio
+
+        waveform = torchaudio.functional.resample(waveform, source_rate, 32_000)
+    return waveform
+
+
+class MiniMaxH3VideoVAEStage(BaseStage):
+    def __init__(self, module_manager: ModuleManager, model_runtime_config: ModelRuntimeConfig) -> None:
+        super().__init__("minimax_h3_video_vae", model_runtime_config)
+        self.video_vae = module_manager.fetch_module("minimax_h3_video_vae")
+        if self.video_vae is None:
+            raise ValueError("ModuleManager must contain MiniMax H3 video VAE")
+        self.model_names = ["video_vae"]
+
+    def parallel_models(self) -> None:
+        parallel_config = self.model_runtime_config.parallel_config
+        unsupported = {
+            "cfg_degree": parallel_config.cfg_degree,
+            "sp_ring_degree": parallel_config.sp_ring_degree,
+            "sp_ulysses_degree": parallel_config.sp_ulysses_degree,
+            "pp_degree": parallel_config.pp_degree,
+            "dp_degree": parallel_config.dp_degree,
+        }
+        invalid = {name: degree for name, degree in unsupported.items() if degree != 1}
+        if invalid:
+            raise NotImplementedError(f"MiniMax H3 video VAE does not support these parallel degrees: {invalid}")
+        if parallel_config.tp_degree <= 1:
+            raise NotImplementedError("MiniMax H3 video VAE parallel tiling requires a multi-rank TP group")
+        if self.model_runtime_config.offload_config.offload_type != WeightOffloadType.NO_CPU_OFFLOAD:
+            raise ValueError("MiniMax H3 video VAE parallel tiling cannot be combined with model CPU offload")
+        device_mesh = create_device_mesh_from_config(parallel_config)
+        group = get_tp_group(device_mesh)
+        if group is None:
+            raise RuntimeError("MiniMax H3 video VAE parallel tiling requires a TP process group")
+        self.video_vae.enable_parallel_tiling(group)
+        self.video_vae.to(self.device)
+        self.onload_models_flag = True
+        current_platform.empty_cache()
+
+    @staticmethod
+    def prepare_media(
+        plan: MiniMaxH3ResolvedPlan,
+        paths: dict[int, Path],
+        facts: dict[int, MiniMaxH3MaterialFacts],
+    ) -> list[MiniMaxH3PreparedCondition]:
+        prepared: list[MiniMaxH3PreparedCondition] = []
+        target_width = int(plan.shape["width"])
+        target_height = int(plan.shape["height"])
+        for material_index, material in enumerate(plan.materials):
+            path = paths[int(material.condition_index)]
+            item_facts = facts[int(material.condition_index)]
+            if material.material_chain == "image.target_canvas":
+                with Image.open(path) as source:
+                    image = ImageOps.exif_transpose(source).convert("RGB")
+                image = (
+                    minimax_h3_stretch_keyframe_canvas(
+                        image,
+                        target_width=target_width,
+                        target_height=target_height,
+                    )
+                    if material_index == 0
+                    else minimax_h3_prepare_keyframe_canvas(
+                        image,
+                        target_width=target_width,
+                        target_height=target_height,
+                        allow_upscale=True,
+                    )
+                )
+                prepared.append(MiniMaxH3PreparedCondition(material, "image", image=image))
+            elif material.material_chain == "image.reference_preserve":
+                with Image.open(path) as source:
+                    image = ImageOps.exif_transpose(source).convert("RGB")
+                width, height = _reference_image_size(image.width, image.height)
+                image = image.resize((width, height), Image.Resampling.LANCZOS)
+                prepared.append(MiniMaxH3PreparedCondition(material, "image", image=image))
+            elif material.material_chain in {"video.reference_preserve", "video_audio.reference_preserve"}:
+                if item_facts.width is None or item_facts.height is None:
+                    raise ValueError("reference video probe is missing display dimensions")
+                resolved = minimax_h3_resolve_spatial_shape(width=item_facts.width, height=item_facts.height)
+                frames = _decode_video(
+                    path,
+                    width=int(resolved["width"]),
+                    height=int(resolved["height"]),
+                    frame_count=int(plan.shape["frame_count"]),
+                    start_time_seconds=material.start_time_seconds,
+                )
+                prepared.append(
+                    MiniMaxH3PreparedCondition(
+                        material,
+                        "video_audio" if material.material_chain == "video_audio.reference_preserve" else "video",
+                        video_frames=frames,
+                        has_audio=item_facts.has_audio,
+                    )
+                )
+            elif material.material_chain == "audio":
+                prepared.append(MiniMaxH3PreparedCondition(material, "audio", has_audio=True))
+            else:
+                raise ValueError(f"unsupported material chain {material.material_chain!r}")
+        return prepared
+
+    @with_model_offload(["video_vae"])
+    @torch.inference_mode()
+    def encode_visual(self, conditions: list[MiniMaxH3PreparedCondition]) -> list[MiniMaxH3PreparedCondition]:
+        return self._encode_visual(conditions, keep_rows_on_device=False)
+
+    @with_model_offload(["video_vae"])
+    @torch.inference_mode()
+    def encode_visual_for_denoising(self, conditions: list[MiniMaxH3PreparedCondition]) -> list[dict[str, Any]]:
+        """Encode channel-friendly condition rows without staging them through CPU."""
+        encoded = self._encode_visual(conditions, keep_rows_on_device=True)
+        return [condition.as_denoising_payload() for condition in encoded]
+
+    def _encode_visual(
+        self,
+        conditions: list[MiniMaxH3PreparedCondition],
+        *,
+        keep_rows_on_device: bool,
+    ) -> list[MiniMaxH3PreparedCondition]:
+        output: list[MiniMaxH3PreparedCondition] = []
+        parameter = next(self.video_vae.parameters())
+        for condition in conditions:
+            if condition.image is None and condition.video_frames is None:
+                output.append(condition)
+                continue
+            with _scoped_seed(42, parameter.device):
+                if condition.image is not None:
+                    latent = self.video_vae.encode_images(condition.image, use_fp16_latent=True)[0]
+                else:
+                    assert condition.video_frames is not None
+                    frames = condition.video_frames.cpu().numpy()
+                    latent = self.video_vae.encode_videos(frames, use_fp16_latent=True)[0]
+            if latent.ndim == 4:
+                latent = latent.unsqueeze(0)
+            mean = latent.new_tensor(self.video_vae.config.latents_mean).view(1, -1, 1, 1, 1)
+            std = latent.new_tensor(self.video_vae.config.latents_std).view(1, -1, 1, 1, 1)
+            normalized = latent.float().sub(mean).div(std)
+            rows = minimax_h3_patchify_video_latent(normalized, patch_size=(1, 2, 2))
+            if not keep_rows_on_device:
+                rows = rows.cpu()
+            output.append(
+                MiniMaxH3PreparedCondition(
+                    **{
+                        **condition.__dict__,
+                        "visual_rows": rows,
+                        "latent_t": int(normalized.shape[2]),
+                        "latent_h": int(normalized.shape[3]),
+                        "latent_w": int(normalized.shape[4]),
+                    }
+                )
+            )
+        return output
+
+    @with_model_offload(["video_vae"])
+    @torch.inference_mode()
+    def decode_video(self, latent: torch.Tensor) -> torch.Tensor:
+        device = next(self.video_vae.parameters()).device
+        use_fp16_autocast = device.type == "cuda"
+        if use_fp16_autocast:
+            self.video_vae.prepare_decoder_autocast_weights(torch.float16)
+        with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_fp16_autocast):
+            frames = self.video_vae.decode_normalized(latent.to(device))
+        # Keep the large decoded tensor on the producing device. ParallelWorker
+        # can then return a CUDA IPC handle instead of copying FP32 frames into
+        # shared CPU storage inside the worker process.
+        return frames.permute(0, 2, 3, 4, 1).float().contiguous()
+
+
+class MiniMaxH3AudioVAEStage(BaseStage):
+    def __init__(self, module_manager: ModuleManager, model_runtime_config: ModelRuntimeConfig) -> None:
+        super().__init__("minimax_h3_audio_vae", model_runtime_config)
+        self.audio_vae = module_manager.fetch_module("minimax_h3_audio_vae")
+        if self.audio_vae is None:
+            raise ValueError("ModuleManager must contain MiniMax H3 audio VAE")
+        self.model_names = ["audio_vae"]
+
+    @with_model_offload(["audio_vae"])
+    @torch.inference_mode()
+    def encode_audio(
+        self,
+        conditions: list[MiniMaxH3PreparedCondition],
+        paths: dict[int, Path],
+        facts: dict[int, MiniMaxH3MaterialFacts],
+        duration_seconds: float,
+    ) -> list[MiniMaxH3PreparedCondition]:
+        output: list[MiniMaxH3PreparedCondition] = []
+        device = next(self.audio_vae.parameters()).device
+        for condition in conditions:
+            if not condition.has_audio:
+                output.append(condition)
+                continue
+            index = int(condition.material.condition_index)
+            is_video = condition.material.material_chain in {
+                "video.reference_preserve",
+                "video_audio.reference_preserve",
+            }
+            source_rate = 44_100 if is_video else facts[index].sample_rate
+            if source_rate is None:
+                source_rate = 44_100
+            waveform = _decode_audio(
+                paths[index],
+                source_rate=source_rate,
+                start_time_seconds=condition.material.start_time_seconds,
+                max_duration_seconds=duration_seconds,
+            )
+            latent = self.audio_vae.encode_mean(waveform.unsqueeze(1).to(device), 32_000)
+            rows = latent.permute(0, 2, 1).reshape(-1, int(latent.shape[1])).float().cpu()
+            output.append(
+                MiniMaxH3PreparedCondition(
+                    **{
+                        **condition.__dict__,
+                        "audio_rows": rows,
+                        "ref_audio_t": int(latent.shape[-1]),
+                    }
+                )
+            )
+        return output
+
+    @with_model_offload(["audio_vae"])
+    @torch.inference_mode()
+    def decode_audio(self, latent: torch.Tensor) -> torch.Tensor:
+        device = next(self.audio_vae.parameters()).device
+        return self.audio_vae.decode_normalized(latent.to(device)).float().cpu()
+
+
+__all__ = [
+    "MiniMaxH3PreparedCondition",
+    "MiniMaxH3AudioVAEStage",
+    "MiniMaxH3VideoVAEStage",
+]
diff --git a/tests/integration/test_minimax_h3_distributed.py b/tests/integration/test_minimax_h3_distributed.py
new file mode 100644
index 00000000..884a1e8f
--- /dev/null
+++ b/tests/integration/test_minimax_h3_distributed.py
@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from copy import deepcopy
+
+import pytest
+import torch
+
+from telefuser.core.base_stage import BaseStage
+from telefuser.core.config import ModelRuntimeConfig, ParallelConfig
+from telefuser.distributed.device_mesh import create_device_mesh_from_config
+from telefuser.models.minimax_h3_dit import MiniMaxH3DiT, MiniMaxH3DiTConfig
+from telefuser.worker import ParallelWorker
+
+
+def _small_config() -> MiniMaxH3DiTConfig:
+    return MiniMaxH3DiTConfig(
+        hidden_size=32,
+        num_layers=2,
+        token_refiner_num_layers=1,
+        num_attention_heads=4,
+        attention_head_dim=8,
+        ffn_hidden_size=64,
+        latents_dim=2,
+        audio_latents_dim=2,
+        patch_size=(1, 2, 2),
+        text_dim=16,
+        timestep_input_dim=8,
+        time_embed_hidden_size=32,
+        time_embed_dim=16,
+        rope_inv_freq_len=1,
+    )
+
+
+def _inputs() -> dict[str, object]:
+    sequence = 64
+    return {
+        "x": torch.randn(1, sequence, 8),
+        "audio_x": torch.randn(1, sequence, 2),
+        "img_position_ids": torch.zeros(1, sequence, 3, dtype=torch.float64),
+        "unique_timesteps": torch.tensor([0.5]),
+        "inverse_indices": torch.zeros(sequence, dtype=torch.long),
+        "update_mask": torch.ones(32, dtype=torch.bool),
+        "update_audio_mask": torch.ones(16, dtype=torch.bool),
+        "token_tags": torch.cat(
+            (
+                torch.ones(16, dtype=torch.long),
+                torch.full((16,), 2, dtype=torch.long),
+                torch.zeros(32, dtype=torch.long),
+            )
+        ),
+        "prompt_embeds": torch.randn(16, 16),
+        "img_pos_info": {"position_ids": torch.arange(32, 64)},
+        "audio_pos_info": {"position_ids": torch.arange(16, 32)},
+        "text_pos_info": {"position_ids": torch.arange(0, 16)},
+        "img_pos_for_infer_output_info": {"position_ids": torch.arange(32, 64)},
+        "packed_seq_params": {"cu_seqlens_q": torch.tensor([0, 32, 64], dtype=torch.int32)},
+    }
+
+
+class _MiniMaxH3UlyssesParityStage(BaseStage):
+    def __init__(self, degree: int) -> None:
+        super().__init__(
+            "minimax-h3-ulysses-parity",
+            ModelRuntimeConfig(
+                device_type="cuda",
+                torch_dtype=torch.bfloat16,
+                parallel_config=ParallelConfig(device_ids=list(range(degree)), sp_ulysses_degree=degree),
+            ),
+        )
+        torch.manual_seed(17)
+        source = MiniMaxH3DiT(_small_config()).eval()
+        self.dense = deepcopy(source)
+        self.parallel = deepcopy(source)
+        self.empty_cache_after_call = False
+
+    def parallel_models(self) -> None:
+        self.parallel = self.parallel.to(self.device)
+        if torch.distributed.get_rank() == 0:
+            self.dense = self.dense.to(self.device)
+        mesh = create_device_mesh_from_config(self.model_runtime_config.parallel_config)
+        self.parallel.enable_usp(mesh)
+
+    def compare(self, inputs: dict[str, object]) -> tuple[tuple[torch.Tensor, ...], tuple[torch.Tensor, ...]]:
+        parallel = tuple(tensor.cpu() for tensor in self.parallel(**inputs))
+        dense: tuple[torch.Tensor, ...] = ()
+        if torch.distributed.get_rank() == 0:
+            dense = tuple(tensor.cpu() for tensor in self.dense(**inputs))
+        return dense, parallel
+
+
+@pytest.mark.distributed
+@pytest.mark.gpu
+@pytest.mark.multi_gpu
+@pytest.mark.parametrize("degree", [2, 4])
+def test_minimax_h3_ulysses_matches_dense_packed_forward(degree: int) -> None:
+    if torch.cuda.device_count() < degree:
+        pytest.skip(f"requires {degree} CUDA devices")
+    torch.manual_seed(29)
+    worker = ParallelWorker(_MiniMaxH3UlyssesParityStage(degree))
+    try:
+        dense, parallel = worker.compare(_inputs(), sync=True)
+    finally:
+        worker.close()
+    assert len(dense) == len(parallel) == 2
+    for actual, expected in zip(parallel, dense, strict=True):
+        torch.testing.assert_close(actual, expected, rtol=2e-2, atol=2e-2)
diff --git a/tests/integration/test_minimax_h3_parity.py b/tests/integration/test_minimax_h3_parity.py
new file mode 100644
index 00000000..38d3a6c1
--- /dev/null
+++ b/tests/integration/test_minimax_h3_parity.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import torch
+
+try:
+    from safetensors import safe_open
+except ImportError:
+    pytest.skip("safetensors is required for MiniMax H3 checkpoint tests", allow_module_level=True)
+
+from telefuser.models.minimax_h3_audio_vae import MiniMaxH3AudioVAE
+from telefuser.models.minimax_h3_dit import MiniMaxH3DiT
+from telefuser.models.minimax_h3_encoder import MiniMaxH3Encoder
+from telefuser.models.minimax_h3_video_vae import MiniMaxH3VideoVAE
+
+MODEL_ROOT = Path("/hhb-data/aigc/model_zoo/MiniMaxAI_MiniMax-H3")
+if not MODEL_ROOT.is_dir():
+    pytest.skip("the supplied MiniMax H3 checkpoint root is unavailable", allow_module_level=True)
+
+
+def _metadata_state(paths: list[Path]) -> dict[str, torch.Tensor]:
+    state: dict[str, torch.Tensor] = {}
+    for path in paths:
+        with safe_open(path, framework="pt", device="cpu") as handle:
+            for name in handle.keys():
+                shape = tuple(handle.get_slice(name).get_shape())
+                state[name] = torch.empty(shape, device="meta", dtype=torch.bfloat16)
+    return state
+
+
+def _assert_exact_contract(
+    model_class: type[torch.nn.Module],
+    checkpoint_paths: list[Path],
+    config_path: Path,
+) -> None:
+    official = _metadata_state(checkpoint_paths)
+    converter = model_class.state_dict_converter(config_path=config_path)
+    converted, kwargs = converter.from_official(official)
+    with torch.device("meta"):
+        model = model_class(**kwargs)
+    expected = model.state_dict()
+    assert set(converted) == set(expected)
+    mismatches = {
+        name: (tuple(converted[name].shape), tuple(expected[name].shape))
+        for name in expected
+        if converted[name].shape != expected[name].shape
+    }
+    assert not mismatches
+
+
+@pytest.mark.filesystem
+@pytest.mark.parametrize("partition", ["FL2VA", "Ref2VA"])
+def test_original_partition_checkpoint_contracts_are_exact(partition: str) -> None:
+    root = MODEL_ROOT / partition
+    _assert_exact_contract(
+        MiniMaxH3DiT,
+        sorted((root / "transformer").glob("model-*.safetensors")),
+        root / "transformer" / "config.json",
+    )
+    _assert_exact_contract(
+        MiniMaxH3Encoder,
+        sorted((root / "text_encoder").glob("model-*.safetensors")),
+        root / "text_encoder",
+    )
+    _assert_exact_contract(
+        MiniMaxH3VideoVAE,
+        [root / "video_vae" / "source" / "model.safetensors"],
+        root / "video_vae",
+    )
+    _assert_exact_contract(
+        MiniMaxH3AudioVAE,
+        [root / "audio_vae" / "model.safetensors"],
+        root / "audio_vae",
+    )
diff --git a/tests/unit/distributed/test_device_mesh.py b/tests/unit/distributed/test_device_mesh.py
index e34b6927..bf8b73b7 100644
--- a/tests/unit/distributed/test_device_mesh.py
+++ b/tests/unit/distributed/test_device_mesh.py
@@ -42,6 +42,7 @@ class TestValidateParallelConfig:
             ([0, 1, 2, 3], 1, 1, 1, 2, 2),  # Sequence parallel
             ([0, 1], 1, 2, 1, 1, 1),  # CFG parallel
             ([0, 1, 2, 3, 4, 5, 6, 7], 2, 2, 1, 2, 1),  # Combined
+            ([0, 1, 2, 3], 1, 1, 2, 1, 2),  # Ulysses + tensor parallel
         ],
     )
     def test_valid_configurations(self, device_ids, dp, cfg, tp, sp_ring, sp_ulysses):
@@ -58,18 +59,17 @@ def test_valid_configurations(self, device_ids, dp, cfg, tp, sp_ring, sp_ulysses
         _validate_parallel_config(config)
         assert config.world_size == len(device_ids)
 
-    def test_invalid_sp_and_tp_together(self):
-        """Test that SP and TP cannot be enabled together."""
+    def test_sp_and_tp_together(self):
+        """Test that SP and TP can form a two-dimensional mesh."""
         config = ParallelConfig(
             device_ids=[0, 1, 2, 3],
             dp_degree=1,
             cfg_degree=1,
             tp_degree=2,
-            sp_ring_degree=2,
-            sp_ulysses_degree=1,
+            sp_ring_degree=1,
+            sp_ulysses_degree=2,
         )
-        with pytest.raises(ValueError, match="Not allowed to enable sequence parallel and tensor parallel together"):
-            _validate_parallel_config(config)
+        _validate_parallel_config(config)
 
     def test_invalid_world_size_mismatch(self):
         """Test that device count must match parallel degrees."""
@@ -99,6 +99,7 @@ class TestCreateDeviceMeshFromConfig:
             ([0, 1, 2, 3], 1, 1, 1, 1, 4, ["ulysses"]),  # Ulysses only
             ([0, 1], 1, 2, 1, 1, 1, ["cfg"]),
             ([0, 1, 2, 3, 4, 5, 6, 7], 2, 2, 1, 2, 1, ["dp", "cfg", "ring"]),  # DP+CFG+Ring
+            ([0, 1, 2, 3], 1, 1, 2, 1, 2, ["ulysses", "tp"]),  # Ulysses + TP
         ],
     )
     @patch("telefuser.distributed.device_mesh.DeviceMesh")
diff --git a/tests/unit/models/test_lingbot_video_dit.py b/tests/unit/models/test_lingbot_video_dit.py
index c8430ab3..75c28d90 100644
--- a/tests/unit/models/test_lingbot_video_dit.py
+++ b/tests/unit/models/test_lingbot_video_dit.py
@@ -142,7 +142,7 @@ def test_transformer_packed_batch_matches_independent_samples_with_different_tex
     torch.testing.assert_close(actual, expected, rtol=1e-5, atol=1e-5)
 
 
-def test_transformer_rejects_packed_batch_with_non_sdpa_attention() -> None:
+def test_transformer_rejects_packed_batch_with_unsupported_attention() -> None:
     model = LingBotVideoTransformer3DModel(
         in_channels=2,
         out_channels=2,
@@ -156,7 +156,7 @@ def test_transformer_rejects_packed_batch_with_non_sdpa_attention() -> None:
     ).eval()
     model.set_attention_config(AttentionConfig.dense_attention(AttnImplType.FLASH_ATTN_2))
 
-    with pytest.raises(ValueError, match="packed sequence attention currently requires TORCH_SDPA"):
+    with pytest.raises(ValueError, match="packed sequence attention requires TORCH_SDPA or FLASH_ATTN_4"):
         model(
             torch.randn(2, 2, 1, 2, 2),
             torch.tensor([700.0, 300.0]),
diff --git a/tests/unit/models/test_minimax_h3_audio_vae.py b/tests/unit/models/test_minimax_h3_audio_vae.py
new file mode 100644
index 00000000..fe9b238c
--- /dev/null
+++ b/tests/unit/models/test_minimax_h3_audio_vae.py
@@ -0,0 +1,101 @@
+import json
+from pathlib import Path
+
+import pytest
+import torch
+
+from telefuser.models.minimax_h3_audio_vae import (
+    MiniMaxH3AudioVAE,
+    MiniMaxH3AudioVAEConfig,
+    MiniMaxH3AudioVAEStateDictConverter,
+)
+
+
+def _config() -> MiniMaxH3AudioVAEConfig:
+    return MiniMaxH3AudioVAEConfig(
+        encoder_dim=8,
+        encoder_rates=(2,),
+        latent_dim=16,
+        decoder_dim=32,
+        decoder_rates=(2,),
+        sample_rate=32_000,
+        latent_channels=8,
+        output_channels=2,
+        attn_proj=True,
+        decoder_type="bigvgan",
+        latents_mean=(0.0,) * 8,
+        latents_std=(1.0,) * 8,
+    )
+
+
+def test_audio_vae_config_reads_released_component(tmp_path: Path) -> None:
+    (tmp_path / "config.json").write_text(
+        json.dumps(
+            {
+                "source_metadata_path": "metadata.json",
+                "output_channel": 2,
+                "latents_mean": [0.0] * 32,
+                "latents_std": [1.0] * 32,
+            }
+        ),
+        encoding="utf-8",
+    )
+    (tmp_path / "metadata.json").write_text(
+        '{"metadata":{"kwargs":{"encoder_dim":64,"encoder_rates":[2,4,4,5,5],'
+        '"latent_dim":2048,"decoder_dim":1024,"decoder_rates":[5,5,2,2,2,2,2],'
+        '"sample_rate":32000,"vae_latent_channels":32,"attn_proj":true,'
+        '"decoder_type":"bigvgan"}}}',
+        encoding="utf-8",
+    )
+    config = MiniMaxH3AudioVAEConfig.from_path(tmp_path)
+    assert config.sample_rate == 32_000
+    assert config.encoder_rates == (2, 4, 4, 5, 5)
+    assert config.output_channels == 2
+
+
+def test_audio_vae_config_rejects_non_h3_latent_width() -> None:
+    config = _config()
+    with pytest.raises(ValueError, match="32 latent channels"):
+        config.validate()
+
+
+def test_audio_vae_converter_maps_legacy_weight_norm_keys() -> None:
+    converter = MiniMaxH3AudioVAEStateDictConverter.__new__(MiniMaxH3AudioVAEStateDictConverter)
+    converter.config = _config()
+    state = {
+        "encoder.block.0.bias": torch.zeros(1),
+        "encoder.block.0.weight_g": torch.ones(1, 1, 1),
+        "encoder.block.0.weight_v": torch.ones(1, 1, 3),
+    }
+    converted, kwargs = converter.from_official(state)
+    assert set(converted) == {
+        "encoder.block.0.bias",
+        "encoder.block.0.parametrizations.weight.original0",
+        "encoder.block.0.parametrizations.weight.original1",
+    }
+    assert kwargs == {"config": converter.config}
+
+
+def test_decode_normalized_requires_stereo() -> None:
+    model = MiniMaxH3AudioVAE.__new__(MiniMaxH3AudioVAE)
+    torch.nn.Module.__init__(model)
+    model.config = _config()
+    with pytest.raises(ValueError, match=r"\[2, 32, T\]"):
+        model.decode_normalized(torch.zeros(1, 8, 4))
+
+
+def test_decode_normalized_casts_fp32_denoise_output_to_model_dtype() -> None:
+    model = MiniMaxH3AudioVAE.__new__(MiniMaxH3AudioVAE)
+    torch.nn.Module.__init__(model)
+    model.config = _config()
+    model.probe = torch.nn.Parameter(torch.zeros(1, dtype=torch.bfloat16))
+    observed: list[torch.dtype] = []
+
+    def decode(latent: torch.Tensor) -> torch.Tensor:
+        observed.append(latent.dtype)
+        return latent[:, :1]
+
+    model.decode = decode
+    output = model.decode_normalized(torch.zeros(2, 8, 4, dtype=torch.float32))
+    assert observed == [torch.bfloat16]
+    assert output.shape == (1, 2, 4)
diff --git a/tests/unit/models/test_minimax_h3_dit.py b/tests/unit/models/test_minimax_h3_dit.py
new file mode 100644
index 00000000..179180d9
--- /dev/null
+++ b/tests/unit/models/test_minimax_h3_dit.py
@@ -0,0 +1,294 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+import torch
+
+from telefuser.models.minimax_h3_dit import (
+    MINIMAX_H3_FP32_BUFFER_NAMES,
+    MINIMAX_H3_FP32_PARAM_NAMES,
+    MiniMaxH3DiT,
+    MiniMaxH3DiTConfig,
+    _reorder_grouped_qkv_to_qkv,
+)
+from telefuser.ops.rotary import apply_qk_norm_rope_neox, apply_rotary_emb_neox
+
+
+def _small_config() -> MiniMaxH3DiTConfig:
+    return MiniMaxH3DiTConfig(
+        hidden_size=32,
+        num_layers=2,
+        token_refiner_num_layers=1,
+        num_attention_heads=4,
+        attention_head_dim=8,
+        ffn_hidden_size=64,
+        latents_dim=2,
+        audio_latents_dim=2,
+        patch_size=(1, 2, 2),
+        text_dim=16,
+        timestep_input_dim=8,
+        time_embed_hidden_size=32,
+        time_embed_dim=16,
+        rope_inv_freq_len=1,
+    )
+
+
+def test_partial_neox_rope_matches_h3_reference() -> None:
+    torch.manual_seed(0)
+    query = torch.randn(3, 2, 8)
+    key = torch.randn(3, 2, 8)
+    angles = torch.randn(3, 3)
+    cache = torch.cat((angles.cos(), angles.sin()), dim=-1)
+
+    actual_query, actual_key = apply_rotary_emb_neox(query, key, cache)
+
+    def reference(value: torch.Tensor) -> torch.Tensor:
+        first, second = value[..., :6].chunk(2, dim=-1)
+        cosine = angles.cos().unsqueeze(1)
+        sine = angles.sin().unsqueeze(1)
+        rotary = torch.cat((first * cosine - second * sine, second * cosine + first * sine), dim=-1)
+        return torch.cat((rotary, value[..., 6:]), dim=-1)
+
+    torch.testing.assert_close(actual_query, reference(query))
+    torch.testing.assert_close(actual_key, reference(key))
+
+
+def test_qk_norm_rope_native_fallback_matches_split_reference() -> None:
+    torch.manual_seed(0)
+    query = torch.randn(3, 2, 8, dtype=torch.bfloat16)
+    key = torch.randn_like(query)
+    q_weight = torch.randn(8, dtype=torch.bfloat16)
+    k_weight = torch.randn(8, dtype=torch.bfloat16)
+    angles = torch.randn(3, 3)
+    cache = torch.cat((angles.cos(), angles.sin()), dim=-1).to(torch.bfloat16)
+
+    def normalize(value: torch.Tensor, weight: torch.Tensor) -> torch.Tensor:
+        variance = value.float().pow(2).mean(-1, keepdim=True)
+        return (value * torch.rsqrt(variance + 1e-5)).to(weight.dtype) * weight
+
+    expected_query, expected_key = apply_rotary_emb_neox(
+        normalize(query, q_weight),
+        normalize(key, k_weight),
+        cache,
+    )
+    actual_query, actual_key = apply_qk_norm_rope_neox(
+        query,
+        key,
+        q_weight,
+        k_weight,
+        cache,
+        eps=1e-5,
+    )
+
+    assert torch.equal(actual_query, expected_query)
+    assert torch.equal(actual_key, expected_key)
+
+
+def test_released_architecture_has_exact_parameter_contract() -> None:
+    config = MiniMaxH3DiTConfig()
+    with torch.device("meta"):
+        model = MiniMaxH3DiT(config)
+    assert len(model.state_dict()) == 535
+    assert model.video_patch_proj.weight.shape == (5376, 96)
+    assert model.blocks[49].attn.qkv_proj.weight.shape == (3 * 56 * 128, 5376)
+    assert model.token_refiner.blocks[1].mlp.fc1.weight.shape == (2 * 14336, 5376)
+
+
+def test_mixed_precision_boundaries_match_upstream_contract() -> None:
+    with torch.device("meta"):
+        model = MiniMaxH3DiT(_small_config())
+    state = model.state_dict()
+    for name, tensor in state.items():
+        if name in MINIMAX_H3_FP32_PARAM_NAMES | MINIMAX_H3_FP32_BUFFER_NAMES:
+            assert tensor.dtype == torch.float32, name
+        elif tensor.is_floating_point():
+            assert tensor.dtype == torch.bfloat16, name
+
+
+def test_to_preserves_fp32_boundary_values_during_dtype_conversion() -> None:
+    model = MiniMaxH3DiT(_small_config())
+    boundary_names = MINIMAX_H3_FP32_PARAM_NAMES | MINIMAX_H3_FP32_BUFFER_NAMES
+    with torch.no_grad():
+        for index, name in enumerate(sorted(boundary_names), start=1):
+            tensor = model.state_dict()[name]
+            tensor.fill_(index * 0.123456789)
+    expected = {name: model.state_dict()[name].clone() for name in boundary_names}
+
+    model.to(dtype=torch.bfloat16)
+
+    state = model.state_dict()
+    for name, value in expected.items():
+        assert state[name].dtype == torch.float32
+        assert torch.equal(state[name], value), name
+    assert model.blocks[0].attn.qkv_proj.weight.dtype == torch.bfloat16
+
+
+def test_grouped_qkv_reorder_matches_sglang_vector() -> None:
+    weight = torch.arange(12, dtype=torch.float32).reshape(12, 1)
+    actual = _reorder_grouped_qkv_to_qkv(
+        weight,
+        num_query_groups=2,
+        heads_per_group=1,
+        head_dim=2,
+    )
+    expected = torch.tensor([0, 1, 6, 7, 2, 3, 8, 9, 4, 5, 10, 11], dtype=torch.float32).reshape(12, 1)
+    torch.testing.assert_close(actual, expected)
+
+
+def test_enable_tp_shards_fused_projections_by_logical_section() -> None:
+    model = MiniMaxH3DiT(_small_config())
+    block = model.blocks[0]
+    original_qkv = block.attn.qkv_proj.weight.detach().clone()
+    original_out = block.attn.out_proj.weight.detach().clone()
+    original_fc1 = block.mlp.fc1.weight.detach().clone()
+    original_fc2 = block.mlp.fc2.weight.detach().clone()
+    original_adaln = block.adaln_proj.linear.weight.detach().clone()
+    tp_group = MagicMock()
+
+    with (
+        patch("telefuser.models.minimax_h3_dit.get_tp_world_size", return_value=2),
+        patch("telefuser.models.minimax_h3_dit.get_tp_rank", return_value=1),
+        patch("telefuser.models.minimax_h3_dit.get_tp_group", return_value=tp_group),
+    ):
+        model.enable_tp(MagicMock())
+
+    q, k, v = original_qkv.chunk(3, dim=0)
+    expected_qkv = torch.cat((q.chunk(2)[1], k.chunk(2)[1], v.chunk(2)[1]), dim=0)
+    gate, up = original_fc1.chunk(2, dim=0)
+    expected_fc1 = torch.cat((gate.chunk(2)[1], up.chunk(2)[1]), dim=0)
+    torch.testing.assert_close(block.attn.qkv_proj.weight, expected_qkv)
+    torch.testing.assert_close(block.attn.out_proj.weight, original_out.chunk(2, dim=1)[1])
+    torch.testing.assert_close(block.mlp.fc1.weight, expected_fc1)
+    torch.testing.assert_close(block.mlp.fc2.weight, original_fc2.chunk(2, dim=1)[1])
+    torch.testing.assert_close(block.adaln_proj.linear.weight, original_adaln.chunk(2, dim=0)[1])
+    assert block.attn.num_heads == 2
+    assert block.attn.inner_dim == 16
+    assert block.mlp.intermediate_size == 32
+    assert model.tp_flag is True
+
+
+def test_small_packed_forward_returns_video_and_audio_rows() -> None:
+    torch.manual_seed(0)
+    model = MiniMaxH3DiT(_small_config()).eval()
+    sequence = 8
+    video_positions = torch.arange(4, 8)
+    audio_positions = torch.arange(2, 4)
+    text_positions = torch.arange(0, 2)
+    video, audio = model(
+        x=torch.randn(1, sequence, 8),
+        audio_x=torch.randn(1, sequence, 2),
+        img_position_ids=torch.zeros(1, sequence, 3, dtype=torch.float64),
+        unique_timesteps=torch.tensor([0.5]),
+        inverse_indices=torch.zeros(sequence, dtype=torch.long),
+        update_mask=torch.ones(video_positions.numel(), dtype=torch.bool),
+        token_tags=torch.tensor([1, 1, 2, 2, 0, 0, 0, 0]),
+        prompt_embeds=torch.randn(2, 16),
+        img_pos_info={"position_ids": video_positions},
+        audio_pos_info={"position_ids": audio_positions},
+        text_pos_info={"position_ids": text_positions},
+        img_pos_for_infer_output_info={"position_ids": video_positions},
+        packed_seq_params={"cu_seqlens_q": torch.tensor([0, sequence], dtype=torch.int32)},
+    )
+    assert video.shape == (4, 8)
+    assert audio.shape == (2, 2)
+    assert torch.isfinite(video).all()
+    assert torch.isfinite(audio).all()
+
+
+def test_tp_forward_batches_block_adaln_all_gather() -> None:
+    torch.manual_seed(0)
+    model = MiniMaxH3DiT(_small_config()).eval()
+    tp_group = MagicMock()
+    with (
+        patch("telefuser.models.minimax_h3_dit.get_tp_world_size", return_value=2),
+        patch("telefuser.models.minimax_h3_dit.get_tp_rank", return_value=0),
+        patch("telefuser.models.minimax_h3_dit.get_tp_group", return_value=tp_group),
+    ):
+        model.enable_tp(MagicMock())
+
+    sequence = 8
+    video_positions = torch.arange(4, 8)
+    audio_positions = torch.arange(2, 4)
+
+    def gather_rank_copies(tensor: torch.Tensor, *, dim: int, **_: object) -> torch.Tensor:
+        return torch.cat((tensor, tensor), dim=dim)
+
+    with (
+        patch("telefuser.models.minimax_h3_dit.all_gather_cat", side_effect=gather_rank_copies) as gather,
+        patch("telefuser.models.minimax_h3_dit.all_reduce_sum_"),
+    ):
+        video, audio = model(
+            x=torch.randn(1, sequence, 8),
+            audio_x=torch.randn(1, sequence, 2),
+            img_position_ids=torch.zeros(1, sequence, 3, dtype=torch.float64),
+            unique_timesteps=torch.tensor([0.5]),
+            inverse_indices=torch.zeros(sequence, dtype=torch.long),
+            update_mask=torch.ones(video_positions.numel(), dtype=torch.bool),
+            token_tags=torch.tensor([1, 1, 2, 2, 0, 0, 0, 0]),
+            prompt_embeds=torch.randn(2, 16),
+            img_pos_info={"position_ids": video_positions},
+            audio_pos_info={"position_ids": audio_positions},
+            text_pos_info={"position_ids": torch.arange(0, 2)},
+            img_pos_for_infer_output_info={"position_ids": video_positions},
+            packed_seq_params={"cu_seqlens_q": torch.tensor([0, sequence], dtype=torch.int32)},
+        )
+
+    assert video.shape == (4, 8)
+    assert audio.shape == (2, 2)
+    assert gather.call_count == 2
+    assert gather.call_args_list[0].args[0].shape[0] == len(model.blocks)
+
+
+def test_request_static_inputs_are_reused_across_denoising_steps() -> None:
+    torch.manual_seed(0)
+    model = MiniMaxH3DiT(_small_config()).eval()
+    sequence = 8
+    video_positions = torch.arange(4, 8)
+    audio_positions = torch.arange(2, 4)
+    inputs = {
+        "x": torch.randn(1, sequence, 8),
+        "audio_x": torch.randn(1, sequence, 2),
+        "img_position_ids": torch.zeros(1, sequence, 3, dtype=torch.float64),
+        "unique_timesteps": torch.tensor([0.5]),
+        "inverse_indices": torch.zeros(sequence, dtype=torch.long),
+        "update_mask": torch.ones(video_positions.numel(), dtype=torch.bool),
+        "token_tags": torch.tensor([1, 1, 2, 2, 0, 0, 0, 0]),
+        "prompt_embeds": torch.randn(2, 16),
+        "img_pos_info": {"position_ids": video_positions},
+        "audio_pos_info": {"position_ids": audio_positions},
+        "text_pos_info": {"position_ids": torch.arange(0, 2)},
+        "img_pos_for_infer_output_info": {"position_ids": video_positions},
+        "packed_seq_params": {"cu_seqlens_q": torch.tensor([0, sequence], dtype=torch.int32)},
+    }
+
+    with (
+        patch.object(model.token_refiner, "forward", wraps=model.token_refiner.forward) as token_refiner,
+        patch.object(model.rope, "forward", wraps=model.rope.forward) as rope,
+    ):
+        model(static_cache_key=1, **inputs)
+        model(static_cache_key=1, **inputs)
+        assert token_refiner.call_count == 1
+        assert rope.call_count == 1
+
+        model(static_cache_key=2, **inputs)
+        assert token_refiner.call_count == 2
+        assert rope.call_count == 2
+
+
+def test_time_embedder_reuses_device_frequency_cache() -> None:
+    model = MiniMaxH3DiT(_small_config()).eval()
+    timestep = torch.tensor([0.5])
+
+    model.time_embedder(timestep)
+    cached = model.time_embedder._frequency_cache[timestep.device]
+    model.time_embedder(timestep)
+
+    assert model.time_embedder._frequency_cache[timestep.device] is cached
+
+
+def test_enable_usp_rejects_uneven_head_partition() -> None:
+    model = MiniMaxH3DiT(_small_config())
+    with (
+        patch("telefuser.models.minimax_h3_dit.get_ulysses_world_size", return_value=3),
+        pytest.raises(ValueError, match="must be divisible"),
+    ):
+        model.enable_usp(MagicMock())
diff --git a/tests/unit/models/test_minimax_h3_encoder.py b/tests/unit/models/test_minimax_h3_encoder.py
new file mode 100644
index 00000000..8039d7ee
--- /dev/null
+++ b/tests/unit/models/test_minimax_h3_encoder.py
@@ -0,0 +1,79 @@
+from unittest.mock import patch
+
+import torch
+
+from telefuser.models.minimax_h3_encoder import (
+    MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER,
+    MiniMaxH3Encoder,
+    _is_unconsumed_checkpoint_weight,
+    _shard_linear_input,
+    _shard_linear_output,
+)
+
+
+def test_encoder_filters_tail_norm_and_lm_head_but_keeps_layer_49() -> None:
+    assert not _is_unconsumed_checkpoint_weight("model.language_model.layers.49.self_attn.q_proj.weight")
+    assert _is_unconsumed_checkpoint_weight("model.language_model.layers.50.self_attn.q_proj.weight")
+    assert _is_unconsumed_checkpoint_weight("model.language_model.layers.63.mlp.down_proj.weight")
+    assert _is_unconsumed_checkpoint_weight("model.language_model.norm.weight")
+    assert _is_unconsumed_checkpoint_weight("lm_head.weight")
+    assert MINIMAX_H3_QWEN3VL_SELECTED_LM_LAYER == 50
+
+
+def test_encoder_filter_does_not_drop_visual_or_embedding_weights() -> None:
+    for name in (
+        "model.language_model.embed_tokens.weight",
+        "model.visual.patch_embed.proj.weight",
+        "model.visual.blocks.26.attn.qkv.weight",
+    ):
+        assert not _is_unconsumed_checkpoint_weight(name)
+    assert torch.bfloat16.is_floating_point
+
+
+def test_encode_ids_enters_encoder_root_forward() -> None:
+    encoder = MiniMaxH3Encoder.__new__(MiniMaxH3Encoder)
+    torch.nn.Module.__init__(encoder)
+    encoder.register_parameter("anchor", torch.nn.Parameter(torch.zeros(())))
+    encoder.hidden_dim = 4
+    input_ids = torch.tensor([1, 2, 3])
+    expected = torch.arange(12, dtype=torch.bfloat16).reshape(1, 3, 4)
+
+    with patch.object(encoder, "forward", return_value=expected) as forward:
+        actual = encoder.encode_ids(input_ids)
+
+    torch.testing.assert_close(actual, expected[0])
+    call = forward.call_args.kwargs
+    assert torch.equal(call["input_ids"], input_ids.unsqueeze(0))
+    assert torch.equal(call["attention_mask"], torch.ones(1, 3, dtype=torch.long))
+    assert set(call) == {"input_ids", "attention_mask"}
+
+
+def test_encoder_tp_shards_fused_columns_by_logical_section() -> None:
+    linear = torch.nn.Linear(4, 12, bias=True)
+    original_weight = linear.weight.detach().clone()
+    original_bias = linear.bias.detach().clone()
+
+    _shard_linear_output(linear, rank=1, world_size=2, sections=(4, 4, 4))
+
+    expected_weight = torch.cat(tuple(section.chunk(2)[1] for section in original_weight.split((4, 4, 4))))
+    expected_bias = torch.cat(tuple(section.chunk(2)[1] for section in original_bias.split((4, 4, 4))))
+    torch.testing.assert_close(linear.weight, expected_weight)
+    torch.testing.assert_close(linear.bias, expected_bias)
+    assert linear.out_features == 6
+
+
+def test_encoder_tp_row_shard_adds_bias_on_rank_zero_only() -> None:
+    rank_zero = torch.nn.Linear(4, 3, bias=True)
+    rank_one = torch.nn.Linear(4, 3, bias=True)
+    rank_one.load_state_dict(rank_zero.state_dict())
+    original_weight = rank_zero.weight.detach().clone()
+    original_bias = rank_zero.bias.detach().clone()
+
+    _shard_linear_input(rank_zero, rank=0, world_size=2)
+    _shard_linear_input(rank_one, rank=1, world_size=2)
+
+    torch.testing.assert_close(rank_zero.weight, original_weight.chunk(2, dim=1)[0])
+    torch.testing.assert_close(rank_one.weight, original_weight.chunk(2, dim=1)[1])
+    torch.testing.assert_close(rank_zero.bias, original_bias)
+    torch.testing.assert_close(rank_one.bias, torch.zeros_like(original_bias))
+    assert rank_zero.in_features == rank_one.in_features == 2
diff --git a/tests/unit/models/test_minimax_h3_video_vae.py b/tests/unit/models/test_minimax_h3_video_vae.py
new file mode 100644
index 00000000..7fa905d8
--- /dev/null
+++ b/tests/unit/models/test_minimax_h3_video_vae.py
@@ -0,0 +1,80 @@
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+import torch
+
+from telefuser.models.minimax_h3_video.klvae import AutoencoderKL
+from telefuser.models.minimax_h3_video_vae import (
+    MiniMaxH3VideoVAEConfig,
+    MiniMaxH3VideoVAEStateDictConverter,
+)
+
+
+def _config() -> MiniMaxH3VideoVAEConfig:
+    return MiniMaxH3VideoVAEConfig(
+        architecture={"vae_ratio": 16, "vae_ratio_t": 4, "embed_dim": 24},
+        clip_length=17,
+        token_drop=3,
+        encoder_tiling=True,
+        decoder_tiling=True,
+        tile_size=256,
+        tile_overlap_min=64,
+        chunk_dim=-1,
+        latent_channels=24,
+        latents_mean=(0.0,) * 24,
+        latents_std=(1.0,) * 24,
+    )
+
+
+def test_video_vae_config_reads_released_component(tmp_path: Path) -> None:
+    source = tmp_path / "source"
+    source.mkdir()
+    (tmp_path / "config.json").write_text(
+        '{"source_path":"source","vae_clip_length":17,"vae_token_drop":3,'
+        '"vae_encoder_tiling":1,"vae_decoder_tiling":1,"vae_tile_size":256,'
+        '"vae_tile_overlap_min":64,"vae_chunk_dim":-1,"latent_channels":24,'
+        '"latents_mean":[' + ",".join(["0"] * 24) + "],"
+        '"latents_std":[' + ",".join(["1"] * 24) + "]}",
+        encoding="utf-8",
+    )
+    (source / "config.json").write_text(
+        '{"vae_ratio":16,"vae_ratio_t":4,"embed_dim":24}',
+        encoding="utf-8",
+    )
+    config = MiniMaxH3VideoVAEConfig.from_path(tmp_path)
+    assert config.latent_channels == 24
+    assert config.model_kwargs()["parallel_tiling"] is False
+
+
+def test_video_vae_config_rejects_wrong_geometry() -> None:
+    config = _config()
+    config.architecture["vae_ratio_t"] = 8
+    with pytest.raises(ValueError, match="f16/t4/d24"):
+        config.validate()
+
+
+def test_video_vae_converter_prefixes_composed_model() -> None:
+    converter = MiniMaxH3VideoVAEStateDictConverter.__new__(MiniMaxH3VideoVAEStateDictConverter)
+    converter.config = _config()
+    state = {"encoder.conv_in.conv.weight": torch.zeros(1)}
+    converted, kwargs = converter.from_official(state)
+    assert set(converted) == {"model.encoder.conv_in.conv.weight"}
+    assert kwargs == {"config": converter.config}
+
+
+def test_parallel_tile_gather_restores_round_robin_order() -> None:
+    model = AutoencoderKL.__new__(AutoencoderKL)
+    torch.nn.Module.__init__(model)
+    model.parallel_tiling = True
+    model.tile_parallel_group = MagicMock()
+    gathered = torch.tensor([[[0.0], [2.0]], [[1.0], [0.0]]])
+
+    with (
+        patch.object(model, "_tile_parallel_state", return_value=(1, 2)),
+        patch("telefuser.models.minimax_h3_video.klvae.all_gather_stacked", return_value=gathered) as gather,
+    ):
+        results = model._all_gather_tiled_results([torch.tensor([1.0])], num_tiles=3)
+
+    gather.assert_called_once()
+    assert [float(value.item()) for value in results] == [0.0, 1.0, 2.0]
diff --git a/tests/unit/ops/test_activations.py b/tests/unit/ops/test_activations.py
index 35a7e069..b7a11a3f 100644
--- a/tests/unit/ops/test_activations.py
+++ b/tests/unit/ops/test_activations.py
@@ -12,7 +12,10 @@
     FP32SiLU,
     LinearActivation,
     SwiGLU,
+    gelu_and_mul,
     get_activation,
+    silu_and_mul,
+    silu_and_mul_reuse_input,
 )
 from tests.conftest import requires_cuda
 
@@ -47,6 +50,35 @@ def test_invalid_activation(self):
             get_activation("invalid")
 
 
+def test_fused_gated_activations_fall_back_for_cpu_tensors() -> None:
+    x = torch.randn(2, 8)
+    gate, value = x.chunk(2, dim=-1)
+
+    torch.testing.assert_close(silu_and_mul(x), torch.nn.functional.silu(gate) * value)
+    torch.testing.assert_close(gelu_and_mul(x), torch.nn.functional.gelu(gate) * value)
+
+
+def test_reuse_input_falls_back_without_mutating_cpu_input() -> None:
+    value = torch.randn(3, 8)
+    original = value.clone()
+
+    torch.testing.assert_close(silu_and_mul_reuse_input(value), silu_and_mul(original))
+    torch.testing.assert_close(value, original)
+
+
+@requires_cuda
+def test_reuse_input_uses_rounded_inplace_cuda_path() -> None:
+    value = torch.randn(17, 64, device="cuda", dtype=torch.bfloat16)
+    original = value.clone()
+    gate, up = original.chunk(2, dim=-1)
+    expected = torch.nn.functional.silu(gate).to(torch.bfloat16) * up
+
+    output = silu_and_mul_reuse_input(value)
+
+    assert output.data_ptr() == value.data_ptr()
+    assert torch.equal(output, expected)
+
+
 class TestFP32SiLU:
     """Test FP32SiLU activation."""
 
diff --git a/tests/unit/ops/test_attention_backends.py b/tests/unit/ops/test_attention_backends.py
index 03940331..296268e5 100644
--- a/tests/unit/ops/test_attention_backends.py
+++ b/tests/unit/ops/test_attention_backends.py
@@ -60,6 +60,73 @@ def test_flash_attn4_dispatch_unwraps_output_when_lse_is_disabled() -> None:
     )
 
 
+def test_flash_attn4_varlen_dispatch_reuses_cumulative_lengths() -> None:
+    q = torch.randn(1, 5, 2, 4)
+    cu_seqlens = torch.tensor([0, 2, 5], dtype=torch.int32)
+    flash_attn4_varlen = MagicMock(return_value=q[0])
+
+    with (
+        patch.object(attention_impl, "FLASH_ATTN_4_AVAILABLE", True),
+        patch.object(attention_impl, "flash_attn4", MagicMock()),
+        patch.object(attention_impl, "flash_attn4_varlen", flash_attn4_varlen),
+    ):
+        output = attention_impl.attention(
+            q,
+            q,
+            q,
+            attn_impl=attention_impl.AttnImplType.FLASH_ATTN_4,
+            sequence_lengths=[2, 3],
+            cu_seqlens=cu_seqlens,
+            scale=0.5,
+        )
+
+    torch.testing.assert_close(output, q)
+    flash_attn4_varlen.assert_called_once()
+    args = flash_attn4_varlen.call_args.args
+    kwargs = flash_attn4_varlen.call_args.kwargs
+    for actual in args:
+        torch.testing.assert_close(actual, q[0])
+    torch.testing.assert_close(kwargs.pop("cu_seqlens_q"), cu_seqlens)
+    torch.testing.assert_close(kwargs.pop("cu_seqlens_k"), cu_seqlens)
+    assert kwargs == {
+        "max_seqlen_q": 3,
+        "max_seqlen_k": 3,
+        "softmax_scale": 0.5,
+        "causal": False,
+        "return_lse": False,
+    }
+
+
+def test_flash_attn4_packed_falls_back_to_sdpa_without_varlen_backend() -> None:
+    q = torch.randn(1, 5, 2, 4)
+
+    with (
+        patch.object(attention_impl, "FLASH_ATTN_4_AVAILABLE", True),
+        patch.object(attention_impl, "flash_attn4", MagicMock()),
+        patch.object(attention_impl, "flash_attn4_varlen", None),
+    ):
+        output = attention_impl.attention(
+            q,
+            q,
+            q,
+            attn_impl=attention_impl.AttnImplType.FLASH_ATTN_4,
+            sequence_lengths=[2, 3],
+        )
+
+    expected = torch.cat(
+        [
+            torch.nn.functional.scaled_dot_product_attention(
+                part.transpose(0, 1).unsqueeze(0),
+                part.transpose(0, 1).unsqueeze(0),
+                part.transpose(0, 1).unsqueeze(0),
+            )
+            for part in (q[0, :2], q[0, 2:])
+        ],
+        dim=2,
+    ).transpose(1, 2)
+    torch.testing.assert_close(output, expected)
+
+
 def test_sage_attention_prefers_tf_kernel() -> None:
     imported_modules: list[str] = []
     tf_kernel_module = ModuleType("tf_kernel")
diff --git a/tests/unit/ops/test_normalization.py b/tests/unit/ops/test_normalization.py
index 24abd928..c64d8d59 100644
--- a/tests/unit/ops/test_normalization.py
+++ b/tests/unit/ops/test_normalization.py
@@ -10,6 +10,8 @@
     RMSNorm,
     _fused_add_layer_norm_scale_shift,
     _fused_layer_norm_scale_shift,
+    indexed_gate,
+    indexed_scale_shift,
 )
 
 
@@ -38,6 +40,90 @@ def test_fused_add_layer_norm_scale_shift_matches_native() -> None:
     torch.testing.assert_close(output, expected, atol=5e-5, rtol=1e-5)
 
 
+def test_indexed_scale_shift_matches_native() -> None:
+    x = torch.randn(7, 16)
+    shift = torch.randn(3, 16)
+    scale = torch.randn(3, 16)
+    indices = torch.tensor([0, 2, 1, 0, 1, 2, 2])
+
+    output = indexed_scale_shift(x, shift, scale, indices)
+    expected = x * (1 + scale.index_select(0, indices)) + shift.index_select(0, indices)
+
+    torch.testing.assert_close(output, expected)
+
+
+def test_indexed_gate_matches_native() -> None:
+    x = torch.randn(7, 16)
+    other = torch.randn_like(x)
+    gate = torch.randn(3, 16)
+    indices = torch.tensor([0, 2, 1, 0, 1, 2, 2])
+
+    output = indexed_gate(x, gate, other, indices)
+    expected = x + gate.index_select(0, indices) * other
+
+    torch.testing.assert_close(output, expected)
+
+
+def test_indexed_modulation_validates_tensor_metadata() -> None:
+    x = torch.randn(4, 8)
+    shift = torch.randn(2, 8)
+    scale = torch.randn(2, 8)
+    indices = torch.tensor([0, 1, 0, 1])
+
+    with pytest.raises(ValueError, match="one entry per input row"):
+        indexed_scale_shift(x, shift, scale, indices[:-1])
+    with pytest.raises(TypeError, match="int32 or int64"):
+        indexed_scale_shift(x, shift, scale, indices.float())
+    with pytest.raises(ValueError, match="same number of rows"):
+        indexed_scale_shift(x, shift, torch.randn(3, 8), indices)
+    with pytest.raises(ValueError, match="hidden dimension"):
+        indexed_scale_shift(x, shift, torch.randn(2, 7), indices)
+    with pytest.raises(ValueError, match="per-row tensors"):
+        indexed_gate(x, shift, torch.randn(3, 8), indices)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required for the Triton kernel")
+def test_indexed_modulation_masks_out_of_range_indices() -> None:
+    device = torch.device("cuda")
+    dtype = torch.bfloat16
+    indices = torch.tensor([0, -1, 1, 7], device=device)
+    x = torch.randn(4, 128, device=device, dtype=dtype)
+    shift = torch.randn(2, 128, device=device, dtype=dtype)
+    scale = torch.randn(2, 128, device=device, dtype=dtype)
+    gate = torch.randn(2, 128, device=device, dtype=dtype)
+    other = torch.randn_like(x)
+
+    scale_shift_output = indexed_scale_shift(x.clone(), shift, scale, indices)
+    gate_output = indexed_gate(x.clone(), gate, other, indices)
+    torch.cuda.synchronize()
+
+    torch.testing.assert_close(scale_shift_output[[1, 3]], x[[1, 3]], atol=0, rtol=0)
+    torch.testing.assert_close(gate_output[[1, 3]], x[[1, 3]], atol=0, rtol=0)
+
+
+@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required for the Triton kernel")
+def test_indexed_modulation_supports_row_strided_parameters() -> None:
+    device = torch.device("cuda")
+    dtype = torch.bfloat16
+    rows, parameter_rows, hidden_size = 7, 3, 128
+    indices = torch.tensor([0, 2, 1, 0, 1, 2, 2], device=device)
+    parameters = torch.randn(parameter_rows, hidden_size * 3, device=device, dtype=dtype)
+    shift, scale, gate = parameters.chunk(3, dim=-1)
+    assert not shift.is_contiguous()
+    assert shift.stride(-1) == scale.stride(-1) == gate.stride(-1) == 1
+
+    x = torch.randn(rows, hidden_size, device=device, dtype=dtype)
+    other = torch.randn_like(x)
+    expected_scale_shift = x * (1 + scale.index_select(0, indices)) + shift.index_select(0, indices)
+    expected_gate = x + gate.index_select(0, indices) * other
+
+    output_scale_shift = indexed_scale_shift(x.clone(), shift, scale, indices)
+    output_gate = indexed_gate(x.clone(), gate, other, indices)
+
+    torch.testing.assert_close(output_scale_shift, expected_scale_shift, atol=0, rtol=0)
+    torch.testing.assert_close(output_gate, expected_gate, atol=0, rtol=0)
+
+
 class TestRMSNorm:
     """Test RMSNorm layer."""
 
diff --git a/tests/unit/pipelines/minimax_h3/__init__.py b/tests/unit/pipelines/minimax_h3/__init__.py
new file mode 100644
index 00000000..f1c02203
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for the MiniMax H3 pipeline."""
diff --git a/tests/unit/pipelines/minimax_h3/test_artifact_comparison.py b/tests/unit/pipelines/minimax_h3/test_artifact_comparison.py
new file mode 100644
index 00000000..54561c44
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_artifact_comparison.py
@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from tools.validation.compare_minimax_h3_artifacts import (
+    _audio_temporal_metrics,
+    _best_lag_samples,
+    _compare_video,
+)
+
+
+def _save(path: Path, value: np.ndarray) -> Path:
+    np.save(path, value)
+    return path
+
+
+def test_compare_video_records_each_frame_and_worst_frame(tmp_path: Path) -> None:
+    reference = np.arange(24, dtype=np.uint8).reshape(2, 2, 2, 3)
+    candidate = reference.copy()
+    candidate[1] += 1
+
+    report = _compare_video(_save(tmp_path / "reference.npy", reference), _save(tmp_path / "candidate.npy", candidate))
+
+    assert len(report["per_frame"]) == 2
+    assert report["per_frame"][0]["exact_fraction"] == 1.0
+    assert report["per_frame_summary"]["max_rmse_frame_index"] == 1
+    assert report["per_frame_summary"]["min_psnr_frame_index"] == 1
+
+
+def test_audio_temporal_metrics_record_exact_windows_and_zero_lag(tmp_path: Path) -> None:
+    sample_rate = 2048
+    time = np.arange(2 * sample_rate, dtype=np.float32) / sample_rate
+    signal = np.stack((np.sin(2 * np.pi * 120 * time), np.sin(2 * np.pi * 240 * time))).astype(np.float32)
+    reference_path = _save(tmp_path / "reference.npy", signal)
+    candidate_path = _save(tmp_path / "candidate.npy", signal.copy())
+
+    report = _audio_temporal_metrics(reference_path, candidate_path, sample_rate=sample_rate)
+
+    assert len(report["per_second"]) == 2
+    assert report["summary"]["min_cosine_similarity"] == pytest.approx(1.0)
+    assert report["summary"]["min_log_spectral_cosine"] == pytest.approx(1.0)
+    assert report["summary"]["energy_envelope_correlation"] == pytest.approx(1.0)
+    assert report["summary"]["best_lag_samples"] == 0
+
+
+def test_best_lag_samples_reports_candidate_delay() -> None:
+    rng = np.random.default_rng(0)
+    reference = rng.standard_normal(8192)
+    candidate = np.concatenate((np.zeros(64), reference[:-64]))
+    reference_before = reference.copy()
+    candidate_before = candidate.copy()
+
+    assert _best_lag_samples(reference, candidate, sample_rate=2048) == 64
+    np.testing.assert_array_equal(reference, reference_before)
+    np.testing.assert_array_equal(candidate, candidate_before)
diff --git a/tests/unit/pipelines/minimax_h3/test_canvas.py b/tests/unit/pipelines/minimax_h3/test_canvas.py
new file mode 100644
index 00000000..6988eb6a
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_canvas.py
@@ -0,0 +1,34 @@
+import pytest
+from PIL import Image
+
+from telefuser.pipelines.minimax_h3.canvas import (
+    minimax_h3_cover_crop_plan,
+    minimax_h3_prepare_keyframe_canvas,
+)
+
+
+def test_cover_crop_is_centered_and_refuses_implicit_upscale() -> None:
+    plan = minimax_h3_cover_crop_plan(
+        source_width=1600,
+        source_height=1200,
+        target_width=1344,
+        target_height=768,
+        allow_upscale=False,
+    )
+    assert plan["resized_size"] == (1344, 1008)
+    assert plan["crop_box"] == (0, 120, 1344, 888)
+    with pytest.raises(ValueError, match="allow_upscale=true"):
+        minimax_h3_cover_crop_plan(
+            source_width=320,
+            source_height=240,
+            target_width=1344,
+            target_height=768,
+            allow_upscale=False,
+        )
+
+
+def test_prepare_keyframe_canvas_returns_target_rgb_image() -> None:
+    source = Image.new("RGBA", (1600, 1200), color=(255, 0, 0, 128))
+    actual = minimax_h3_prepare_keyframe_canvas(source, target_width=1344, target_height=768, allow_upscale=False)
+    assert actual.mode == "RGB"
+    assert actual.size == (1344, 768)
diff --git a/tests/unit/pipelines/minimax_h3/test_data.py b/tests/unit/pipelines/minimax_h3/test_data.py
new file mode 100644
index 00000000..a9f56c04
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_data.py
@@ -0,0 +1,173 @@
+"""CPU contracts derived from SGLang test_minimax_h3_admission.py."""
+
+import pytest
+
+from telefuser.pipelines.minimax_h3.data import (
+    minimax_h3_validate_canonical_request,
+    minimax_h3_validate_reference_media_facts,
+)
+from telefuser.pipelines.minimax_h3.resolved_plan import minimax_h3_resolve_plan
+from telefuser.pipelines.minimax_h3.task_profiles import partition_for_task
+
+TARGET = {"short_edge": 768, "aspect_ratio": "16:9", "duration_seconds": 5.0}
+
+
+@pytest.mark.parametrize(
+    ("task", "conditions", "partition", "chains"),
+    [
+        ("t2va", [], "fl2va", []),
+        (
+            "fl2va",
+            [
+                {"type": "image", "uri": "file:///first.png", "role": "keyframe", "frame_index": 0},
+                {"type": "image", "uri": "file:///last.png", "role": "keyframe", "frame_index": -1},
+            ],
+            "fl2va",
+            ["image.target_canvas", "image.target_canvas"],
+        ),
+        (
+            "ref2va",
+            [
+                {"type": "image", "uri": "file:///image.png", "role": "reference"},
+                {
+                    "type": "video",
+                    "uri": "file:///video.mp4",
+                    "role": "reference",
+                    "start_time_seconds": 12.5,
+                },
+                {"type": "audio", "uri": "file:///audio.wav", "role": "reference"},
+                {"type": "video_audio", "uri": "file:///av.mp4", "role": "reference"},
+            ],
+            "ref2va",
+            [
+                "image.reference_preserve",
+                "video.reference_preserve",
+                "audio",
+                "video_audio.reference_preserve",
+            ],
+        ),
+    ],
+)
+def test_public_tasks_resolve_to_exact_partition_and_material_plan(
+    task: str,
+    conditions: list[dict[str, object]],
+    partition: str,
+    chains: list[str],
+) -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task=task, prompt="contract", conditions=conditions, target=TARGET, seed=0
+    )
+    plan = minimax_h3_resolve_plan(canonical)
+
+    assert partition_for_task(task) == partition
+    assert plan.task == task
+    assert [material.material_chain for material in plan.materials] == chains
+    assert plan.shape["frame_count"] == 124
+    assert plan.shape["video_latent_t"] == 37
+
+
+def test_fl2va_signatures_preserve_first_and_last_semantics() -> None:
+    for indices in ([0], [-1], [0, -1]):
+        conditions = [
+            {"type": "image", "uri": f"file:///{index}.png", "role": "keyframe", "frame_index": index}
+            for index in indices
+        ]
+        plan = minimax_h3_resolve_plan(
+            minimax_h3_validate_canonical_request(
+                task="fl2va", prompt="contract", conditions=conditions, target=TARGET, seed=0
+            )
+        )
+        assert [material.frame_index for material in plan.materials] == indices
+        assert [material.resolved_frame_index for material in plan.materials] == [
+            123 if index == -1 else index for index in indices
+        ]
+
+
+def test_task_names_are_normalized_once() -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task=" T2VA ", prompt="contract", conditions=[], target=TARGET, seed=0
+    )
+    assert canonical["task"] == "t2va"
+    assert partition_for_task(" T2VA ") == "fl2va"
+
+
+@pytest.mark.parametrize("duration", [3.9, 15.1])
+def test_duration_outside_release_range_fails_before_model_execution(duration: float) -> None:
+    with pytest.raises(ValueError, match=r"\[4, 15\]"):
+        minimax_h3_validate_canonical_request(
+            task="t2va",
+            prompt="contract",
+            conditions=[],
+            target={**TARGET, "duration_seconds": duration},
+            seed=0,
+        )
+
+
+def test_ref2va_order_and_audio_duration_source_are_preserved() -> None:
+    conditions = [
+        {"type": "image", "uri": "file:///subject.png", "role": "reference"},
+        {"type": "audio", "uri": "file:///voice.wav", "role": "reference"},
+    ]
+    canonical = minimax_h3_validate_canonical_request(
+        task="ref2va",
+        prompt="contract",
+        conditions=conditions,
+        target={"short_edge": 768, "aspect_ratio": "auto"},
+        seed=0,
+    )
+    plan = minimax_h3_resolve_plan(canonical)
+    assert [material.condition_type for material in plan.materials] == ["image", "audio"]
+    assert plan.shape["temporal"] == "deferred_from_audio_reference"
+
+
+def test_invalid_material_combinations_report_field_paths() -> None:
+    with pytest.raises(ValueError, match=r"conditions\[0\]"):
+        minimax_h3_validate_canonical_request(
+            task="fl2va",
+            prompt="contract",
+            conditions=[{"type": "audio", "uri": "file:///x.wav", "role": "reference"}],
+            target=TARGET,
+            seed=0,
+        )
+
+
+def test_ref2va_release_count_limits_and_audio_companion_rule() -> None:
+    images = [{"type": "image", "uri": f"file:///{index}.png", "role": "reference"} for index in range(10)]
+    with pytest.raises(ValueError, match="at most 9 image"):
+        minimax_h3_validate_canonical_request(
+            task="ref2va", prompt="contract", conditions=images, target=TARGET, seed=0
+        )
+    with pytest.raises(ValueError, match="require at least one image or video"):
+        minimax_h3_validate_canonical_request(
+            task="ref2va",
+            prompt="contract",
+            conditions=[{"type": "audio", "uri": "file:///voice.wav", "role": "reference"}],
+            target=TARGET,
+            seed=0,
+        )
+
+
+def test_ref2va_probed_clip_and_total_duration_limits() -> None:
+    conditions = [
+        {"type": "image", "uri": "file:///subject.png", "role": "reference"},
+        {"type": "video", "uri": "file:///one.mp4", "role": "reference"},
+        {"type": "video", "uri": "file:///two.mp4", "role": "reference"},
+        {"type": "audio", "uri": "file:///voice.wav", "role": "reference"},
+    ]
+    minimax_h3_validate_reference_media_facts(
+        conditions,
+        video_duration_seconds_by_condition={1: 7.5, 2: 7.5},
+        audio_duration_seconds_by_condition={3: 2.0},
+    )
+    with pytest.raises(ValueError, match="video total duration"):
+        minimax_h3_validate_reference_media_facts(
+            conditions,
+            video_duration_seconds_by_condition={1: 8.0, 2: 7.1},
+            audio_duration_seconds_by_condition={3: 2.0},
+        )
+    with pytest.raises(ValueError, match=r"conditions\[3\] audio duration"):
+        minimax_h3_validate_reference_media_facts(
+            conditions,
+            video_duration_seconds_by_condition={1: 7.5, 2: 7.5},
+            audio_duration_seconds_by_condition={3: 1.9},
+        )
diff --git a/tests/unit/pipelines/minimax_h3/test_examples.py b/tests/unit/pipelines/minimax_h3/test_examples.py
new file mode 100644
index 00000000..bf4c8eab
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_examples.py
@@ -0,0 +1,196 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from examples.minimax_h3 import minimax_h3_fl2va_h100 as fl2va_example
+from examples.minimax_h3 import minimax_h3_ref2va_h100 as ref2va_example
+from examples.minimax_h3 import minimax_h3_request_h100 as request_example
+from examples.minimax_h3.common import (
+    MINIMAX_H3_DEFAULT_FL2VA_IMAGE,
+    MINIMAX_H3_DEFAULT_REF2VA_AUDIO,
+    MINIMAX_H3_DEFAULT_REF2VA_VIDEO,
+    load_minimax_h3_request,
+    partition_for_minimax_h3_request,
+)
+from examples.minimax_h3.minimax_h3_fl2va_h100 import build_fl2va_conditions
+from examples.minimax_h3.minimax_h3_ref2va_h100 import default_ref2va_conditions
+from telefuser.core.config import AttnImplType
+from telefuser.service.core.pipeline_contract import PipelineContract
+
+
+def test_fl2va_example_builds_every_public_keyframe_signature() -> None:
+    assert build_fl2va_conditions(mode="t2va", image=None, last_image=None) == []
+    assert [item["frame_index"] for item in build_fl2va_conditions(mode="first-frame", image="a", last_image=None)] == [
+        0
+    ]
+    assert [item["frame_index"] for item in build_fl2va_conditions(mode="last-frame", image=None, last_image="b")] == [
+        -1
+    ]
+    assert [item["frame_index"] for item in build_fl2va_conditions(mode="first-last", image="a", last_image="b")] == [
+        0,
+        -1,
+    ]
+
+
+def test_fl2va_example_keeps_legacy_mode_inference_and_accepts_last_only() -> None:
+    assert build_fl2va_conditions(mode=None, image=None, last_image=None) == []
+    assert build_fl2va_conditions(mode=None, image=None, last_image="last.png")[0]["frame_index"] == -1
+    with pytest.raises(ValueError, match="does not accept"):
+        build_fl2va_conditions(mode="t2va", image="first.png", last_image=None)
+
+
+def test_default_materials_are_source_controlled_example_inputs() -> None:
+    assert MINIMAX_H3_DEFAULT_FL2VA_IMAGE.is_file()
+    assert MINIMAX_H3_DEFAULT_REF2VA_VIDEO.is_file()
+    assert MINIMAX_H3_DEFAULT_REF2VA_AUDIO.is_file()
+    assert [item["type"] for item in default_ref2va_conditions()] == ["video", "audio"]
+
+
+def test_examples_expose_standard_pipeline_service_entrypoints() -> None:
+    for example in (fl2va_example, ref2va_example, request_example):
+        assert example.PPL_CONFIG["model_root"]
+        assert callable(example.get_pipeline)
+        assert callable(example.run)
+        assert callable(example.run_with_file)
+
+    for example in (fl2va_example, ref2va_example):
+        assert example.PIPELINE_MANIFEST["entrypoints"] == {
+            "get_pipeline": "get_pipeline",
+            "run_with_file": "run_with_file",
+        }
+
+    fl2va_contract = PipelineContract.from_mapping(fl2va_example.PIPELINE_MANIFEST, fallback_name="fl2va")
+    ref2va_contract = PipelineContract.from_mapping(ref2va_example.PIPELINE_MANIFEST, fallback_name="ref2va")
+    assert fl2va_contract.supported_tasks == ("t2v", "i2v", "fl2v")
+    assert ref2va_contract.supported_tasks == ("s2v",)
+
+    assert fl2va_example.PIPELINE_MANIFEST["supported_tasks"] == ["t2v", "i2v", "fl2v"]
+    assert ref2va_example.PIPELINE_MANIFEST["supported_tasks"] == ["s2v"]
+    conditions = ref2va_example.PIPELINE_MANIFEST["task_contracts"]["s2v"]["parameters"]["conditions"]
+    assert conditions["type"] == "array"
+    assert conditions["required"] is True
+
+
+def test_standard_get_pipeline_forwards_parallel_runtime_options(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = []
+    sentinel = object()
+
+    def fake_loader(model_root: str, **kwargs: object) -> object:
+        calls.append((model_root, kwargs))
+        return sentinel
+
+    monkeypatch.setattr(fl2va_example, "load_minimax_h3_pipeline", fake_loader)
+    result = fl2va_example.get_pipeline(4, "/models/h3", device="cuda:1", num_inference_steps=20, enable_fsdp=True)
+
+    assert result is sentinel
+    assert calls == [
+        (
+            "/models/h3",
+            {
+                "partition": "FL2VA",
+                "device": "cuda:1",
+                "num_inference_steps": 20,
+                "ulysses_degree": 2,
+                "tp_degree": 2,
+                "text_encoder_tp_degree": 4,
+                "enable_fsdp": True,
+                "attn_impl": AttnImplType.FLASH_ATTN_4,
+            },
+        )
+    ]
+
+
+def test_fl2va_run_maps_standard_service_tasks_to_model_conditions() -> None:
+    calls = []
+    marker = object()
+
+    class Pipeline:
+        def __call__(self, **kwargs: object) -> object:
+            calls.append(kwargs)
+            return marker
+
+    pipeline = Pipeline()
+    assert fl2va_example.run(pipeline, task="t2v") is marker
+    assert calls[-1]["task"] == "t2va"
+    assert calls[-1]["conditions"] == []
+    with pytest.raises(ValueError, match="requires first_image_path"):
+        fl2va_example.run(pipeline, task="i2v")
+    with pytest.raises(ValueError, match="requires first_image_path and last_image_path"):
+        fl2va_example.run(pipeline, task="fl2v", first_image_path="first.png")
+
+    fl2va_example.run(pipeline, task="i2v", first_image_path="first.png")
+    assert [item["frame_index"] for item in calls[-1]["conditions"]] == [0]
+
+    fl2va_example.run(pipeline, task="fl2v", first_image_path="first.png", last_image_path="last.png")
+    assert [item["frame_index"] for item in calls[-1]["conditions"]] == [0, -1]
+
+
+def test_ref2va_run_preserves_ordered_service_conditions() -> None:
+    calls = []
+    marker = object()
+    conditions = [
+        {"type": "audio", "role": "reference", "uri": "voice.mp3"},
+        {"type": "image", "role": "reference", "uri": "subject.png"},
+    ]
+
+    class Pipeline:
+        def __call__(self, **kwargs: object) -> object:
+            calls.append(kwargs)
+            return marker
+
+    assert ref2va_example.run(Pipeline(), conditions=conditions) is marker
+    assert calls[0]["conditions"] is conditions
+    assert calls[0]["task"] == "ref2va"
+
+
+def test_run_with_file_returns_service_artifact(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    saved = []
+    marker = object()
+
+    class Pipeline:
+        def __call__(self, **kwargs: object) -> object:
+            return marker
+
+    monkeypatch.setattr(fl2va_example, "save_generation", lambda result, path: saved.append((result, path)))
+    output_path = tmp_path / "result.mp4"
+    response = fl2va_example.run_with_file(Pipeline(), output_path=str(output_path))
+
+    assert response == {"output_path": str(output_path)}
+    assert saved == [(marker, str(output_path))]
+
+
+def test_request_loader_resolves_relative_materials_without_reordering(tmp_path: Path) -> None:
+    request_path = tmp_path / "request.json"
+    request_path.write_text(
+        json.dumps(
+            {
+                "task": "ref2va",
+                "prompt": "preserve order",
+                "conditions": [
+                    {"type": "audio", "role": "reference", "uri": "voice.mp3"},
+                    {"type": "video", "role": "reference", "uri": "https://example.com/reference.mp4"},
+                ],
+                "target": {"short_edge": 768, "aspect_ratio": "16:9", "duration_seconds": 5},
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    request = load_minimax_h3_request(request_path)
+
+    assert request["conditions"][0]["type"] == "audio"
+    assert request["conditions"][0]["uri"] == str(tmp_path / "voice.mp3")
+    assert request["conditions"][1]["type"] == "video"
+    assert request["conditions"][1]["uri"] == "https://example.com/reference.mp4"
+    assert partition_for_minimax_h3_request(request) == "REF2VA"
+
+
+def test_request_loader_rejects_unknown_top_level_fields(tmp_path: Path) -> None:
+    request_path = tmp_path / "request.json"
+    request_path.write_text(
+        json.dumps({"task": "t2va", "prompt": "move", "target": {}, "unexpected": True}),
+        encoding="utf-8",
+    )
+    with pytest.raises(ValueError, match="unknown fields"):
+        load_minimax_h3_request(request_path)
diff --git a/tests/unit/pipelines/minimax_h3/test_material_io.py b/tests/unit/pipelines/minimax_h3/test_material_io.py
new file mode 100644
index 00000000..93a11f4d
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_material_io.py
@@ -0,0 +1,32 @@
+from pathlib import Path
+
+import pytest
+
+from telefuser.pipelines.minimax_h3 import material_io
+
+
+def test_probe_preserves_independent_video_and_audio_durations(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        material_io,
+        "_probe_av",
+        lambda _path: {
+            "format": {"duration": "10.0"},
+            "streams": [
+                {
+                    "codec_type": "video",
+                    "width": 1920,
+                    "height": 1080,
+                    "duration": "9.5",
+                },
+                {"codec_type": "audio", "sample_rate": "48000", "duration": "6.0"},
+            ],
+        },
+    )
+
+    facts = material_io.minimax_h3_probe_material(Path("reference.mp4"), "video")
+
+    assert facts.duration_seconds == 10.0
+    assert facts.video_duration_seconds == 9.5
+    assert facts.audio_duration_seconds == 6.0
+    assert facts.sample_rate == 48_000
+    assert facts.has_audio is True
diff --git a/tests/unit/pipelines/minimax_h3/test_packed_sequence.py b/tests/unit/pipelines/minimax_h3/test_packed_sequence.py
new file mode 100644
index 00000000..9a8fd058
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_packed_sequence.py
@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Numerical contracts for MiniMax-H3 packed-sequence layouts."""
+
+import unittest
+
+from telefuser.pipelines.minimax_h3.packed_sequence import (
+    minimax_h3_packed_sequence,
+    minimax_h3_packed_sequence_ref2va_blocks,
+)
+
+
+class TestMiniMaxH3PackedSequence(unittest.TestCase):
+    def test_t2va_structure(self):
+        built = minimax_h3_packed_sequence(
+            text_len=97,
+            latent_t=62,
+            latent_h=48,
+            latent_w=76,
+            audio_t=348,
+            include_keyframe_cond=False,
+        )
+        self.assertTrue(built["update_mask"].all())
+        self.assertEqual(int(built["img_pos"].shape[0]), 62 * 24 * 38)
+        self.assertEqual(int(built["seq_len"]) % 64, 0)
+        self.assertEqual(built["token_tags"][built["audio_pos"]].unique().tolist(), [2])
+
+    def test_fl2va_first_last_cond_blocks_use_exact_rope_span(self):
+        text_len = 11
+        latent_t = 37
+        built = minimax_h3_packed_sequence(
+            text_len=text_len,
+            latent_t=latent_t,
+            latent_h=48,
+            latent_w=76,
+            audio_t=203,
+            include_keyframe_cond=True,
+            keyframe_frame_indices=[0, -1],
+            frame_count=124,
+        )
+        frame_rows = 24 * 38
+        cond_rows = 2 * frame_rows
+        self.assertEqual(int((~built["update_mask"]).sum()), cond_rows)
+        self.assertEqual(
+            int(built["img_pos"].shape[0]),
+            (2 + latent_t) * frame_rows,
+        )
+        cond_pos = built["img_pos"][:cond_rows].reshape(2, frame_rows)
+        cond_t = [float(built["img_position_ids"][positions, 0].unique().item()) for positions in cond_pos]
+        frame_rescale = 5.0 / 3.0
+        temporal_span = sum(frame_rescale * (1, 4, 4, 4, 4)[index % 5] for index in range(latent_t))
+        self.assertEqual(cond_t[0], float(text_len))
+        self.assertAlmostEqual(
+            cond_t[1],
+            float(text_len) + temporal_span - frame_rescale,
+            places=12,
+        )
+        self.assertFalse(built["update_mask"][:cond_rows].any())
+        self.assertTrue(built["update_mask"][cond_rows:].all())
+
+    def test_i2va_and_l2va_single_cond_blocks_use_endpoint_rope(self):
+        text_len = 11
+        latent_t = 37
+        frame_count = 124
+        frame_rescale = 5.0 / 3.0
+        temporal_span = sum(frame_rescale * (1, 4, 4, 4, 4)[index % 5] for index in range(latent_t))
+        for semantic_index, expected_t in (
+            (0, float(text_len)),
+            (-1, float(text_len) + temporal_span - frame_rescale),
+        ):
+            with self.subTest(semantic_index=semantic_index):
+                built = minimax_h3_packed_sequence(
+                    text_len=text_len,
+                    latent_t=latent_t,
+                    latent_h=48,
+                    latent_w=76,
+                    audio_t=203,
+                    include_keyframe_cond=True,
+                    keyframe_frame_indices=[semantic_index],
+                    frame_count=frame_count,
+                )
+                frame_rows = 24 * 38
+                self.assertEqual(int((~built["update_mask"]).sum()), frame_rows)
+                positions = built["img_pos"][:frame_rows]
+                cond_t = float(built["img_position_ids"][positions, 0].unique().item())
+                self.assertAlmostEqual(cond_t, expected_t, places=12)
+
+    def test_fl2va_keyframe_index_validation_is_defensive(self):
+        common = dict(
+            text_len=11,
+            latent_t=37,
+            latent_h=48,
+            latent_w=76,
+            audio_t=203,
+            include_keyframe_cond=True,
+            frame_count=124,
+        )
+        for frame_indices in (None, [1], [0, 52, -1]):
+            with (
+                self.subTest(frame_indices=frame_indices),
+                self.assertRaises(ValueError),
+            ):
+                minimax_h3_packed_sequence(
+                    **common,
+                    keyframe_frame_indices=frame_indices,
+                )
+
+    def test_ref2va_structure(self):
+        built = minimax_h3_packed_sequence_ref2va_blocks(
+            text_len=97,
+            latent_t=112,
+            latent_h=48,
+            latent_w=84,
+            audio_t=631,
+            ref_blocks=[
+                {"kind": "image", "latent_h": 64, "latent_w": 48},
+                {"kind": "audio", "ref_audio_t": 582},
+            ],
+        )
+
+        self.assertEqual(int(built["seq_len"]) % 64, 0)
+        self.assertEqual(int((~built["update_mask"]).sum()), 32 * 24)
+        self.assertEqual(int((~built["audio_update_mask"]).sum()), 582 * 2)
+        self.assertEqual(built["token_tags"][built["audio_pos"]].unique().tolist(), [2])
+
+    def test_ref2va_mixed_media_preserves_temporal_origin(self):
+        built = minimax_h3_packed_sequence_ref2va_blocks(
+            text_len=5,
+            latent_t=2,
+            latent_h=4,
+            latent_w=4,
+            audio_t=5,
+            ref_blocks=[
+                {"kind": "image", "latent_h": 4, "latent_w": 4},
+                {
+                    "kind": "video_audio",
+                    "ref_audio_t": 3,
+                    "latent_t": 2,
+                    "latent_h": 4,
+                    "latent_w": 4,
+                },
+                {"kind": "audio", "ref_audio_t": 1},
+            ],
+        )
+
+        self.assertEqual(int((~built["update_mask"]).sum()), 12)
+        self.assertEqual(int((~built["audio_update_mask"]).sum()), 8)
+        target_video_t0 = built["img_position_ids"][built["img_pos"][12], 0]
+        target_audio_t0 = built["img_position_ids"][built["audio_pos"][8], 0]
+        self.assertEqual(float(target_audio_t0), float(target_video_t0))
diff --git a/tests/unit/pipelines/minimax_h3/test_packed_tokens.py b/tests/unit/pipelines/minimax_h3/test_packed_tokens.py
new file mode 100644
index 00000000..c7313d40
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_packed_tokens.py
@@ -0,0 +1,22 @@
+import torch
+
+from telefuser.pipelines.minimax_h3.packed_tokens import (
+    minimax_h3_patchify_video_latent,
+    minimax_h3_unpack_audio_tokens,
+    minimax_h3_unpatchify_video_tokens,
+)
+
+
+def test_video_patchify_round_trip_preserves_native_layout() -> None:
+    latent = torch.arange(2 * 3 * 2 * 4 * 6).reshape(2, 3, 2, 4, 6)
+    rows = minimax_h3_patchify_video_latent(latent, patch_size=(1, 2, 2))
+    restored = minimax_h3_unpatchify_video_tokens(rows, latent_shape=(2, 2, 3, 3), patch_size=(1, 2, 2))
+    assert torch.equal(restored, latent)
+
+
+def test_audio_unpack_restores_channel_major_latent() -> None:
+    rows = torch.arange(12).reshape(6, 2)
+    actual = minimax_h3_unpack_audio_tokens(rows, audio_t=6, audio_channel=2)
+    assert actual.shape == (2, 2, 3)
+    assert torch.equal(actual[0], rows[:3].T)
+    assert torch.equal(actual[1], rows[3:].T)
diff --git a/tests/unit/pipelines/minimax_h3/test_parallelism.py b/tests/unit/pipelines/minimax_h3/test_parallelism.py
new file mode 100644
index 00000000..11794772
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_parallelism.py
@@ -0,0 +1,247 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+import torch
+
+from telefuser.core.config import ModelRuntimeConfig, OffloadConfig, ParallelConfig, WeightOffloadType
+from telefuser.pipelines.minimax_h3.denoising import (
+    MiniMaxH3DenoisingStage,
+    _build_local_embedding_layout,
+)
+from telefuser.pipelines.minimax_h3.text_encoding import MiniMaxH3TextEncodingStage
+from telefuser.pipelines.minimax_h3.vae import MiniMaxH3VideoVAEStage
+
+
+def _stage(parallel_config: ParallelConfig) -> tuple[MiniMaxH3DenoisingStage, MagicMock]:
+    transformer = MagicMock()
+    transformer.parameters.return_value = [torch.nn.Parameter(torch.zeros(1, dtype=torch.float32))]
+    transformer.get_fsdp_module_names.return_value = ["blocks"]
+    manager = MagicMock()
+    manager.fetch_module.return_value = transformer
+    runtime = ModelRuntimeConfig(
+        device_type="cuda",
+        device_id=0,
+        torch_dtype=torch.bfloat16,
+        parallel_config=parallel_config,
+        offload_config=OffloadConfig(offload_type=WeightOffloadType.NO_CPU_OFFLOAD),
+    )
+    return MiniMaxH3DenoisingStage(manager, runtime), transformer
+
+
+def test_local_embedding_layout_selects_only_rank_owned_rows() -> None:
+    layout = _build_local_embedding_layout(
+        seq_len=12,
+        text_pos=torch.tensor([0, 1, 2]),
+        img_pos=torch.tensor([3, 5, 6, 9, 11]),
+        audio_pos=torch.tensor([4, 7, 8, 10]),
+        world_size=2,
+        rank=1,
+        device=torch.device("cpu"),
+    )
+
+    assert layout["row_start"] == 6
+    assert layout["row_stop"] == 12
+    assert torch.equal(layout["text_source_ids"], torch.empty(0, dtype=torch.long))
+    assert torch.equal(layout["img_global_ids"], torch.tensor([6, 9, 11]))
+    assert torch.equal(layout["img_row_ids"], torch.tensor([0, 3, 5]))
+    assert torch.equal(layout["audio_global_ids"], torch.tensor([7, 8, 10]))
+    assert torch.equal(layout["audio_row_ids"], torch.tensor([1, 2, 4]))
+
+
+def test_parallel_models_enables_ulysses_and_preserves_fp32_fsdp_parameters() -> None:
+    stage, transformer = _stage(ParallelConfig(device_ids=[0, 1], sp_ulysses_degree=2, enable_fsdp=True))
+    device_mesh = MagicMock()
+    fsdp_model = MagicMock()
+    with (
+        patch(
+            "telefuser.pipelines.minimax_h3.denoising.create_device_mesh_from_config",
+            return_value=device_mesh,
+        ),
+        patch(
+            "telefuser.pipelines.minimax_h3.denoising.shard_model_fsdp2_inference",
+            return_value=fsdp_model,
+        ) as shard,
+    ):
+        stage.parallel_models()
+
+    transformer.enable_usp.assert_called_once_with(device_mesh)
+    shard.assert_called_once()
+    call = shard.call_args.kwargs
+    assert call["wrap_module_names"] == ["blocks"]
+    assert call["device_mesh"] is device_mesh
+    assert len(call["ignored_states"]) == 1
+    assert stage.transformer is fsdp_model
+
+
+@pytest.mark.parametrize(
+    ("field", "kwargs"),
+    [
+        ("cfg_degree", {"cfg_degree": 2}),
+        ("sp_ring_degree", {"sp_ring_degree": 2}),
+        ("pp_degree", {"pp_degree": 2}),
+    ],
+)
+def test_parallel_models_rejects_unsupported_degrees(field: str, kwargs: dict[str, int]) -> None:
+    stage, _ = _stage(ParallelConfig(device_ids=[0, 1], **kwargs))
+    with pytest.raises(NotImplementedError, match=field):
+        stage.parallel_models()
+
+
+def test_parallel_models_enables_tp_before_ulysses_and_keeps_shards_resident() -> None:
+    stage, transformer = _stage(ParallelConfig(device_ids=[0, 1, 2, 3], sp_ulysses_degree=2, tp_degree=2))
+    device_mesh = MagicMock()
+    calls = MagicMock()
+    calls.attach_mock(transformer.enable_tp, "enable_tp")
+    calls.attach_mock(transformer.enable_usp, "enable_usp")
+
+    with patch(
+        "telefuser.pipelines.minimax_h3.denoising.create_device_mesh_from_config",
+        return_value=device_mesh,
+    ):
+        stage.parallel_models()
+
+    assert [call[0] for call in calls.method_calls] == ["enable_tp", "enable_usp"]
+    transformer.enable_tp.assert_called_once_with(device_mesh)
+    transformer.enable_usp.assert_called_once_with(device_mesh)
+    transformer.to.assert_called_once_with(stage.device)
+    assert stage.onload_models_flag is True
+
+
+def test_parallel_models_rejects_tp_with_fsdp() -> None:
+    stage, _ = _stage(ParallelConfig(device_ids=[0, 1], tp_degree=2, enable_fsdp=True))
+    with (
+        patch("telefuser.pipelines.minimax_h3.denoising.create_device_mesh_from_config"),
+        pytest.raises(ValueError, match="cannot be combined with FSDP"),
+    ):
+        stage.parallel_models()
+
+
+def test_text_encoder_direct_handoff_keeps_token_tags_on_cpu() -> None:
+    manager = MagicMock()
+    manager.fetch_module.return_value = MagicMock()
+    stage = MiniMaxH3TextEncodingStage(
+        manager,
+        ModelRuntimeConfig(device_type="cpu"),
+        processor=MagicMock(),
+    )
+    stage.onload_models_flag = True
+    condition = MagicMock()
+    hidden_states = torch.zeros(2, 4)
+    cpu_tags = torch.tensor([1, 1])
+    condition.hidden_states = hidden_states
+    condition.token_tags.cpu.return_value = cpu_tags
+
+    with patch.object(stage, "_encode_impl", return_value=condition):
+        result = stage.encode_for_denoising(
+            task="t2va",
+            prompt="move",
+            images=[],
+            videos=[],
+            condition_labels=[],
+        )
+
+    assert result["hidden_states"] is hidden_states
+    assert result["token_tags"] is cpu_tags
+    condition.token_tags.cpu.assert_called_once_with()
+
+
+def test_text_encoder_parallel_models_enables_fsdp_residency() -> None:
+    encoder = MagicMock()
+    encoder.get_fsdp_module_names.return_value = ["fsdp_language_layers"]
+    manager = MagicMock()
+    manager.fetch_module.return_value = encoder
+    runtime = ModelRuntimeConfig(
+        device_type="cuda",
+        parallel_config=ParallelConfig(device_ids=[0, 1], sp_ulysses_degree=2, enable_fsdp=True),
+        offload_config=OffloadConfig(offload_type=WeightOffloadType.NO_CPU_OFFLOAD),
+    )
+    stage = MiniMaxH3TextEncodingStage(manager, runtime, processor=MagicMock())
+    device_mesh = MagicMock()
+    fsdp_encoder = MagicMock()
+
+    with (
+        patch(
+            "telefuser.pipelines.minimax_h3.text_encoding.create_device_mesh_from_config",
+            return_value=device_mesh,
+        ),
+        patch(
+            "telefuser.pipelines.minimax_h3.text_encoding.shard_model_fsdp2_inference",
+            return_value=fsdp_encoder,
+        ) as shard,
+    ):
+        stage.parallel_models()
+
+    shard.assert_called_once_with(
+        module=encoder,
+        device_mesh=device_mesh,
+        wrap_module_names=["fsdp_language_layers"],
+    )
+    assert stage.text_encoder is fsdp_encoder
+    assert stage.onload_models_flag is True
+
+
+def test_text_encoder_parallel_models_enables_tp_residency() -> None:
+    encoder = MagicMock()
+    manager = MagicMock()
+    manager.fetch_module.return_value = encoder
+    runtime = ModelRuntimeConfig(
+        device_type="cuda",
+        parallel_config=ParallelConfig(device_ids=[0, 1, 2, 3], tp_degree=4),
+        offload_config=OffloadConfig(offload_type=WeightOffloadType.NO_CPU_OFFLOAD),
+    )
+    stage = MiniMaxH3TextEncodingStage(manager, runtime, processor=MagicMock())
+    device_mesh = MagicMock()
+
+    with patch(
+        "telefuser.pipelines.minimax_h3.text_encoding.create_device_mesh_from_config",
+        return_value=device_mesh,
+    ):
+        stage.parallel_models()
+
+    encoder.enable_tp.assert_called_once_with(device_mesh)
+    encoder.to.assert_called_once_with(stage.device)
+    assert stage.onload_models_flag is True
+
+
+def test_text_encoder_parallel_models_requires_fsdp() -> None:
+    manager = MagicMock()
+    manager.fetch_module.return_value = MagicMock()
+    stage = MiniMaxH3TextEncodingStage(
+        manager,
+        ModelRuntimeConfig(
+            device_type="cuda",
+            parallel_config=ParallelConfig(device_ids=[0, 1], sp_ulysses_degree=2),
+            offload_config=OffloadConfig(offload_type=WeightOffloadType.NO_CPU_OFFLOAD),
+        ),
+        processor=MagicMock(),
+    )
+
+    with pytest.raises(NotImplementedError, match="requires TP or FSDP"):
+        stage.parallel_models()
+
+
+def test_video_vae_parallel_models_enables_tile_residency() -> None:
+    video_vae = MagicMock()
+    manager = MagicMock()
+    manager.fetch_module.return_value = video_vae
+    runtime = ModelRuntimeConfig(
+        device_type="cuda",
+        parallel_config=ParallelConfig(device_ids=[0, 1, 2, 3], tp_degree=4),
+        offload_config=OffloadConfig(offload_type=WeightOffloadType.NO_CPU_OFFLOAD),
+    )
+    stage = MiniMaxH3VideoVAEStage(manager, runtime)
+    device_mesh = MagicMock()
+    group = MagicMock()
+
+    with (
+        patch(
+            "telefuser.pipelines.minimax_h3.vae.create_device_mesh_from_config",
+            return_value=device_mesh,
+        ),
+        patch("telefuser.pipelines.minimax_h3.vae.get_tp_group", return_value=group),
+    ):
+        stage.parallel_models()
+
+    video_vae.enable_parallel_tiling.assert_called_once_with(group)
+    video_vae.to.assert_called_once_with(stage.device)
+    assert stage.onload_models_flag is True
diff --git a/tests/unit/pipelines/minimax_h3/test_pipeline.py b/tests/unit/pipelines/minimax_h3/test_pipeline.py
new file mode 100644
index 00000000..71924fb1
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_pipeline.py
@@ -0,0 +1,499 @@
+from pathlib import Path
+
+import pytest
+import torch
+
+from telefuser.core.config import AttnImplType, ModelRuntimeConfig, ParallelConfig, WeightOffloadType
+from telefuser.core.module_manager import ModuleManager
+from telefuser.pipelines.minimax_h3.data import minimax_h3_validate_canonical_request
+from telefuser.pipelines.minimax_h3.denoising import MiniMaxH3DenoisingStage
+from telefuser.pipelines.minimax_h3.material_io import MiniMaxH3MaterialFacts
+from telefuser.pipelines.minimax_h3.pipeline import MiniMaxH3Pipeline, MiniMaxH3PipelineConfig
+from telefuser.pipelines.minimax_h3.resolved_plan import (
+    MiniMaxH3MaterialPlanItem,
+    minimax_h3_resolve_plan,
+)
+from telefuser.pipelines.minimax_h3.text_encoding import MiniMaxH3TextCondition
+from telefuser.pipelines.minimax_h3.vae import MiniMaxH3PreparedCondition
+from tools.validation.minimax_h3_trajectory_stage import MiniMaxH3TrajectoryDenoisingStage
+
+
+class _ZeroVelocityDiT(torch.nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.anchor = torch.nn.Parameter(torch.zeros(()))
+
+    def forward(self, **kwargs):
+        video_rows = kwargs["img_pos_for_infer_output_info"]["position_ids"].numel()
+        audio_rows = kwargs["audio_pos_info"]["position_ids"].numel()
+        device = self.anchor.device
+        return (
+            torch.zeros(video_rows, 96, device=device),
+            torch.zeros(audio_rows, 32, device=device),
+        )
+
+
+def test_deferred_fl2va_geometry_uses_first_keyframe_ratio() -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task="fl2va",
+        prompt="move",
+        conditions=[{"type": "image", "role": "keyframe", "uri": "frame.png", "frame_index": 0}],
+        target={"short_edge": 768, "aspect_ratio": "auto", "duration_seconds": 4.0},
+        seed=0,
+    )
+    _, plan = MiniMaxH3Pipeline._resolve_deferred_plan(
+        canonical,
+        {0: MiniMaxH3MaterialFacts(width=1920, height=1080)},
+    )
+    assert plan.shape["geometry"] == "resolved_v2"
+    assert plan.shape["width"] > plan.shape["height"]
+    assert plan.shape["width"] % 32 == 0
+    assert plan.shape["height"] % 32 == 0
+
+
+def test_ref2va_deferred_duration_uses_audio_stream_duration() -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task="ref2va",
+        prompt="move",
+        conditions=[
+            {
+                "type": "video",
+                "role": "reference",
+                "uri": "reference.mp4",
+                "start_time_seconds": 1.0,
+            }
+        ],
+        target={"short_edge": 768, "aspect_ratio": "auto"},
+        seed=0,
+    )
+    _, plan = MiniMaxH3Pipeline._resolve_deferred_plan(
+        canonical,
+        {
+            0: MiniMaxH3MaterialFacts(
+                width=1920,
+                height=1080,
+                duration_seconds=10.0,
+                video_duration_seconds=10.0,
+                audio_duration_seconds=6.0,
+                has_audio=True,
+            )
+        },
+    )
+    assert plan.shape["frame_count"] == 124
+
+
+def test_ref2va_deferred_duration_rejects_silent_video() -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task="ref2va",
+        prompt="move",
+        conditions=[{"type": "video", "role": "reference", "uri": "silent.mp4"}],
+        target={"short_edge": 768, "aspect_ratio": "auto"},
+        seed=0,
+    )
+    with pytest.raises(ValueError, match="exactly one probed condition with an audio stream"):
+        MiniMaxH3Pipeline._resolve_deferred_plan(
+            canonical,
+            {
+                0: MiniMaxH3MaterialFacts(
+                    width=1920,
+                    height=1080,
+                    duration_seconds=6.0,
+                    video_duration_seconds=6.0,
+                    has_audio=False,
+                )
+            },
+        )
+
+
+def test_ref2va_start_time_must_precede_soundtrack_end() -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task="ref2va",
+        prompt="move",
+        conditions=[
+            {
+                "type": "video",
+                "role": "reference",
+                "uri": "reference.mp4",
+                "start_time_seconds": 7.0,
+            }
+        ],
+        target={"short_edge": 768, "aspect_ratio": "auto", "duration_seconds": 4.0},
+        seed=0,
+    )
+    with pytest.raises(ValueError, match="soundtrack duration"):
+        MiniMaxH3Pipeline._resolve_deferred_plan(
+            canonical,
+            {
+                0: MiniMaxH3MaterialFacts(
+                    width=1920,
+                    height=1080,
+                    duration_seconds=10.0,
+                    video_duration_seconds=10.0,
+                    audio_duration_seconds=6.0,
+                    has_audio=True,
+                )
+            },
+        )
+
+
+def test_ref2va_labels_preserve_mixed_material_order() -> None:
+    materials = [
+        MiniMaxH3MaterialPlanItem(0, "reference", "image", "a", "image.reference_preserve"),
+        MiniMaxH3MaterialPlanItem(1, "reference", "audio", "b", "audio"),
+        MiniMaxH3MaterialPlanItem(2, "reference", "video", "c", "video.reference_preserve"),
+    ]
+    prepared = [
+        MiniMaxH3PreparedCondition(materials[0], "image"),
+        MiniMaxH3PreparedCondition(materials[1], "audio", has_audio=True),
+        MiniMaxH3PreparedCondition(materials[2], "video_audio", has_audio=True),
+    ]
+    assert MiniMaxH3Pipeline._condition_labels(prepared) == [
+        ("image", 1),
+        ("audio", 1),
+        ("audio", 2),
+        ("video", 1),
+    ]
+
+
+def test_t2va_denoising_stage_runs_complete_packed_contract_on_cpu() -> None:
+    manager = ModuleManager(device="cpu")
+    manager.add_module(_ZeroVelocityDiT(), "minimax_h3_transformer")
+    stage = MiniMaxH3DenoisingStage(
+        manager,
+        ModelRuntimeConfig(device_type="cpu", torch_dtype=torch.float32),
+    )
+    canonical = minimax_h3_validate_canonical_request(
+        task="t2va",
+        prompt="move",
+        conditions=[],
+        target={"short_edge": 768, "aspect_ratio": "1:1", "duration_seconds": 4.0},
+        seed=0,
+    )
+    plan = minimax_h3_resolve_plan(canonical)
+    text = MiniMaxH3TextCondition(
+        hidden_states=torch.zeros(3, 5120, dtype=torch.bfloat16),
+        token_tags=torch.ones(3, dtype=torch.long),
+    )
+    transported = stage.denoise_for_video_vae(
+        plan=plan,
+        text={"hidden_states": text.hidden_states, "token_tags": text.token_tags},
+        conditions=[],
+        num_inference_steps=2,
+    )
+    result = transported["remainder"]
+    assert transported["video_latent"].shape == (1, 24, plan.shape["video_latent_t"], 48, 48)
+    assert result.audio_latent.shape == (2, 32, plan.shape["audio_latent_t"])
+    assert result.packed["seq_len"] % 64 == 0
+    assert result.runtime_metrics["peak_allocated_bytes"] == 0
+    assert result.runtime_metrics["peak_reserved_bytes"] == 0
+    assert result.runtime_metrics["communication_seconds"] == 0.0
+
+
+def test_denoising_rejects_corrupt_transported_token_tags() -> None:
+    manager = ModuleManager(device="cpu")
+    manager.add_module(_ZeroVelocityDiT(), "minimax_h3_transformer")
+    stage = MiniMaxH3DenoisingStage(
+        manager,
+        ModelRuntimeConfig(device_type="cpu", torch_dtype=torch.float32),
+    )
+    canonical = minimax_h3_validate_canonical_request(
+        task="t2va",
+        prompt="move",
+        conditions=[],
+        target={"short_edge": 768, "aspect_ratio": "1:1", "duration_seconds": 4.0},
+        seed=0,
+    )
+    text = MiniMaxH3TextCondition(
+        hidden_states=torch.zeros(3, 5120, dtype=torch.bfloat16),
+        token_tags=torch.tensor([1, 2**62, 1], dtype=torch.long),
+    )
+
+    with pytest.raises(ValueError, match="token_tags must contain only"):
+        stage.denoise(
+            plan=minimax_h3_resolve_plan(canonical),
+            text=text,
+            conditions=[],
+            num_inference_steps=2,
+        )
+
+
+def test_trajectory_stage_captures_selected_boundaries_without_changing_result(tmp_path: Path) -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task="t2va",
+        prompt="move",
+        conditions=[],
+        target={"short_edge": 768, "aspect_ratio": "1:1", "duration_seconds": 4.0},
+        seed=0,
+    )
+    plan = minimax_h3_resolve_plan(canonical)
+    text = MiniMaxH3TextCondition(
+        hidden_states=torch.zeros(3, 5120, dtype=torch.bfloat16),
+        token_tags=torch.ones(3, dtype=torch.long),
+    )
+
+    def build_stage(stage_class, **kwargs):
+        manager = ModuleManager(device="cpu")
+        manager.add_module(_ZeroVelocityDiT(), "minimax_h3_transformer")
+        return stage_class(
+            manager,
+            ModelRuntimeConfig(device_type="cpu", torch_dtype=torch.float32),
+            **kwargs,
+        )
+
+    expected = build_stage(MiniMaxH3DenoisingStage).denoise(
+        plan=plan,
+        text=text,
+        conditions=[],
+        num_inference_steps=4,
+    )
+    trajectory_path = tmp_path / "trajectory.pt"
+    actual = build_stage(
+        MiniMaxH3TrajectoryDenoisingStage,
+        trajectory_path=trajectory_path,
+    ).denoise(
+        plan=plan,
+        text=text,
+        conditions=[],
+        num_inference_steps=4,
+    )
+
+    assert torch.equal(actual.video_latent, expected.video_latent)
+    assert torch.equal(actual.audio_latent, expected.audio_latent)
+    artifact = torch.load(trajectory_path, map_location="cpu", weights_only=True)
+    assert artifact["selected_steps"] == [0, 1, 2]
+    assert artifact["observed_transformer_steps"] == 3
+    assert artifact["observed_scheduler_steps"] == 3
+    assert set(artifact["steps"]) == {"0", "1", "2"}
+    assert torch.count_nonzero(artifact["steps"]["0"]["scheduler_input"]["input_visual_latent"]) > 0
+    assert torch.count_nonzero(artifact["steps"]["0"]["scheduler_input"]["input_audio_latent"]) > 0
+    assert torch.equal(
+        artifact["steps"]["0"]["scheduler_input"]["noise_pred_visual"],
+        torch.zeros_like(artifact["steps"]["0"]["scheduler_input"]["noise_pred_visual"]),
+    )
+
+
+def test_trajectory_stage_can_capture_only_first_update_from_full_schedule(tmp_path: Path) -> None:
+    canonical = minimax_h3_validate_canonical_request(
+        task="t2va",
+        prompt="move",
+        conditions=[],
+        target={"short_edge": 768, "aspect_ratio": "1:1", "duration_seconds": 4.0},
+        seed=0,
+    )
+    plan = minimax_h3_resolve_plan(canonical)
+    text = MiniMaxH3TextCondition(
+        hidden_states=torch.zeros(3, 5120, dtype=torch.bfloat16),
+        token_tags=torch.ones(3, dtype=torch.long),
+    )
+
+    def capture(path: Path, max_updates: int | None = None) -> dict:
+        manager = ModuleManager(device="cpu")
+        manager.add_module(_ZeroVelocityDiT(), "minimax_h3_transformer")
+        stage = MiniMaxH3TrajectoryDenoisingStage(
+            manager,
+            ModelRuntimeConfig(device_type="cpu", torch_dtype=torch.float32),
+            trajectory_path=path,
+            max_updates=max_updates,
+        )
+        stage.denoise(plan=plan, text=text, conditions=[], num_inference_steps=4)
+        return torch.load(path, map_location="cpu", weights_only=True)
+
+    full = capture(tmp_path / "full.pt")
+    first = capture(tmp_path / "first.pt", max_updates=1)
+
+    assert first["configured_num_updates"] == 3
+    assert first["num_updates"] == 1
+    assert first["trajectory_truncated"] is True
+    assert first["selected_steps"] == [0]
+    assert first["observed_transformer_steps"] == 1
+    assert first["observed_scheduler_steps"] == 1
+    assert torch.equal(
+        first["steps"]["0"]["scheduler_input"]["noise_pred_visual"],
+        full["steps"]["0"]["scheduler_input"]["noise_pred_visual"],
+    )
+
+
+def test_pipeline_wraps_multi_gpu_stages_and_closes_workers(monkeypatch: pytest.MonkeyPatch) -> None:
+    from telefuser.pipelines.minimax_h3 import pipeline as pipeline_module
+
+    class _Stage:
+        def __init__(self, *args, **kwargs) -> None:
+            pass
+
+    class _Worker:
+        def __init__(self, stage: object, **kwargs: object) -> None:
+            self.stage = stage
+            self.kwargs = kwargs
+            self.closed = False
+
+        def close(self) -> None:
+            self.closed = True
+
+    class _Channel:
+        instances = []
+
+        def __init__(self, consumer_world_size: int, **kwargs: object) -> None:
+            self.consumer_world_size = consumer_world_size
+            self.kwargs = kwargs
+            self.closed = False
+            self.instances.append(self)
+
+        def close(self) -> None:
+            self.closed = True
+
+    monkeypatch.setattr(pipeline_module.AutoProcessor, "from_pretrained", lambda *args, **kwargs: object())
+    monkeypatch.setattr(pipeline_module, "MiniMaxH3TextEncodingStage", _Stage)
+    monkeypatch.setattr(pipeline_module, "MiniMaxH3VideoVAEStage", _Stage)
+    monkeypatch.setattr(pipeline_module, "MiniMaxH3AudioVAEStage", _Stage)
+    monkeypatch.setattr(pipeline_module, "MiniMaxH3DenoisingStage", _Stage)
+    monkeypatch.setattr(pipeline_module, "ParallelWorker", _Worker)
+    monkeypatch.setattr(pipeline_module, "WorkerTensorChannel", _Channel)
+    monkeypatch.setattr(pipeline_module.dist, "is_initialized", lambda: False)
+
+    pipeline = MiniMaxH3Pipeline(device="cpu")
+    pipeline.init(
+        ModuleManager(device="cpu"),
+        MiniMaxH3PipelineConfig(
+            processor_path="processor",
+            text_encoder_config=ModelRuntimeConfig(
+                device_type="cpu",
+                parallel_config=ParallelConfig(device_ids=[0, 1], sp_ulysses_degree=2),
+            ),
+            dit_config=ModelRuntimeConfig(
+                device_type="cpu",
+                parallel_config=ParallelConfig(device_ids=[0, 1], sp_ulysses_degree=2),
+            ),
+            video_vae_config=ModelRuntimeConfig(
+                device_type="cpu",
+                parallel_config=ParallelConfig(device_ids=[0, 1], tp_degree=2),
+            ),
+        ),
+    )
+    assert isinstance(pipeline.text_stage, _Worker)
+    assert isinstance(pipeline.video_vae_stage, _Worker)
+    assert isinstance(pipeline.denoising_stage, _Worker)
+    assert len(_Channel.instances) == 3
+    assert pipeline._uses_direct_text_handoff
+    assert pipeline._uses_direct_visual_handoff
+    assert pipeline._uses_direct_video_latent_handoff
+    assert pipeline.text_stage.kwargs["tensor_output_methods"] == ("encode_for_denoising",)
+    assert pipeline.video_vae_stage.kwargs["tensor_output_methods"] == ("encode_visual_for_denoising",)
+    assert pipeline.denoising_stage.kwargs["tensor_output_methods"] == ("denoise_for_video_vae",)
+    pipeline.stop()
+    assert pipeline.text_stage.closed
+    assert pipeline.video_vae_stage.closed
+    assert pipeline.denoising_stage.closed
+    assert all(channel.closed for channel in _Channel.instances)
+
+
+def test_condition_transport_payload_drops_source_media() -> None:
+    material = MiniMaxH3MaterialPlanItem(0, "reference", "image", "a", "image.reference_preserve")
+    visual_rows = torch.zeros(2, 96)
+    condition = MiniMaxH3PreparedCondition(
+        material,
+        "image",
+        image=object(),
+        visual_rows=visual_rows,
+        latent_t=1,
+        latent_h=2,
+        latent_w=3,
+    )
+
+    payload = MiniMaxH3Pipeline._condition_transport_payload(condition)
+
+    assert "image" not in payload
+    assert "video_frames" not in payload
+    assert payload["visual_rows"] is visual_rows
+    assert MiniMaxH3PreparedCondition(**payload).latent_w == 3
+
+
+def test_pipeline_resolves_deferred_worker_result() -> None:
+    marker = object()
+    assert MiniMaxH3Pipeline._resolve_stage_result(lambda: marker) is marker
+    assert MiniMaxH3Pipeline._resolve_stage_result(marker) is marker
+
+
+def test_example_loader_allows_release_length_parallel_denoising(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    from telefuser.pipelines.minimax_h3 import example_utils as common
+
+    component_root = tmp_path / "Ref2VA"
+    for name in ("transformer", "text_encoder"):
+        directory = component_root / name
+        directory.mkdir(parents=True)
+        (directory / "model-00001-of-00001.safetensors").touch()
+
+    captured = {}
+
+    class _Manager:
+        def __init__(self, *args, **kwargs) -> None:
+            pass
+
+        def load_model(self, *args, **kwargs) -> None:
+            pass
+
+    class _Pipeline:
+        def __init__(self, *args, **kwargs) -> None:
+            pass
+
+        def init(self, manager, config) -> None:
+            captured["config"] = config
+
+    monkeypatch.setattr(common, "ModuleManager", _Manager)
+    monkeypatch.setattr(common, "MiniMaxH3Pipeline", _Pipeline)
+
+    common.load_minimax_h3_pipeline(
+        tmp_path,
+        partition="Ref2VA",
+        device="cpu",
+        ulysses_degree=2,
+        tp_degree=2,
+        text_encoder_tp_degree=4,
+        attn_impl="TORCH_SDPA",
+    )
+
+    config = captured["config"]
+    assert config.dit_config.parallel_config.timeout == 1800
+    assert config.dit_config.parallel_config.sp_ulysses_degree == 2
+    assert config.dit_config.parallel_config.tp_degree == 2
+    assert config.dit_config.parallel_config.enable_fsdp is False
+    assert config.dit_config.attention_config.attn_impl is AttnImplType.TORCH_SDPA
+    assert config.dit_config.offload_config.offload_type is WeightOffloadType.NO_CPU_OFFLOAD
+    assert config.text_encoder_config.parallel_config.sp_ulysses_degree == 1
+    assert config.text_encoder_config.parallel_config.tp_degree == 4
+    assert config.text_encoder_config.parallel_config.enable_fsdp is False
+    assert config.text_encoder_config.offload_config.offload_type is WeightOffloadType.NO_CPU_OFFLOAD
+    assert config.video_vae_config.offload_config.offload_type is WeightOffloadType.NO_CPU_OFFLOAD
+    assert config.video_vae_config.parallel_config.tp_degree == 4
+    assert config.audio_vae_config.offload_config.offload_type is WeightOffloadType.NO_CPU_OFFLOAD
+
+
+def test_example_writer_preserves_complete_generated_audio(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    from types import SimpleNamespace
+
+    from telefuser.pipelines.minimax_h3 import example_utils as common
+
+    commands = []
+    monkeypatch.setattr(common, "save_wav", lambda *args, **kwargs: None)
+    monkeypatch.setattr(common, "save_video", lambda *args, **kwargs: None)
+    monkeypatch.setattr(common.subprocess, "run", lambda command, **kwargs: commands.append(command))
+    generation = SimpleNamespace(
+        video=torch.zeros(1, 2, 2, 2, 3),
+        audio=torch.zeros(1, 2, 16),
+        video_fps=24,
+        audio_sample_rate=32_000,
+    )
+    output = tmp_path / "result.mp4"
+
+    common.save_generation(generation, output)
+
+    assert len(commands) == 1
+    command = commands[0]
+    assert "-shortest" not in command
+    assert command[-1] == str(output)
+    assert command[command.index("-map") + 1] == "0:v:0"
diff --git a/tests/unit/pipelines/minimax_h3/test_scheduler.py b/tests/unit/pipelines/minimax_h3/test_scheduler.py
new file mode 100644
index 00000000..a8d596f6
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_scheduler.py
@@ -0,0 +1,88 @@
+"""Scheduler vectors derived from SGLang test_minimax_h3_denoise_loop.py."""
+
+import pytest
+import torch
+
+from telefuser.pipelines.minimax_h3.denoising import _minimax_h3_update_target_rows_
+from telefuser.pipelines.minimax_h3.scheduler import (
+    MiniMaxH3EulerAncestralEta0SchedulerAdapter,
+    minimax_h3_euler_eta0_step,
+    minimax_h3_rf_v_to_x0,
+)
+
+
+def test_inplace_target_update_matches_public_scheduler_math() -> None:
+    torch.manual_seed(0)
+    state = torch.randn(7, 5)
+    velocity = torch.randn_like(state)
+    sigma_curr = 0.75
+    sigma_next = 0.25
+    ratio = torch.tensor(sigma_next / sigma_curr)
+    denoised = state + sigma_curr * velocity
+    expected = ratio * state + (1.0 - ratio) * denoised
+
+    actual = state.clone()
+    reusable_velocity = velocity.clone()
+    _minimax_h3_update_target_rows_(
+        actual,
+        reusable_velocity,
+        sigma_t=torch.tensor(sigma_curr),
+        sigma_curr=sigma_curr,
+        sigma_ratio=ratio,
+        one_minus_sigma_ratio=1.0 - ratio,
+        denoised_scratch=torch.empty_like(actual),
+    )
+
+    torch.testing.assert_close(actual, expected)
+
+
+def test_rf_velocity_conversion_and_eta0_step() -> None:
+    state = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
+    velocity = torch.tensor([[0.5, -0.5], [1.0, -1.0]])
+    timestep = torch.tensor(0.25)
+    denoised = minimax_h3_rf_v_to_x0(state, velocity, timestep)
+    torch.testing.assert_close(denoised, state + 0.75 * velocity)
+    actual = minimax_h3_euler_eta0_step(state, denoised, sigma_curr=0.75, sigma_next=0.25)
+    expected = (0.25 / 0.75) * state + (1.0 - 0.25 / 0.75) * denoised
+    torch.testing.assert_close(actual, expected)
+
+
+def test_dual_modality_timesteps_use_independent_sigma_schedules() -> None:
+    adapter = MiniMaxH3EulerAncestralEta0SchedulerAdapter()
+    visual = torch.ones(2, 3)
+    audio = torch.ones(4, 2) * 2
+    result = adapter.step_denoising(
+        input_visual_latent=visual,
+        input_audio_latent=audio,
+        timestep=torch.tensor(0.5),
+        video_timestep=torch.tensor(0.25),
+        audio_timestep=torch.tensor(0.75),
+        noise_pred_visual=torch.ones_like(visual),
+        noise_pred_audio=-torch.ones_like(audio),
+        sigma_curr=0.5,
+        sigma_next=0.0,
+        video_sigma_curr=0.75,
+        video_sigma_next=0.5,
+        audio_sigma_curr=0.25,
+        audio_sigma_next=0.125,
+    )
+    expected_visual_x0 = visual + 0.75 * torch.ones_like(visual)
+    expected_audio_x0 = audio - 0.25 * torch.ones_like(audio)
+    torch.testing.assert_close(
+        result["output_visual_latent"], (0.5 / 0.75) * visual + (1 - 0.5 / 0.75) * expected_visual_x0
+    )
+    torch.testing.assert_close(result["output_audio_latent"], 0.5 * audio + 0.5 * expected_audio_x0)
+
+
+def test_scheduler_rejects_timestep_sigma_mismatch() -> None:
+    adapter = MiniMaxH3EulerAncestralEta0SchedulerAdapter()
+    with pytest.raises(ValueError, match="video_sigma_curr"):
+        adapter.step_denoising(
+            input_visual_latent=torch.zeros(1),
+            input_audio_latent=torch.zeros(1),
+            timestep=torch.tensor(0.5),
+            noise_pred_visual=torch.zeros(1),
+            noise_pred_audio=torch.zeros(1),
+            sigma_curr=0.4,
+            sigma_next=0.0,
+        )
diff --git a/tests/unit/pipelines/minimax_h3/test_trajectory_comparison.py b/tests/unit/pipelines/minimax_h3/test_trajectory_comparison.py
new file mode 100644
index 00000000..54188fe1
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_trajectory_comparison.py
@@ -0,0 +1,55 @@
+import math
+
+import torch
+
+from tools.validation.compare_minimax_h3_trajectories import _at, _mappings, _tensor_metrics
+
+
+def test_tensor_metrics_reports_exact_tensor() -> None:
+    tensor = torch.tensor([[1.0, 2.0]], dtype=torch.float32)
+    metrics = _tensor_metrics(tensor, tensor.clone())
+    assert metrics["comparable"] is True
+    assert metrics["exact_fraction"] == 1.0
+    assert metrics["rmse"] == 0.0
+    assert metrics["cosine_similarity"] == 1.0
+    assert math.isinf(metrics["psnr_db_reference_range"])
+
+
+def test_tensor_metrics_reports_numeric_drift() -> None:
+    reference = torch.tensor([0.0, 2.0], dtype=torch.float32)
+    candidate = torch.tensor([1.0, 2.0], dtype=torch.float32)
+    metrics = _tensor_metrics(reference, candidate)
+    assert metrics["comparable"] is True
+    assert metrics["exact_fraction"] == 0.5
+    assert metrics["max_abs_error"] == 1.0
+    assert metrics["mean_abs_error"] == 0.5
+    assert metrics["rmse"] == math.sqrt(0.5)
+
+
+def test_tensor_metrics_rejects_shape_mismatch() -> None:
+    metrics = _tensor_metrics(torch.zeros(2), torch.zeros(3))
+    assert metrics == {
+        "reference_shape": [2],
+        "candidate_shape": [3],
+        "reference_dtype": "torch.float32",
+        "candidate_dtype": "torch.float32",
+        "comparable": False,
+        "reason": "shape_mismatch",
+    }
+
+
+def test_at_concatenates_ref2va_condition_segments() -> None:
+    artifact = {"video_audio": torch.tensor([[1.0]]), "audio": torch.tensor([[2.0]])}
+    assert torch.equal(_at(artifact, ("video_audio", "audio")), torch.tensor([[1.0], [2.0]]))
+
+
+def test_ref2va_mappings_use_global_tags_and_full_audio_prediction() -> None:
+    mappings = {item["name"]: item for item in _mappings("ref2va")}
+    assert mappings["packed.token_tags"]["candidate_path"] == "transformer_layout.block_token_tags"
+    assert mappings["processor.pixel_values_videos"]["expected_relation"] == "exact"
+    assert mappings["processor.video_grid_thw"]["expected_relation"] == "exact"
+    assert mappings["condition_vae.audio_pre_noise"]["candidate_path"] == (
+        "conditions_pre_noise.0.audio_rows",
+        "conditions_pre_noise.1.audio_rows",
+    )
+    assert mappings["step.0.dit_prediction.audio"]["candidate_path"] == "steps.0.dit_output.1"
diff --git a/tests/unit/pipelines/minimax_h3/test_vae.py b/tests/unit/pipelines/minimax_h3/test_vae.py
new file mode 100644
index 00000000..8fba0458
--- /dev/null
+++ b/tests/unit/pipelines/minimax_h3/test_vae.py
@@ -0,0 +1,89 @@
+import numpy as np
+import torch
+
+from telefuser.core.config import ModelRuntimeConfig
+from telefuser.core.module_manager import ModuleManager
+from telefuser.pipelines.minimax_h3.resolved_plan import MiniMaxH3MaterialPlanItem
+from telefuser.pipelines.minimax_h3.vae import (
+    MiniMaxH3AudioVAEStage,
+    MiniMaxH3PreparedCondition,
+    MiniMaxH3VideoVAEStage,
+)
+
+
+class _VideoVAEProbe(torch.nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.anchor = torch.nn.Parameter(torch.zeros(()))
+        self.config = type("Config", (), {"latents_mean": (0.0,) * 24, "latents_std": (1.0,) * 24})()
+        self.observed: np.ndarray | None = None
+        self.prepared_dtype: torch.dtype | None = None
+
+    def encode_videos(self, frames: np.ndarray, **_: object) -> list[torch.Tensor]:
+        self.observed = frames
+        return [torch.zeros(24, 2, 2, 2)]
+
+    def prepare_decoder_autocast_weights(self, dtype: torch.dtype) -> None:
+        self.prepared_dtype = dtype
+
+    def decode_normalized(self, latent: torch.Tensor) -> torch.Tensor:
+        return latent[:, :3]
+
+
+def test_reference_video_uses_uint8_numpy_preprocessing_path() -> None:
+    video_vae = _VideoVAEProbe()
+    audio_vae = torch.nn.Linear(1, 1)
+    manager = ModuleManager(device="cpu")
+    manager.add_module(video_vae, "minimax_h3_video_vae")
+    manager.add_module(audio_vae, "minimax_h3_audio_vae")
+    runtime = ModelRuntimeConfig(device_type="cpu", torch_dtype=torch.float32)
+    stage = MiniMaxH3VideoVAEStage(manager, runtime)
+    material = MiniMaxH3MaterialPlanItem(
+        0,
+        "reference",
+        "video",
+        "reference.mov",
+        "video.reference_preserve",
+    )
+    condition = MiniMaxH3PreparedCondition(
+        material,
+        "video",
+        video_frames=torch.zeros(5, 32, 32, 3, dtype=torch.uint8),
+    )
+
+    encoded = stage.encode_visual([condition])
+
+    assert video_vae.observed is not None
+    assert video_vae.observed.dtype == np.uint8
+    assert video_vae.observed.shape == (5, 32, 32, 3)
+    assert encoded[0].visual_rows is not None
+
+
+def test_vae_stages_accept_independent_component_placement() -> None:
+    manager = ModuleManager(device="cpu")
+    manager.add_module(_VideoVAEProbe(), "minimax_h3_video_vae")
+    manager.add_module(torch.nn.Linear(1, 1), "minimax_h3_audio_vae")
+    video_config = ModelRuntimeConfig(device_type="cpu", device_id=0)
+    audio_config = ModelRuntimeConfig(device_type="cpu", device_id=1)
+
+    video_stage = MiniMaxH3VideoVAEStage(manager, video_config)
+    audio_stage = MiniMaxH3AudioVAEStage(manager, audio_config)
+
+    assert video_stage.model_runtime_config is video_config
+    assert audio_stage.model_runtime_config is audio_config
+
+
+def test_video_decode_keeps_cpu_path_in_fp32() -> None:
+    video_vae = _VideoVAEProbe()
+    manager = ModuleManager(device="cpu")
+    manager.add_module(video_vae, "minimax_h3_video_vae")
+    manager.add_module(torch.nn.Linear(1, 1), "minimax_h3_audio_vae")
+    runtime = ModelRuntimeConfig(device_type="cpu", torch_dtype=torch.float32)
+    stage = MiniMaxH3VideoVAEStage(manager, runtime)
+
+    frames = stage.decode_video(torch.zeros(1, 24, 1, 2, 2))
+
+    assert frames.shape == (1, 1, 2, 2, 3)
+    assert frames.device.type == "cpu"
+    assert frames.dtype == torch.float32
+    assert video_vae.prepared_dtype is None
diff --git a/tests/unit/service/test_example_service_parity.py b/tests/unit/service/test_example_service_parity.py
index 040f75ff..257f0fa6 100644
--- a/tests/unit/service/test_example_service_parity.py
+++ b/tests/unit/service/test_example_service_parity.py
@@ -28,6 +28,8 @@
 
 SERVICE_EXAMPLES = {
     "wan21_i2v_service": (Path("examples/wan_video/wan21_14b_image_to_video_480p_service.py"), "i2v", True),
+    "minimax_h3_fl2va": (Path("examples/minimax_h3/minimax_h3_fl2va_h100.py"), "t2v", True),
+    "minimax_h3_ref2va": (Path("examples/minimax_h3/minimax_h3_ref2va_h100.py"), "s2v", True),
     "wan22_i2v_distill": (Path("examples/wan_video/wan22_14b_image_to_video_distill_h100.py"), "i2v", True),
     "lingbot_video_dense": (Path("examples/lingbot_video/lingbot_video_dense_1_3b.py"), "t2i", True),
     "lingbot_video_moe": (Path("examples/lingbot_video/lingbot_video_moe_30b.py"), "t2i", True),
@@ -86,7 +88,7 @@ def _parameter_value(parameter_type: str) -> object:
         "boolean": True,
         "integer": 7,
         "number": 1.5,
-        "array": [],
+        "array": [{"type": "image", "role": "reference", "uri": "input.png"}],
         "object": {},
     }
     return values.get(parameter_type, "test-value")
@@ -188,6 +190,9 @@ def test_task_request_reaches_example_entrypoint_with_contract_defaults(example_
             request_data[input_name] = str(input_path)
         else:
             request_data[input_name] = f"{input_name}.bin"
+    for name, parameter in task_contract.parameters.items():
+        if parameter.required and parameter.default is None:
+            request_data.setdefault(name, _parameter_value(parameter.type))
     request = TaskRequest(**request_data)
     explicit_fields = set(request.model_fields_set)
     asyncio.run(
@@ -280,6 +285,9 @@ def get_task_contract(self, requested_task: str) -> TaskContract | None:
     for input_name in task_contract.required_inputs:
         request_data[input_name] = f"{input_name}.bin"
 
+    for name, parameter in task_contract.parameters.items():
+        if parameter.required and parameter.default is None:
+            request_data.setdefault(name, _parameter_value(parameter.type))
     try:
         with TestClient(server.app) as client:
             response = client.post("/v1/tasks/create", json=request_data)
diff --git a/tests/unit/test_example_registry.py b/tests/unit/test_example_registry.py
index a3058782..a56fb120 100644
--- a/tests/unit/test_example_registry.py
+++ b/tests/unit/test_example_registry.py
@@ -14,6 +14,8 @@
     "wan_video/wan22_14b_image_to_video_distill_h100.py",
     "lingbot_video/lingbot_video_dense_1_3b.py",
     "lingbot_video/lingbot_video_moe_30b.py",
+    "minimax_h3/minimax_h3_fl2va_h100.py",
+    "minimax_h3/minimax_h3_ref2va_h100.py",
 }
 
 
@@ -50,6 +52,21 @@ def test_example_regression_registry_has_runnable_entrypoints() -> None:
         symbols = _module_symbols(script_path)
         assert "get_pipeline" in symbols, f"{name} is missing get_pipeline()"
         assert "run" in symbols, f"{name} is missing run()"
+        if pipeline.use_run_with_file:
+            assert "run_with_file" in symbols, f"{name} is missing configured run_with_file()"
+
+
+def test_minimax_h3_four_gpu_regression_contract() -> None:
+    pipeline = load_config().pipelines["minimax_h3_t2va_4gpu"]
+
+    assert pipeline.script == "minimax_h3/minimax_h3_fl2va_h100.py"
+    assert pipeline.gpu_count == 4
+    assert pipeline.seed == 0
+    assert pipeline.resolution == "768p"
+    assert pipeline.target_video_length == 5
+    assert pipeline.use_run_with_file is True
+    assert pipeline.require_audio is True
+    assert pipeline.ppl_config_overrides["num_inference_steps"] == 50
 
 
 def test_all_declared_service_examples_have_cpu_parity_coverage() -> None:
diff --git a/tests/unit/test_run_examples.py b/tests/unit/test_run_examples.py
index 39713c78..17f5a2e1 100644
--- a/tests/unit/test_run_examples.py
+++ b/tests/unit/test_run_examples.py
@@ -115,6 +115,31 @@ def capture_save_video(frames: list[np.ndarray], path: str, fps: float, quality:
     assert saved_frames[0].dtype == np.uint8
 
 
+def test_save_output_accepts_file_entrypoint_artifact(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    artifact = tmp_path / "joint-audio-video.mp4"
+    artifact.write_bytes(b"artifact")
+
+    class FakeVideoData:
+        width = 1360
+        height = 768
+
+        def __init__(self, video_file: str) -> None:
+            assert video_file == str(artifact)
+
+        def __len__(self) -> int:
+            return 121
+
+    from telefuser.utils import video as video_utils
+
+    monkeypatch.setattr(video_utils, "VideoData", FakeVideoData)
+
+    path, frames, resolution = run_examples._save_output({"output_path": str(artifact)}, str(tmp_path), "video")
+
+    assert path == str(artifact)
+    assert frames == 121
+    assert resolution == "1360x768"
+
+
 def test_call_get_pipeline_forwards_matching_config_overrides() -> None:
     module = ModuleType("pipeline_config_example")
 
@@ -154,6 +179,24 @@ def run(
     assert run_examples._call_run(module, object(), {"target_video_length": 2}) == (None, 2)
 
 
+def test_call_run_supports_standard_file_entrypoint() -> None:
+    module = ModuleType("file_example")
+
+    def run_with_file(pipeline: object, output_path: str, target_video_length: float) -> dict[str, str]:
+        del pipeline
+        assert target_video_length == 5
+        return {"output_path": output_path}
+
+    module.run_with_file = run_with_file
+
+    assert run_examples._call_run(
+        module,
+        object(),
+        {"output_path": "/tmp/result.mp4", "target_video_length": 5},
+        entrypoint="run_with_file",
+    ) == {"output_path": "/tmp/result.mp4"}
+
+
 def test_video_metrics_rejects_mismatched_frame_counts(monkeypatch: pytest.MonkeyPatch) -> None:
     from telefuser.utils import video as video_utils
 
@@ -204,7 +247,7 @@ def test_video_comparison_rejects_missing_metrics(
     baseline.write_bytes(b"baseline")
     current.write_bytes(b"current")
     monkeypatch.setattr(run_examples, "_get_baseline_path", lambda *_args: str(baseline))
-    monkeypatch.setattr(run_examples, "compute_video_metrics", lambda *_args: metrics)
+    monkeypatch.setattr(run_examples, "compute_video_metrics", lambda *_args, **_kwargs: metrics)
 
     result = run_examples.compare_against_baseline(
         str(tmp_path), "wan/example.py", 1, str(current), "video", 25.0, 0.85, 0.02
@@ -214,6 +257,71 @@ def test_video_comparison_rejects_missing_metrics(
     assert result["message"] == "Video comparison produced no PSNR/SSIM metrics"
 
 
+def test_required_audio_metrics_compare_stream_contract_and_waveform(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    stream_info = {"sample_rate": 32_000, "channels": 2, "duration": 5.0}
+    waveforms = {
+        "baseline.mp4": np.array([0.5, -0.25, 0.1, -0.2], dtype=np.float32),
+        "current.mp4": np.array([0.49, -0.24, 0.11, -0.19], dtype=np.float32),
+    }
+    monkeypatch.setattr(run_examples, "_probe_audio_stream", lambda _path: stream_info)
+    monkeypatch.setattr(
+        run_examples,
+        "_decode_audio",
+        lambda path, **_kwargs: waveforms[path],
+    )
+
+    metrics = run_examples._compute_audio_metrics("baseline.mp4", "current.mp4", required=True)
+
+    assert metrics["audio_cosine"] > 0.99
+    assert metrics["audio_duration_delta"] == 0.0
+
+
+def test_required_audio_metrics_reject_missing_current_track(monkeypatch: pytest.MonkeyPatch) -> None:
+    baseline_info = {"sample_rate": 32_000, "channels": 2, "duration": 5.0}
+    monkeypatch.setattr(
+        run_examples,
+        "_probe_audio_stream",
+        lambda path: baseline_info if path == "baseline.mp4" else None,
+    )
+
+    with pytest.raises(ValueError, match="Current video has no audio stream"):
+        run_examples._compute_audio_metrics("baseline.mp4", "current.mp4", required=True)
+
+
+def test_video_comparison_enforces_required_audio_cosine(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    baseline = tmp_path / "baseline.mp4"
+    current = tmp_path / "current.mp4"
+    baseline.write_bytes(b"baseline")
+    current.write_bytes(b"current")
+    monkeypatch.setattr(run_examples, "_get_baseline_path", lambda *_args: str(baseline))
+    monkeypatch.setattr(
+        run_examples,
+        "compute_video_metrics",
+        lambda *_args, **_kwargs: {"psnr": 30.0, "ssim": 0.95, "audio_cosine": 0.5},
+    )
+
+    result = run_examples.compare_against_baseline(
+        str(tmp_path),
+        "minimax_h3/example.py",
+        4,
+        str(current),
+        "video",
+        25.0,
+        0.85,
+        0.02,
+        require_audio=True,
+        audio_cosine_min=0.95,
+    )
+
+    assert not result["passed"]
+    assert "audio cosine 0.5000 < 0.9500" in result["message"]
+
+
 def test_video_comparison_rejects_unavailable_dependencies(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     baseline = tmp_path / "baseline.mp4"
     current = tmp_path / "current.mp4"
@@ -221,7 +329,7 @@ def test_video_comparison_rejects_unavailable_dependencies(monkeypatch: pytest.M
     current.write_bytes(b"current")
     monkeypatch.setattr(run_examples, "_get_baseline_path", lambda *_args: str(baseline))
 
-    def raise_missing_dependency(*_args: object) -> dict[str, float]:
+    def raise_missing_dependency(*_args: object, **_kwargs: object) -> dict[str, float]:
         raise ModuleNotFoundError("skimage")
 
     monkeypatch.setattr(run_examples, "compute_video_metrics", raise_missing_dependency)
diff --git a/tools/validation/capture_minimax_h3_text_refiner.py b/tools/validation/capture_minimax_h3_text_refiner.py
new file mode 100644
index 00000000..ec30b9f9
--- /dev/null
+++ b/tools/validation/capture_minimax_h3_text_refiner.py
@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Capture MiniMax H3 text-refiner boundaries without loading the full DiT."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+from safetensors import safe_open
+
+from telefuser.models.minimax_h3_dit import (
+    MiniMaxH3DiTConfig,
+    MiniMaxH3TokenRefiner,
+    _reorder_grouped_qkv_to_qkv,
+)
+
+
+class _TextRefiner(nn.Module):
+    def __init__(self, config: MiniMaxH3DiTConfig) -> None:
+        super().__init__()
+        self.condition_proj = nn.Linear(config.text_dim, config.hidden_size, dtype=torch.bfloat16)
+        self.token_refiner = MiniMaxH3TokenRefiner(config)
+
+
+def _load_refiner(checkpoint_dir: Path, device: torch.device) -> _TextRefiner:
+    config = MiniMaxH3DiTConfig.from_json(checkpoint_dir / "config.json")
+    model = _TextRefiner(config)
+    index = json.loads((checkpoint_dir / "model.safetensors.index.json").read_text(encoding="utf-8"))
+    weight_map = index["weight_map"]
+    selected = [name for name in weight_map if name.startswith("condition_proj.") or name.startswith("token_refiner.")]
+    shard_names = {weight_map[name] for name in selected}
+    if len(shard_names) != 1:
+        raise ValueError(f"text-refiner weights must occupy one shard, got {sorted(shard_names)}")
+    shard_path = checkpoint_dir / next(iter(shard_names))
+    state: dict[str, torch.Tensor] = {}
+    with safe_open(shard_path, framework="pt", device="cpu") as stream:
+        for name in selected:
+            value = stream.get_tensor(name)
+            if name.endswith(".attn.qkv_proj.weight"):
+                value = _reorder_grouped_qkv_to_qkv(
+                    value,
+                    num_query_groups=config.num_attention_heads,
+                    heads_per_group=1,
+                    head_dim=config.attention_head_dim,
+                )
+            state[name] = value
+    model.load_state_dict(state, strict=True)
+    return model.to(device).eval()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--checkpoint-dir", type=Path, required=True)
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--device", default="cuda:0")
+    args = parser.parse_args()
+
+    device = torch.device(args.device)
+    source = torch.load(args.input, map_location="cpu", weights_only=True)
+    hidden = source["hidden_states"].to(device=device, dtype=torch.bfloat16)
+    model = _load_refiner(args.checkpoint_dir, device)
+    captured: dict[str, torch.Tensor] = {"input": hidden.detach().cpu()}
+    with torch.inference_mode():
+        hidden = model.condition_proj(hidden)
+        captured["condition_proj"] = hidden.detach().cpu()
+        for index, block in enumerate(model.token_refiner.blocks):
+            hidden = block(
+                hidden,
+                sequence_lengths=[int(hidden.shape[0])],
+                attention_config=None,
+            )
+            captured[f"block_{index}"] = hidden.detach().cpu()
+        hidden = model.token_refiner.final_norm(hidden)
+        captured["final"] = hidden.detach().cpu()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(captured, args.output)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/validation/compare_minimax_h3_artifacts.py b/tools/validation/compare_minimax_h3_artifacts.py
new file mode 100644
index 00000000..e5115b18
--- /dev/null
+++ b/tools/validation/compare_minimax_h3_artifacts.py
@@ -0,0 +1,357 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Compare raw MiniMax H3 SGLang and TeleFuser output arrays."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+
+import numpy as np
+
+if __package__:
+    from tools.validation.minimax_h3_validation_common import sha256 as _sha256
+else:
+    from minimax_h3_validation_common import sha256 as _sha256
+
+MIN_VIDEO_COSINE = 0.99
+MIN_VIDEO_PSNR_DB = 28.0
+MIN_AUDIO_COSINE = 0.94
+MIN_AUDIO_PSNR_DB = 30.0
+DEFAULT_AUDIO_SAMPLE_RATE = 32_000
+
+
+def _compare(reference_path: Path, candidate_path: Path, *, data_range: float) -> dict[str, object]:
+    reference = np.load(reference_path, mmap_mode="r", allow_pickle=False)
+    candidate = np.load(candidate_path, mmap_mode="r", allow_pickle=False)
+    if reference.shape != candidate.shape:
+        raise ValueError(f"shape mismatch: {reference.shape} != {candidate.shape}")
+    reference_flat = reference.reshape(-1)
+    candidate_flat = candidate.reshape(-1)
+    count = reference_flat.size
+    chunk_size = 4 * 1024 * 1024
+    max_abs = 0.0
+    sum_abs = 0.0
+    sum_square = 0.0
+    sum_relative = 0.0
+    dot = 0.0
+    reference_square = 0.0
+    candidate_square = 0.0
+    exact = 0
+    relative_floor = 1.0 if np.issubdtype(reference.dtype, np.integer) else 1e-6
+    for start in range(0, count, chunk_size):
+        stop = min(start + chunk_size, count)
+        reference_chunk = reference_flat[start:stop].astype(np.float64)
+        candidate_chunk = candidate_flat[start:stop].astype(np.float64)
+        difference = candidate_chunk - reference_chunk
+        absolute = np.abs(difference)
+        max_abs = max(max_abs, float(absolute.max(initial=0.0)))
+        sum_abs += float(absolute.sum())
+        sum_square += float(np.square(difference).sum())
+        sum_relative += float((absolute / np.maximum(np.abs(reference_chunk), relative_floor)).sum())
+        dot += float(np.dot(reference_chunk, candidate_chunk))
+        reference_square += float(np.square(reference_chunk).sum())
+        candidate_square += float(np.square(candidate_chunk).sum())
+        exact += int(np.equal(reference_chunk, candidate_chunk).sum())
+    rmse = math.sqrt(sum_square / count)
+    if reference_square == 0.0 and candidate_square == 0.0:
+        cosine = 1.0
+    elif reference_square == 0.0 or candidate_square == 0.0:
+        cosine = 0.0
+    else:
+        cosine = dot / math.sqrt(reference_square * candidate_square)
+    psnr = math.inf if rmse == 0.0 else 20.0 * math.log10(data_range / rmse)
+    return {
+        "shape": list(reference.shape),
+        "reference_dtype": str(reference.dtype),
+        "candidate_dtype": str(candidate.dtype),
+        "reference_sha256": _sha256(reference_path),
+        "candidate_sha256": _sha256(candidate_path),
+        "max_abs_error": max_abs,
+        "mean_abs_error": sum_abs / count,
+        "mean_relative_error": sum_relative / count,
+        "rmse": rmse,
+        "cosine_similarity": cosine,
+        "exact_fraction": exact / count,
+        "psnr_db": psnr,
+    }
+
+
+def _array_metrics(reference: np.ndarray, candidate: np.ndarray, *, data_range: float) -> dict[str, float]:
+    reference_flat = np.asarray(reference, dtype=np.float64).reshape(-1)
+    candidate_flat = np.asarray(candidate, dtype=np.float64).reshape(-1)
+    if reference_flat.shape != candidate_flat.shape:
+        raise ValueError(f"shape mismatch: {reference_flat.shape} != {candidate_flat.shape}")
+    difference = candidate_flat - reference_flat
+    rmse = float(np.sqrt(np.mean(np.square(difference))))
+    reference_norm = float(np.linalg.norm(reference_flat))
+    candidate_norm = float(np.linalg.norm(candidate_flat))
+    if reference_norm == 0.0 and candidate_norm == 0.0:
+        cosine = 1.0
+    elif reference_norm == 0.0 or candidate_norm == 0.0:
+        cosine = 0.0
+    else:
+        cosine = float(np.dot(reference_flat, candidate_flat) / (reference_norm * candidate_norm))
+    return {
+        "mean_abs_error": float(np.mean(np.abs(difference))),
+        "rmse": rmse,
+        "cosine_similarity": cosine,
+        "exact_fraction": float(np.mean(reference_flat == candidate_flat)),
+        "psnr_db": math.inf if rmse == 0.0 else 20.0 * math.log10(data_range / rmse),
+    }
+
+
+def _compare_video(reference_path: Path, candidate_path: Path) -> dict[str, object]:
+    result = _compare(reference_path, candidate_path, data_range=255.0)
+    reference = np.load(reference_path, mmap_mode="r", allow_pickle=False)
+    candidate = np.load(candidate_path, mmap_mode="r", allow_pickle=False)
+    per_frame = []
+    for frame_index in range(reference.shape[0]):
+        metrics = _array_metrics(reference[frame_index], candidate[frame_index], data_range=255.0)
+        per_frame.append({"frame_index": frame_index, **metrics})
+    result["per_frame"] = per_frame
+    result["per_frame_summary"] = {
+        "min_cosine_similarity": min(item["cosine_similarity"] for item in per_frame),
+        "min_cosine_frame_index": min(per_frame, key=lambda item: item["cosine_similarity"])["frame_index"],
+        "min_psnr_db": min(item["psnr_db"] for item in per_frame),
+        "min_psnr_frame_index": min(per_frame, key=lambda item: item["psnr_db"])["frame_index"],
+        "max_rmse": max(item["rmse"] for item in per_frame),
+        "max_rmse_frame_index": max(per_frame, key=lambda item: item["rmse"])["frame_index"],
+    }
+    return result
+
+
+def _log_spectral_cosine(reference: np.ndarray, candidate: np.ndarray) -> float:
+    n_fft = 1024
+    hop_length = 256
+    if reference.size < n_fft:
+        pad = n_fft - reference.size
+        reference = np.pad(reference, (0, pad))
+        candidate = np.pad(candidate, (0, pad))
+    window = np.hanning(n_fft)
+    reference_frames = np.lib.stride_tricks.sliding_window_view(reference, n_fft)[::hop_length]
+    candidate_frames = np.lib.stride_tricks.sliding_window_view(candidate, n_fft)[::hop_length]
+    reference_spectrum = np.log1p(np.abs(np.fft.rfft(reference_frames * window, axis=-1))).reshape(-1)
+    candidate_spectrum = np.log1p(np.abs(np.fft.rfft(candidate_frames * window, axis=-1))).reshape(-1)
+    reference_norm = float(np.linalg.norm(reference_spectrum))
+    candidate_norm = float(np.linalg.norm(candidate_spectrum))
+    if reference_norm == 0.0 and candidate_norm == 0.0:
+        return 1.0
+    if reference_norm == 0.0 or candidate_norm == 0.0:
+        return 0.0
+    return float(np.dot(reference_spectrum, candidate_spectrum) / (reference_norm * candidate_norm))
+
+
+def _best_lag_samples(reference: np.ndarray, candidate: np.ndarray, *, sample_rate: int) -> int:
+    decimation = 8
+    reference_decimated = np.asarray(reference, dtype=np.float64)[::decimation].copy()
+    candidate_decimated = np.asarray(candidate, dtype=np.float64)[::decimation].copy()
+    reference_decimated -= reference_decimated.mean()
+    candidate_decimated -= candidate_decimated.mean()
+    correlation_size = reference_decimated.size + candidate_decimated.size - 1
+    fft_size = 1 << (correlation_size - 1).bit_length()
+    correlation = np.fft.irfft(
+        np.fft.rfft(candidate_decimated, fft_size) * np.fft.rfft(reference_decimated[::-1], fft_size),
+        fft_size,
+    )[:correlation_size]
+    lags = np.arange(-(reference_decimated.size - 1), candidate_decimated.size)
+    max_lag = sample_rate // decimation
+    allowed = np.abs(lags) <= max_lag
+    return int(lags[allowed][np.argmax(correlation[allowed])]) * decimation
+
+
+def _audio_temporal_metrics(
+    reference_path: Path,
+    candidate_path: Path,
+    *,
+    sample_rate: int,
+) -> dict[str, object]:
+    reference = np.load(reference_path, mmap_mode="r", allow_pickle=False)
+    candidate = np.load(candidate_path, mmap_mode="r", allow_pickle=False)
+    if reference.shape != candidate.shape:
+        raise ValueError(f"shape mismatch: {reference.shape} != {candidate.shape}")
+    if reference.ndim == 1:
+        reference = reference[None, :]
+        candidate = candidate[None, :]
+    reference_channels = reference.reshape(-1, reference.shape[-1])
+    candidate_channels = candidate.reshape(-1, candidate.shape[-1])
+    sample_count = reference_channels.shape[-1]
+    per_second = []
+    for window_index, start in enumerate(range(0, sample_count, sample_rate)):
+        stop = min(start + sample_rate, sample_count)
+        reference_window = reference_channels[:, start:stop]
+        candidate_window = candidate_channels[:, start:stop]
+        metrics = _array_metrics(reference_window, candidate_window, data_range=2.0)
+        reference_mono = np.asarray(reference_window, dtype=np.float64).mean(axis=0)
+        candidate_mono = np.asarray(candidate_window, dtype=np.float64).mean(axis=0)
+        per_second.append(
+            {
+                "window_index": window_index,
+                "start_sample": start,
+                "end_sample": stop,
+                "reference_rms": float(np.sqrt(np.mean(np.square(reference_window)))),
+                "candidate_rms": float(np.sqrt(np.mean(np.square(candidate_window)))),
+                "log_spectral_cosine": _log_spectral_cosine(reference_mono, candidate_mono),
+                **metrics,
+            }
+        )
+
+    envelope_samples = max(1, sample_rate // 50)
+    envelope_count = sample_count // envelope_samples
+    reference_envelope = np.sqrt(
+        np.mean(
+            np.square(np.asarray(reference_channels[:, : envelope_count * envelope_samples], dtype=np.float64)).reshape(
+                reference_channels.shape[0], envelope_count, envelope_samples
+            ),
+            axis=(0, 2),
+        )
+    )
+    candidate_envelope = np.sqrt(
+        np.mean(
+            np.square(np.asarray(candidate_channels[:, : envelope_count * envelope_samples], dtype=np.float64)).reshape(
+                candidate_channels.shape[0], envelope_count, envelope_samples
+            ),
+            axis=(0, 2),
+        )
+    )
+    if np.std(reference_envelope) == 0.0 or np.std(candidate_envelope) == 0.0:
+        envelope_correlation = 1.0 if np.array_equal(reference_envelope, candidate_envelope) else 0.0
+    else:
+        envelope_correlation = float(np.corrcoef(reference_envelope, candidate_envelope)[0, 1])
+    reference_mono = np.asarray(reference_channels, dtype=np.float64).mean(axis=0)
+    candidate_mono = np.asarray(candidate_channels, dtype=np.float64).mean(axis=0)
+    best_lag_samples = _best_lag_samples(reference_mono, candidate_mono, sample_rate=sample_rate)
+    return {
+        "sample_rate": sample_rate,
+        "window_samples": sample_rate,
+        "per_second": per_second,
+        "summary": {
+            "min_cosine_similarity": min(item["cosine_similarity"] for item in per_second),
+            "min_cosine_window_index": min(per_second, key=lambda item: item["cosine_similarity"])["window_index"],
+            "min_psnr_db": min(item["psnr_db"] for item in per_second),
+            "min_log_spectral_cosine": min(item["log_spectral_cosine"] for item in per_second),
+            "energy_envelope_correlation": envelope_correlation,
+            "best_lag_samples": best_lag_samples,
+            "best_lag_ms": 1000.0 * best_lag_samples / sample_rate,
+        },
+    }
+
+
+def _compare_audio(reference_path: Path, candidate_path: Path, *, sample_rate: int) -> dict[str, object]:
+    result = _compare(reference_path, candidate_path, data_range=2.0)
+    result["temporal"] = _audio_temporal_metrics(reference_path, candidate_path, sample_rate=sample_rate)
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--reference-frames", type=Path, required=True)
+    parser.add_argument("--candidate-frames", type=Path, required=True)
+    parser.add_argument("--reference-audio", type=Path, required=True)
+    parser.add_argument("--candidate-audio", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--reference-name", default="sglang")
+    parser.add_argument("--candidate-name", default="telefuser")
+    parser.add_argument("--min-video-cosine", type=float, default=MIN_VIDEO_COSINE)
+    parser.add_argument("--min-video-psnr-db", type=float, default=MIN_VIDEO_PSNR_DB)
+    parser.add_argument("--min-audio-cosine", type=float, default=MIN_AUDIO_COSINE)
+    parser.add_argument("--min-audio-psnr-db", type=float, default=MIN_AUDIO_PSNR_DB)
+    parser.add_argument("--min-frame-cosine", type=float)
+    parser.add_argument("--min-frame-psnr-db", type=float)
+    parser.add_argument("--min-audio-window-cosine", type=float)
+    parser.add_argument("--min-audio-window-psnr-db", type=float)
+    parser.add_argument("--min-audio-log-spectral-cosine", type=float)
+    parser.add_argument("--min-audio-envelope-correlation", type=float)
+    parser.add_argument("--max-audio-lag-ms", type=float)
+    parser.add_argument("--audio-sample-rate", type=int, default=DEFAULT_AUDIO_SAMPLE_RATE)
+    args = parser.parse_args()
+
+    frames = _compare_video(args.reference_frames, args.candidate_frames)
+    audio = _compare_audio(args.reference_audio, args.candidate_audio, sample_rate=args.audio_sample_rate)
+    checks = {
+        "video_cosine": float(frames["cosine_similarity"]) >= args.min_video_cosine,
+        "video_psnr": float(frames["psnr_db"]) >= args.min_video_psnr_db,
+        "audio_cosine": float(audio["cosine_similarity"]) >= args.min_audio_cosine,
+        "audio_psnr": float(audio["psnr_db"]) >= args.min_audio_psnr_db,
+    }
+    frame_summary = frames["per_frame_summary"]
+    audio_summary = audio["temporal"]["summary"]
+    optional_thresholds = {
+        "min_frame_cosine": args.min_frame_cosine,
+        "min_frame_psnr_db": args.min_frame_psnr_db,
+        "min_audio_window_cosine": args.min_audio_window_cosine,
+        "min_audio_window_psnr_db": args.min_audio_window_psnr_db,
+        "min_audio_log_spectral_cosine": args.min_audio_log_spectral_cosine,
+        "min_audio_envelope_correlation": args.min_audio_envelope_correlation,
+        "max_audio_lag_ms": args.max_audio_lag_ms,
+    }
+    optional_checks = {
+        "frame_cosine": (
+            "min_frame_cosine",
+            frame_summary["min_cosine_similarity"],
+            lambda actual, limit: actual >= limit,
+        ),
+        "frame_psnr": ("min_frame_psnr_db", frame_summary["min_psnr_db"], lambda actual, limit: actual >= limit),
+        "audio_window_cosine": (
+            "min_audio_window_cosine",
+            audio_summary["min_cosine_similarity"],
+            lambda actual, limit: actual >= limit,
+        ),
+        "audio_window_psnr": (
+            "min_audio_window_psnr_db",
+            audio_summary["min_psnr_db"],
+            lambda actual, limit: actual >= limit,
+        ),
+        "audio_log_spectral_cosine": (
+            "min_audio_log_spectral_cosine",
+            audio_summary["min_log_spectral_cosine"],
+            lambda actual, limit: actual >= limit,
+        ),
+        "audio_envelope_correlation": (
+            "min_audio_envelope_correlation",
+            audio_summary["energy_envelope_correlation"],
+            lambda actual, limit: actual >= limit,
+        ),
+        "audio_lag": (
+            "max_audio_lag_ms",
+            abs(audio_summary["best_lag_ms"]),
+            lambda actual, limit: actual <= limit,
+        ),
+    }
+    for check_name, (threshold_name, actual, comparison) in optional_checks.items():
+        threshold = optional_thresholds[threshold_name]
+        if threshold is not None:
+            checks[check_name] = comparison(float(actual), threshold)
+    report = {
+        "schema_version": 3,
+        "reference": args.reference_name,
+        "candidate": args.candidate_name,
+        "thresholds": {
+            "min_video_cosine": args.min_video_cosine,
+            "min_video_psnr_db": args.min_video_psnr_db,
+            "min_audio_cosine": args.min_audio_cosine,
+            "min_audio_psnr_db": args.min_audio_psnr_db,
+            **{name: value for name, value in optional_thresholds.items() if value is not None},
+        },
+        "checks": checks,
+        "passed": all(checks.values()),
+        "frames": frames,
+        "audio": audio,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2, allow_nan=True) + "\n", encoding="utf-8")
+    summary = {
+        "output": str(args.output),
+        "passed": report["passed"],
+        "checks": checks,
+        "per_frame_summary": frames["per_frame_summary"],
+        "audio_temporal_summary": audio["temporal"]["summary"],
+    }
+    print(json.dumps(summary, sort_keys=True, allow_nan=True))
+    if not report["passed"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/validation/compare_minimax_h3_trajectories.py b/tools/validation/compare_minimax_h3_trajectories.py
new file mode 100644
index 00000000..9aab2cbb
--- /dev/null
+++ b/tools/validation/compare_minimax_h3_trajectories.py
@@ -0,0 +1,413 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Compare mapped stable boundaries from official MiniMax H3 trajectories."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import torch
+
+if __package__:
+    from tools.validation.minimax_h3_validation_common import sha256 as _sha256
+else:
+    from minimax_h3_validation_common import sha256 as _sha256
+
+TensorPath = str | tuple[str, ...]
+
+
+def _at(value: Any, path: TensorPath) -> Any:
+    if isinstance(path, tuple):
+        return torch.cat([_at(value, part) for part in path], dim=0)
+    current = value
+    for part in path.split("."):
+        current = current[int(part)] if isinstance(current, (list, tuple)) else current[part]
+    return current
+
+
+def _tensor_metrics(reference: torch.Tensor, candidate: torch.Tensor) -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "reference_shape": list(reference.shape),
+        "candidate_shape": list(candidate.shape),
+        "reference_dtype": str(reference.dtype),
+        "candidate_dtype": str(candidate.dtype),
+    }
+    if reference.shape != candidate.shape:
+        return {**result, "comparable": False, "reason": "shape_mismatch"}
+
+    reference_flat = reference.detach().cpu().reshape(-1)
+    candidate_flat = candidate.detach().cpu().reshape(-1)
+    count = reference_flat.numel()
+    exact = 0
+    max_abs = 0.0
+    sum_abs = 0.0
+    sum_square = 0.0
+    sum_relative = 0.0
+    dot = 0.0
+    reference_square = 0.0
+    candidate_square = 0.0
+    reference_min = math.inf
+    reference_max = -math.inf
+    relative_floor = 1e-6
+    chunk_size = 1024 * 1024
+    for start in range(0, count, chunk_size):
+        stop = min(start + chunk_size, count)
+        reference_native = reference_flat[start:stop]
+        candidate_native = candidate_flat[start:stop]
+        exact += int(torch.eq(reference_native, candidate_native).sum())
+        reference_chunk = reference_native.to(torch.float64)
+        candidate_chunk = candidate_native.to(torch.float64)
+        difference = candidate_chunk - reference_chunk
+        absolute = difference.abs()
+        max_abs = max(max_abs, float(absolute.max())) if absolute.numel() else max_abs
+        sum_abs += float(absolute.sum())
+        sum_square += float(difference.square().sum())
+        sum_relative += float((absolute / reference_chunk.abs().clamp_min(relative_floor)).sum())
+        dot += float(torch.dot(reference_chunk, candidate_chunk))
+        reference_square += float(reference_chunk.square().sum())
+        candidate_square += float(candidate_chunk.square().sum())
+        if reference_chunk.numel():
+            reference_min = min(reference_min, float(reference_chunk.min()))
+            reference_max = max(reference_max, float(reference_chunk.max()))
+
+    rmse = math.sqrt(sum_square / count) if count else 0.0
+    denominator = math.sqrt(reference_square * candidate_square)
+    cosine = dot / denominator if denominator else 1.0
+    data_range = reference_max - reference_min
+    psnr = math.inf if rmse == 0 else 20.0 * math.log10((data_range or 1.0) / rmse)
+    return {
+        **result,
+        "comparable": True,
+        "count": count,
+        "exact_fraction": exact / count if count else 1.0,
+        "max_abs_error": max_abs,
+        "mean_abs_error": sum_abs / count if count else 0.0,
+        "mean_relative_error": sum_relative / count if count else 0.0,
+        "rmse": rmse,
+        "cosine_similarity": cosine,
+        "psnr_db_reference_range": psnr,
+        "reference_l2": math.sqrt(reference_square),
+        "candidate_l2": math.sqrt(candidate_square),
+    }
+
+
+def _mapping(
+    name: str,
+    source: str,
+    reference_path: TensorPath,
+    candidate_path: TensorPath,
+    *,
+    expected_relation: str,
+) -> dict[str, Any]:
+    return {
+        "name": name,
+        "source": source,
+        "reference_path": reference_path,
+        "candidate_path": candidate_path,
+        "expected_relation": expected_relation,
+    }
+
+
+def _mappings(case: str) -> list[dict[str, Any]]:
+    mappings = [
+        _mapping("processor.input_ids", "text", "input_ids", "input_ids", expected_relation="exact"),
+        _mapping(
+            "encoder.hidden_states",
+            "text",
+            "positive.hidden_states",
+            "hidden_states",
+            expected_relation="numeric",
+        ),
+        _mapping(
+            "encoder.token_tags",
+            "text",
+            "positive.text_token_tags",
+            "token_tags",
+            expected_relation="exact",
+        ),
+    ]
+    if case == "fl2va":
+        mappings += [
+            _mapping(
+                "processor.pixel_values",
+                "text",
+                "processor.pixel_values",
+                "processor.pixel_values",
+                expected_relation="exact",
+            ),
+            _mapping(
+                "processor.image_grid_thw",
+                "text",
+                "processor.image_grid_thw",
+                "processor.image_grid_thw",
+                expected_relation="exact",
+            ),
+            _mapping(
+                "condition_vae.visual_pre_noise",
+                "trajectory",
+                "conditions_pre_noise.visual",
+                "conditions_pre_noise.0.visual_rows",
+                expected_relation="numeric",
+            ),
+            _mapping(
+                "condition_vae.visual_post_noise",
+                "trajectory",
+                "conditions_post_noise.visual",
+                "condition_rows_post_noise.visual",
+                expected_relation="numeric",
+            ),
+        ]
+    elif case == "ref2va":
+        mappings += [
+            _mapping(
+                "processor.pixel_values_videos",
+                "text",
+                "processor.pixel_values_videos",
+                "processor.pixel_values_videos",
+                expected_relation="exact",
+            ),
+            _mapping(
+                "processor.video_grid_thw",
+                "text",
+                "processor.video_grid_thw",
+                "processor.video_grid_thw",
+                expected_relation="exact",
+            ),
+            _mapping(
+                "condition_vae.visual_pre_noise",
+                "trajectory",
+                "conditions_pre_noise.visual",
+                "conditions_pre_noise.0.visual_rows",
+                expected_relation="numeric",
+            ),
+            _mapping(
+                "condition_vae.audio_pre_noise",
+                "trajectory",
+                "conditions_pre_noise.audio",
+                ("conditions_pre_noise.0.audio_rows", "conditions_pre_noise.1.audio_rows"),
+                expected_relation="numeric",
+            ),
+            _mapping(
+                "condition_vae.visual_post_noise",
+                "trajectory",
+                "conditions_post_noise.visual",
+                "condition_rows_post_noise.visual",
+                expected_relation="numeric",
+            ),
+            _mapping(
+                "condition_vae.audio_post_noise",
+                "trajectory",
+                "conditions_post_noise.audio",
+                "condition_rows_post_noise.audio",
+                expected_relation="numeric",
+            ),
+        ]
+
+    for field in ("img_pos", "audio_pos", "text_pos", "update_mask", "img_position_ids", "cu_seqlens"):
+        mappings.append(
+            _mapping(
+                f"packed.{field}",
+                "trajectory",
+                f"packed.{field}",
+                f"packed.{field}",
+                expected_relation="exact",
+            )
+        )
+    mappings.append(
+        _mapping(
+            "packed.token_tags",
+            "trajectory",
+            "packed.token_tags",
+            "transformer_layout.block_token_tags",
+            expected_relation="exact",
+        )
+    )
+    if case == "ref2va":
+        mappings.append(
+            _mapping(
+                "packed.audio_update_mask",
+                "trajectory",
+                "packed.audio_update_mask",
+                "packed.audio_update_mask",
+                expected_relation="exact",
+            )
+        )
+    for field in (
+        "img_position_ids",
+        "unique_timesteps",
+        "inverse_indices",
+        "update_mask",
+        "img_pos_info.position_ids",
+        "audio_pos_info.position_ids",
+        "text_pos_info.position_ids",
+        "img_pos_for_infer_output_info.position_ids",
+        "packed_seq_params.cu_seqlens_q",
+    ):
+        mappings.append(
+            _mapping(
+                f"transformer_layout.{field}",
+                "trajectory",
+                f"transformer_layout.{field}",
+                f"transformer_layout.{field}",
+                expected_relation="exact",
+            )
+        )
+    mappings += [
+        _mapping(
+            "initial_noise.video",
+            "trajectory",
+            "initial_rows.visual",
+            "steps.0.scheduler_input.input_visual_latent",
+            expected_relation="exact",
+        ),
+        _mapping(
+            "initial_noise.audio",
+            "trajectory",
+            "initial_rows.audio",
+            "steps.0.scheduler_input.input_audio_latent",
+            expected_relation="exact",
+        ),
+    ]
+    for step in ("0", "24", "48"):
+        relation = "exact" if step == "0" else "numeric"
+        video_prediction_path = (
+            f"steps.{step}.dit_output.0" if case == "ref2va" else f"steps.{step}.scheduler_input.noise_pred_visual"
+        )
+        audio_prediction_path = (
+            f"steps.{step}.dit_output.1" if case == "ref2va" else f"steps.{step}.scheduler_input.noise_pred_audio"
+        )
+        mappings += [
+            _mapping(
+                f"step.{step}.pre_model.video",
+                "trajectory",
+                f"steps.{step}.pre_model.video_target",
+                f"steps.{step}.scheduler_input.input_visual_latent",
+                expected_relation=relation,
+            ),
+            _mapping(
+                f"step.{step}.pre_model.audio",
+                "trajectory",
+                f"steps.{step}.pre_model.audio_target",
+                f"steps.{step}.scheduler_input.input_audio_latent",
+                expected_relation=relation,
+            ),
+            _mapping(
+                f"step.{step}.dit_prediction.video",
+                "trajectory",
+                f"steps.{step}.dit_output.0",
+                video_prediction_path,
+                expected_relation="numeric",
+            ),
+            _mapping(
+                f"step.{step}.dit_prediction.audio",
+                "trajectory",
+                f"steps.{step}.dit_output.1",
+                audio_prediction_path,
+                expected_relation="numeric",
+            ),
+            _mapping(
+                f"step.{step}.scheduler_output.video",
+                "trajectory",
+                f"steps.{step}.scheduler_output.video_target",
+                f"steps.{step}.scheduler_output.output_visual_latent",
+                expected_relation="numeric",
+            ),
+            _mapping(
+                f"step.{step}.scheduler_output.audio",
+                "trajectory",
+                f"steps.{step}.scheduler_output.audio_target",
+                f"steps.{step}.scheduler_output.output_audio_latent",
+                expected_relation="numeric",
+            ),
+        ]
+    mappings += [
+        _mapping(
+            "final_latent.video",
+            "trajectory",
+            "final_video_latent",
+            "final_video_latent",
+            expected_relation="numeric",
+        ),
+        _mapping(
+            "final_latent.audio",
+            "trajectory",
+            "final_audio_latent",
+            "final_audio_latent",
+            expected_relation="numeric",
+        ),
+    ]
+    return mappings
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--case", choices=("t2va", "fl2va", "ref2va"), required=True)
+    parser.add_argument("--reference-trajectory", type=Path, required=True)
+    parser.add_argument("--candidate-trajectory", type=Path, required=True)
+    parser.add_argument("--reference-text", type=Path, required=True)
+    parser.add_argument("--candidate-text", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+
+    artifacts = {
+        "trajectory": (
+            torch.load(args.reference_trajectory, map_location="cpu", weights_only=True),
+            torch.load(args.candidate_trajectory, map_location="cpu", weights_only=True),
+        ),
+        "text": (
+            torch.load(args.reference_text, map_location="cpu", weights_only=True),
+            torch.load(args.candidate_text, map_location="cpu", weights_only=True),
+        ),
+    }
+    comparisons = {}
+    exact_checks = {}
+    for item in _mappings(args.case):
+        reference, candidate = artifacts[item["source"]]
+        metrics = _tensor_metrics(
+            _at(reference, item["reference_path"]),
+            _at(candidate, item["candidate_path"]),
+        )
+        metrics["expected_relation"] = item["expected_relation"]
+        comparisons[item["name"]] = metrics
+        if item["expected_relation"] == "exact":
+            exact_checks[item["name"]] = bool(metrics.get("comparable") and metrics.get("exact_fraction") == 1.0)
+
+    report = {
+        "schema_version": 1,
+        "case": args.case,
+        "reference": "pinned_sglang",
+        "candidate": "telefuser",
+        "artifacts": {
+            "reference_trajectory": {
+                "path": str(args.reference_trajectory.resolve()),
+                "sha256": _sha256(args.reference_trajectory),
+            },
+            "candidate_trajectory": {
+                "path": str(args.candidate_trajectory.resolve()),
+                "sha256": _sha256(args.candidate_trajectory),
+            },
+            "reference_text": {
+                "path": str(args.reference_text.resolve()),
+                "sha256": _sha256(args.reference_text),
+            },
+            "candidate_text": {
+                "path": str(args.candidate_text.resolve()),
+                "sha256": _sha256(args.candidate_text),
+            },
+        },
+        "exact_checks": exact_checks,
+        "all_exact_boundaries_passed": all(exact_checks.values()),
+        "comparisons": comparisons,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2, allow_nan=True) + "\n", encoding="utf-8")
+    print(json.dumps(report, sort_keys=True, allow_nan=True))
+    if not report["all_exact_boundaries_passed"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/validation/freeze_minimax_h3_reference.py b/tools/validation/freeze_minimax_h3_reference.py
new file mode 100644
index 00000000..6864c2b8
--- /dev/null
+++ b/tools/validation/freeze_minimax_h3_reference.py
@@ -0,0 +1,137 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Freeze the official MiniMax H3 requests and their remote input bytes."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import tempfile
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+if __package__:
+    from tools.validation.minimax_h3_validation_common import sha256 as _sha256
+else:
+    from minimax_h3_validation_common import sha256 as _sha256
+
+_CASES = ("t2va", "fl2va", "ref2va")
+_MAX_DOWNLOAD_BYTES = 2 * 1024**3
+
+
+def _extract_request(script: Path) -> dict[str, object]:
+    text = script.read_text(encoding="utf-8")
+    match = re.search(r"<<'JSON'\n(?P<payload>.*?)\nJSON", text, flags=re.DOTALL)
+    if match is None:
+        raise ValueError(f"could not find the JSON heredoc in {script}")
+    payload = json.loads(match.group("payload"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"request in {script} is not a JSON object")
+    return payload
+
+
+def _download(url: str, destination: Path) -> None:
+    request = urllib.request.Request(url, headers={"User-Agent": "TeleFuser-MiniMax-H3-parity/1"})
+    with urllib.request.urlopen(request, timeout=120) as response:
+        content_length = response.headers.get("Content-Length")
+        if content_length is not None and int(content_length) > _MAX_DOWNLOAD_BYTES:
+            raise ValueError(f"remote fixture exceeds the {_MAX_DOWNLOAD_BYTES}-byte limit: {url}")
+        with tempfile.NamedTemporaryFile(dir=destination.parent, suffix=".part", delete=False) as output:
+            temporary = Path(output.name)
+            copied = 0
+            while chunk := response.read(1024 * 1024):
+                copied += len(chunk)
+                if copied > _MAX_DOWNLOAD_BYTES:
+                    temporary.unlink(missing_ok=True)
+                    raise ValueError(f"remote fixture exceeds the {_MAX_DOWNLOAD_BYTES}-byte limit: {url}")
+                output.write(chunk)
+    temporary.replace(destination)
+
+
+def _fixture_name(case: str, index: int, url: str) -> str:
+    suffix = Path(unquote(urlsplit(url).path)).suffix.lower()
+    if not suffix or len(suffix) > 10:
+        suffix = ".bin"
+    return f"{case}-{index:02d}{suffix}"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model-root", default="/hhb-data/aigc/model_zoo/MiniMaxAI_MiniMax-H3")
+    parser.add_argument("--output-root", default="work_dirs/minimax_h3_parity")
+    parser.add_argument("--refresh", action="store_true", help="Download existing remote fixtures again")
+    args = parser.parse_args()
+
+    model_root = Path(args.model_root).resolve()
+    output_root = Path(args.output_root).resolve()
+    fixture_root = output_root / "fixtures"
+    request_root = output_root / "requests"
+    fixture_root.mkdir(parents=True, exist_ok=True)
+    request_root.mkdir(parents=True, exist_ok=True)
+
+    records: list[dict[str, object]] = []
+    for case in _CASES:
+        script = model_root / "scripts" / "readme" / f"reproducible-768p-{case}-request.sh"
+        request = _extract_request(script)
+        conditions = request.get("conditions", [])
+        if not isinstance(conditions, list):
+            raise ValueError(f"conditions in {script} must be a list")
+        localized: list[dict[str, object]] = []
+        for index, raw_condition in enumerate(conditions):
+            if not isinstance(raw_condition, dict):
+                raise ValueError(f"condition {index} in {script} must be an object")
+            condition = dict(raw_condition)
+            uri = condition.get("uri")
+            if not isinstance(uri, str):
+                raise ValueError(f"condition {index} in {script} has no string URI")
+            if urlsplit(uri).scheme not in {"http", "https"}:
+                raise ValueError(f"official condition URI is not HTTP(S): {uri}")
+            destination = fixture_root / _fixture_name(case, index, uri)
+            if args.refresh or not destination.is_file():
+                _download(uri, destination)
+            condition["uri"] = str(destination)
+            localized.append(condition)
+            records.append(
+                {
+                    "case": case,
+                    "condition_index": index,
+                    "original_uri": uri,
+                    "local_path": str(destination),
+                    "bytes": destination.stat().st_size,
+                    "sha256": _sha256(destination),
+                }
+            )
+        request["conditions"] = localized
+        request_path = request_root / f"reproducible-768p-{case}.json"
+        request_path.write_text(json.dumps(request, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+        records.append(
+            {
+                "case": case,
+                "source_script": str(script),
+                "source_script_sha256": _sha256(script),
+                "localized_request": str(request_path),
+                "localized_request_sha256": _sha256(request_path),
+            }
+        )
+
+    provenance = {
+        "schema_version": 1,
+        "frozen_at_utc": datetime.now(timezone.utc).isoformat(),
+        "model_root": str(model_root),
+        "records": records,
+    }
+    provenance_path = fixture_root / "provenance.json"
+    with tempfile.NamedTemporaryFile("w", dir=fixture_root, suffix=".json", encoding="utf-8", delete=False) as stream:
+        json.dump(provenance, stream, indent=2, ensure_ascii=True)
+        stream.write("\n")
+        temporary = Path(stream.name)
+    shutil.copymode(provenance_path, temporary) if provenance_path.exists() else None
+    temporary.replace(provenance_path)
+    print(json.dumps({"provenance": str(provenance_path), "records": len(records)}, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/validation/minimax_h3_trajectory_stage.py b/tools/validation/minimax_h3_trajectory_stage.py
new file mode 100644
index 00000000..86d1248a
--- /dev/null
+++ b/tools/validation/minimax_h3_trajectory_stage.py
@@ -0,0 +1,201 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Validation-only MiniMax H3 denoising stage with trajectory capture."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.distributed as dist
+
+from telefuser.core.config import ModelRuntimeConfig
+from telefuser.core.module_manager import ModuleManager
+from telefuser.pipelines.minimax_h3 import denoising as denoising_module
+from telefuser.pipelines.minimax_h3.denoising import (
+    MiniMaxH3DenoiseResult,
+    MiniMaxH3DenoisingStage,
+)
+from telefuser.pipelines.minimax_h3.resolved_plan import MiniMaxH3ResolvedPlan
+from telefuser.pipelines.minimax_h3.text_encoding import MiniMaxH3TextCondition
+from telefuser.pipelines.minimax_h3.vae import MiniMaxH3PreparedCondition
+
+
+def _cpu_capture(value: Any) -> Any:
+    if isinstance(value, torch.Tensor):
+        return value.detach().cpu().clone()
+    if isinstance(value, dict):
+        return {str(key): _cpu_capture(item) for key, item in value.items()}
+    if isinstance(value, tuple):
+        return tuple(_cpu_capture(item) for item in value)
+    if isinstance(value, list):
+        return [_cpu_capture(item) for item in value]
+    return value
+
+
+def _condition_payload(condition: MiniMaxH3PreparedCondition) -> dict[str, Any]:
+    return {
+        "material": asdict(condition.material),
+        "kind": condition.kind,
+        "visual_rows": _cpu_capture(condition.visual_rows),
+        "audio_rows": _cpu_capture(condition.audio_rows),
+        "latent_t": condition.latent_t,
+        "latent_h": condition.latent_h,
+        "latent_w": condition.latent_w,
+        "ref_audio_t": condition.ref_audio_t,
+        "has_audio": condition.has_audio,
+    }
+
+
+class MiniMaxH3TrajectoryDenoisingStage(MiniMaxH3DenoisingStage):
+    """Capture stable full-trajectory boundaries from the worker that owns the DiT."""
+
+    def __init__(
+        self,
+        module_manager: ModuleManager,
+        model_runtime_config: ModelRuntimeConfig,
+        *,
+        trajectory_path: str | Path,
+        max_updates: int | None = None,
+    ) -> None:
+        super().__init__(module_manager, model_runtime_config)
+        if max_updates is not None and max_updates < 1:
+            raise ValueError("max_updates must be at least 1 when provided")
+        self.trajectory_path = str(Path(trajectory_path).resolve())
+        self.max_updates = max_updates
+
+    def denoise(
+        self,
+        *,
+        plan: MiniMaxH3ResolvedPlan,
+        text: MiniMaxH3TextCondition,
+        conditions: list[MiniMaxH3PreparedCondition],
+        num_inference_steps: int,
+    ) -> MiniMaxH3DenoiseResult:
+        rank = dist.get_rank() if dist.is_available() and dist.is_initialized() else 0
+        world_size = dist.get_world_size() if dist.is_available() and dist.is_initialized() else 1
+        should_capture = rank == 0
+        configured_num_updates = num_inference_steps - 1
+        num_updates = min(configured_num_updates, self.max_updates or configured_num_updates)
+        selected_steps = sorted({0, num_updates // 2, num_updates - 1})
+        payload: dict[str, Any] = {
+            "schema_version": 1,
+            "rank": rank,
+            "world_size": world_size,
+            "num_inference_steps": num_inference_steps,
+            "num_updates": num_updates,
+            "configured_num_updates": configured_num_updates,
+            "trajectory_truncated": num_updates != configured_num_updates,
+            "selected_steps": selected_steps,
+            "plan": asdict(plan),
+            "text": {
+                "hidden_states": _cpu_capture(text.hidden_states),
+                "token_tags": _cpu_capture(text.token_tags),
+            },
+            "conditions_pre_noise": [_condition_payload(condition) for condition in conditions],
+            "transformer_layout": None,
+            "steps": {},
+        }
+
+        transformer_step = 0
+        scheduler_step = 0
+        original_transformer_forward = self.transformer.forward
+        original_scheduler_step = self.scheduler.step_denoising
+        original_time_shift_sigmas = denoising_module.minimax_h3_time_shift_sigmas
+
+        def limited_time_shift_sigmas(*args: Any, **kwargs: Any) -> torch.Tensor:
+            sigmas = original_time_shift_sigmas(*args, **kwargs)
+            return sigmas[: num_updates + 1]
+
+        def capture_transformer_forward(*args: Any, **kwargs: Any) -> Any:
+            nonlocal transformer_step
+            step = transformer_step
+            if should_capture and payload["transformer_layout"] is None:
+                layout_keys = (
+                    "img_position_ids",
+                    "unique_timesteps",
+                    "inverse_indices",
+                    "update_mask",
+                    "update_audio_mask",
+                    "img_pos_info",
+                    "audio_pos_info",
+                    "text_pos_info",
+                    "img_pos_for_infer_output_info",
+                    "packed_seq_params",
+                    "block_token_tags",
+                    "skip_mask_out_condition",
+                )
+                payload["transformer_layout"] = {key: _cpu_capture(kwargs[key]) for key in layout_keys if key in kwargs}
+                video_positions = kwargs["img_pos_info"]["position_ids"]
+                audio_positions = kwargs["audio_pos_info"]["position_ids"]
+                video_rows = kwargs["x"][0].index_select(0, video_positions)
+                audio_rows = kwargs["audio_x"][0].index_select(0, audio_positions)
+                payload["condition_rows_post_noise"] = {
+                    "visual": _cpu_capture(video_rows[~kwargs["update_mask"]]),
+                    "audio": _cpu_capture(audio_rows[~kwargs["update_audio_mask"]]),
+                }
+            output = original_transformer_forward(*args, **kwargs)
+            if should_capture and step in selected_steps:
+                step_payload = payload["steps"].setdefault(str(step), {})
+                step_payload["dit_output"] = _cpu_capture(output)
+            transformer_step += 1
+            return output
+
+        def capture_scheduler_step(**kwargs: Any) -> dict[str, torch.Tensor]:
+            nonlocal scheduler_step
+            step = scheduler_step
+            output = original_scheduler_step(**kwargs)
+            if should_capture and step in selected_steps:
+                scheduler_keys = (
+                    "input_visual_latent",
+                    "input_audio_latent",
+                    "timestep",
+                    "video_timestep",
+                    "audio_timestep",
+                    "noise_pred_visual",
+                    "noise_pred_audio",
+                    "sigma_curr",
+                    "sigma_next",
+                    "video_sigma_curr",
+                    "video_sigma_next",
+                    "audio_sigma_curr",
+                    "audio_sigma_next",
+                )
+                step_payload = payload["steps"].setdefault(str(step), {})
+                step_payload["scheduler_input"] = {
+                    key: _cpu_capture(kwargs[key]) for key in scheduler_keys if key in kwargs
+                }
+                step_payload["scheduler_output"] = _cpu_capture(output)
+            scheduler_step += 1
+            return output
+
+        self.transformer.forward = capture_transformer_forward
+        self.scheduler.step_denoising = capture_scheduler_step
+        if num_updates != configured_num_updates:
+            denoising_module.minimax_h3_time_shift_sigmas = limited_time_shift_sigmas
+        try:
+            result = super().denoise(
+                plan=plan,
+                text=text,
+                conditions=conditions,
+                num_inference_steps=num_inference_steps,
+            )
+        finally:
+            self.transformer.forward = original_transformer_forward
+            self.scheduler.step_denoising = original_scheduler_step
+            denoising_module.minimax_h3_time_shift_sigmas = original_time_shift_sigmas
+
+        if should_capture:
+            payload["packed"] = _cpu_capture(result.packed)
+            payload["final_video_latent"] = _cpu_capture(result.video_latent)
+            payload["final_audio_latent"] = _cpu_capture(result.audio_latent)
+            payload["observed_transformer_steps"] = transformer_step
+            payload["observed_scheduler_steps"] = scheduler_step
+            trajectory_path = Path(self.trajectory_path)
+            trajectory_path.parent.mkdir(parents=True, exist_ok=True)
+            torch.save(payload, trajectory_path)
+        return result
+
+
+__all__ = ["MiniMaxH3TrajectoryDenoisingStage"]
diff --git a/tools/validation/minimax_h3_validation_common.py b/tools/validation/minimax_h3_validation_common.py
new file mode 100644
index 00000000..bc1830d8
--- /dev/null
+++ b/tools/validation/minimax_h3_validation_common.py
@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Shared deterministic hashing helpers for MiniMax H3 validation tools."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def json_sha256(value: object) -> str:
+    payload = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def model_config_hashes(component_root: Path) -> dict[str, str]:
+    return {
+        str(path.relative_to(component_root)): sha256(path)
+        for path in sorted(component_root.rglob("*.json"))
+        if path.is_file()
+    }
+
+
+__all__ = ["json_sha256", "model_config_hashes", "sha256"]
diff --git a/tools/validation/probe_minimax_h3_block0.py b/tools/validation/probe_minimax_h3_block0.py
new file mode 100644
index 00000000..8b6fa537
--- /dev/null
+++ b/tools/validation/probe_minimax_h3_block0.py
@@ -0,0 +1,172 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Replay MiniMax H3 DiT block 0 and compare stable operator boundaries."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import torch
+from safetensors import safe_open
+
+from telefuser.core.config import AttentionConfig, AttnImplType
+from telefuser.models.minimax_h3_dit import (
+    MiniMaxH3DiTBlock,
+    MiniMaxH3DiTConfig,
+    _modulate,
+    _reorder_grouped_qkv_to_qkv,
+    _rotate_half,
+)
+from telefuser.ops.attention import attention
+
+if __package__:
+    from tools.validation.compare_minimax_h3_trajectories import _tensor_metrics
+    from tools.validation.minimax_h3_validation_common import sha256 as _sha256
+else:
+    from compare_minimax_h3_trajectories import _tensor_metrics
+    from minimax_h3_validation_common import sha256 as _sha256
+
+
+def _load_block(
+    config_path: Path,
+    checkpoint_path: Path,
+    device: torch.device,
+) -> tuple[MiniMaxH3DiTBlock, torch.Tensor]:
+    config = MiniMaxH3DiTConfig.from_json(config_path)
+    block = MiniMaxH3DiTBlock(config)
+    state = {}
+    with safe_open(checkpoint_path, framework="pt", device="cpu") as checkpoint:
+        rope_inv_freq = checkpoint.get_tensor("rope.inv_freq")
+        for name in block.state_dict():
+            tensor = checkpoint.get_tensor(f"blocks.0.{name}")
+            if name == "attn.qkv_proj.weight":
+                tensor = _reorder_grouped_qkv_to_qkv(
+                    tensor,
+                    num_query_groups=config.num_attention_heads,
+                    heads_per_group=1,
+                    head_dim=config.attention_head_dim,
+                )
+            state[name] = tensor
+    block.load_state_dict(state, strict=True)
+    return block.to(device).eval(), rope_inv_freq.to(device=device, dtype=torch.float32)
+
+
+def _record(comparisons: dict[str, Any], name: str, reference: torch.Tensor, candidate: torch.Tensor) -> None:
+    comparisons[name] = _tensor_metrics(reference, candidate.detach().cpu())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--reference-layers", type=Path, required=True)
+    parser.add_argument("--reference-block-details", type=Path, required=True)
+    parser.add_argument("--candidate-layers", type=Path, required=True)
+    parser.add_argument("--candidate-trajectory", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--device", default="cuda:0")
+    parser.add_argument("--rope-source", choices=("checkpoint", "captured-candidate"), default="checkpoint")
+    args = parser.parse_args()
+
+    device = torch.device(args.device)
+    reference_layers = torch.load(args.reference_layers, map_location="cpu", weights_only=True, mmap=True)
+    reference_details = torch.load(args.reference_block_details, map_location="cpu", weights_only=True, mmap=True)
+    candidate_layers = torch.load(args.candidate_layers, map_location="cpu", weights_only=True, mmap=True)
+    candidate_trajectory = torch.load(args.candidate_trajectory, map_location="cpu", weights_only=True, mmap=True)
+
+    block_input = reference_layers["block_0_input"]
+    hidden = block_input["hidden"].to(device)
+    adaln_input = block_input["adaln_input"].to(device)
+    combined_indices = block_input["combined_indices"].to(device)
+    block, rope_inv_freq = _load_block(args.config, args.checkpoint, device)
+    if args.rope_source == "checkpoint":
+        position_ids = candidate_trajectory["transformer_layout"]["img_position_ids"][0].to(device).float()
+        per_axis = position_ids.unsqueeze(-1) * rope_inv_freq.view(1, 1, -1)
+        half = torch.cat(tuple(per_axis.unbind(dim=1)), dim=-1)
+        rope_frequencies = torch.cat((half, half), dim=-1)
+    else:
+        rope_frequencies = candidate_layers["block_0_input"]["rope_frequencies"].to(device)
+    cu_seqlens = candidate_trajectory["packed"]["cu_seqlens"].tolist()
+    sequence_lengths = [
+        stop - start for start, stop in zip(cu_seqlens[:-1], cu_seqlens[1:], strict=True) if stop > start
+    ]
+
+    comparisons: dict[str, Any] = {}
+    with torch.inference_mode():
+        adaln_params = block.adaln_proj(adaln_input)
+        adaln_pairs = zip(reference_details["adaln_params"], adaln_params, strict=True)
+        for index, (reference, candidate) in enumerate(adaln_pairs):
+            _record(comparisons, f"adaln_params.{index}", reference, candidate)
+
+        norm1 = block.norm1(hidden)
+        _record(comparisons, "norm1", reference_details["norm1"], norm1)
+        attention_input = _modulate(norm1, adaln_params[0], adaln_params[1], combined_indices)
+        _record(comparisons, "attention_input", reference_details["attention_input"], attention_input)
+
+        sequence = attention_input.shape[0]
+        qkv = block.attn.qkv_proj(attention_input).reshape(
+            sequence,
+            3,
+            block.attn.num_heads,
+            block.attn.head_dim,
+        )
+        query, key, value = qkv.unbind(dim=1)
+        query = block.attn.q_norm(query)
+        key = block.attn.k_norm(key)
+        rotary_dim = rope_frequencies.shape[-1]
+        cosine = rope_frequencies.cos().unsqueeze(1).to(query.dtype)
+        sine = rope_frequencies.sin().unsqueeze(1).to(query.dtype)
+        query_rotary, query_pass = query[..., :rotary_dim], query[..., rotary_dim:]
+        key_rotary, key_pass = key[..., :rotary_dim], key[..., rotary_dim:]
+        query = torch.cat((query_rotary * cosine + _rotate_half(query_rotary) * sine, query_pass), dim=-1)
+        key = torch.cat((key_rotary * cosine + _rotate_half(key_rotary) * sine, key_pass), dim=-1)
+        attended = attention(
+            query.unsqueeze(0),
+            key.unsqueeze(0),
+            value.unsqueeze(0),
+            attention_config=AttentionConfig.dense_attention(AttnImplType.TORCH_SDPA),
+            scale=block.attn.head_dim**-0.5,
+            sequence_lengths=sequence_lengths,
+        )
+        attention_output = block.attn.out_proj(attended[0].reshape(sequence, block.attn.inner_dim))
+        _record(comparisons, "attention_output", reference_details["attention_output"], attention_output)
+        del attended, query, key, value, qkv
+
+        post_attention = hidden + adaln_params[2].index_select(0, combined_indices) * attention_output
+        _record(comparisons, "post_attention", reference_details["post_attention"], post_attention)
+        norm2 = block.norm2(post_attention)
+        _record(comparisons, "norm2", reference_details["norm2"], norm2)
+        mlp_input = _modulate(norm2, adaln_params[3], adaln_params[4], combined_indices)
+        _record(comparisons, "mlp_input", reference_details["mlp_input"], mlp_input)
+        mlp_output = block.mlp(mlp_input)
+        _record(comparisons, "mlp_output", reference_details["mlp_output"], mlp_output)
+        block_output = post_attention + adaln_params[5].index_select(0, combined_indices) * mlp_output
+        _record(comparisons, "block_output", reference_details["block_output"], block_output)
+
+    report = {
+        "schema_version": 1,
+        "device": str(device),
+        "rope_source": args.rope_source,
+        "sequence_lengths": sequence_lengths,
+        "artifacts": {
+            name: {"path": str(path.resolve()), "sha256": _sha256(path)}
+            for name, path in {
+                "config": args.config,
+                "checkpoint": args.checkpoint,
+                "reference_layers": args.reference_layers,
+                "reference_block_details": args.reference_block_details,
+                "candidate_layers": args.candidate_layers,
+                "candidate_trajectory": args.candidate_trajectory,
+            }.items()
+        },
+        "comparisons": comparisons,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2, allow_nan=True) + "\n", encoding="utf-8")
+    print(json.dumps(report, sort_keys=True, allow_nan=True))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/validation/run_minimax_h3_sglang_reference.py b/tools/validation/run_minimax_h3_sglang_reference.py
new file mode 100644
index 00000000..f0203b53
--- /dev/null
+++ b/tools/validation/run_minimax_h3_sglang_reference.py
@@ -0,0 +1,247 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Run a frozen MiniMax H3 request with the pinned SGLang reference."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import json
+import shutil
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+if __package__:
+    from tools.validation.minimax_h3_validation_common import (
+        json_sha256 as _json_sha256,
+    )
+    from tools.validation.minimax_h3_validation_common import (
+        model_config_hashes as _model_config_hashes,
+    )
+    from tools.validation.minimax_h3_validation_common import (
+        sha256 as _sha256,
+    )
+else:
+    from minimax_h3_validation_common import (
+        json_sha256 as _json_sha256,
+    )
+    from minimax_h3_validation_common import (
+        model_config_hashes as _model_config_hashes,
+    )
+    from minimax_h3_validation_common import (
+        sha256 as _sha256,
+    )
+
+
+def _json_value(value: Any) -> Any:
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _json_value(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_value(item) for item in value]
+    return str(value)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--request", type=Path, required=True)
+    parser.add_argument("--model-root", type=Path, default=Path("/hhb-data/aigc/model_zoo/MiniMaxAI_MiniMax-H3"))
+    parser.add_argument("--sglang-root", type=Path, default=Path("work_dirs/sglang"))
+    parser.add_argument("--partition", choices=("fl2va", "ref2va"), required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--artifact-dir", type=Path)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--num-inference-steps", type=int, default=2)
+    parser.add_argument("--target-duration-seconds", type=float)
+    parser.add_argument("--num-gpus", type=int, default=4)
+    parser.add_argument("--tp-size", type=int, default=2)
+    parser.add_argument("--ulysses-degree", type=int, default=2)
+    parser.add_argument("--performance-mode", choices=("manual", "auto", "speed", "memory"), default="speed")
+    parser.add_argument("--vae-cpu-offload", action="store_true")
+    parser.add_argument("--dit-layerwise-offload", action="store_true")
+    parser.add_argument("--attention-backend")
+    parser.add_argument("--text-condition-artifact", type=Path)
+    parser.add_argument("--trajectory-artifact", type=Path)
+    parser.add_argument("--instrumentation-diff", type=Path)
+    args = parser.parse_args()
+
+    if args.num_inference_steps < 2:
+        raise ValueError("MiniMax H3 requires at least two inference steps")
+    request_path = args.request.resolve()
+    request = json.loads(request_path.read_text(encoding="utf-8"))
+    if not isinstance(request, dict):
+        raise ValueError("frozen request must be a JSON object")
+    allowed_tasks = {"fl2va": {"t2va", "fl2va"}, "ref2va": {"ref2va"}}
+    if request.get("task") not in allowed_tasks[args.partition]:
+        raise ValueError(f"request task {request.get('task')!r} is incompatible with {args.partition}")
+    if args.target_duration_seconds is not None:
+        if not 4 <= args.target_duration_seconds <= 15:
+            raise ValueError("target duration must be in [4, 15] seconds")
+        request["target"] = {**request["target"], "duration_seconds": args.target_duration_seconds}
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.manifest.parent.mkdir(parents=True, exist_ok=True)
+    if args.artifact_dir is not None:
+        args.artifact_dir.mkdir(parents=True, exist_ok=True)
+    if args.instrumentation_diff is not None:
+        instrumentation = subprocess.run(
+            ["git", "-C", str(args.sglang_root.resolve()), "diff", "--binary"],
+            check=True,
+            capture_output=True,
+        ).stdout
+        if not instrumentation:
+            raise ValueError("--instrumentation-diff requires a modified SGLang worktree")
+        args.instrumentation_diff.parent.mkdir(parents=True, exist_ok=True)
+        args.instrumentation_diff.write_bytes(instrumentation)
+
+    import torch
+    from sglang.multimodal_gen import DiffGenerator
+
+    server_kwargs = {
+        "model_path": str(args.model_root.resolve()),
+        "model_id": "MiniMax-H3",
+        "pipeline_class_name": "MiniMaxH3Pipeline",
+        "model_variant": args.partition,
+        "backend": "sglang",
+        "performance_mode": args.performance_mode,
+        "num_gpus": args.num_gpus,
+        "tp_size": args.tp_size,
+        "ulysses_degree": args.ulysses_degree,
+        "enable_torch_compile": False,
+        "enable_cfg_parallel": False,
+        "warmup_mode": "off",
+        "vae_cpu_offload": args.vae_cpu_offload,
+        "dit_layerwise_offload": args.dit_layerwise_offload,
+    }
+    if args.attention_backend is not None:
+        server_kwargs["attention_backend"] = args.attention_backend
+    sampling_kwargs = {
+        **request,
+        "num_inference_steps": args.num_inference_steps,
+        "flow_shift": 12.0,
+        "audio_flow_shift": 3.0,
+        "save_output": True,
+        "return_file_paths_only": args.artifact_dir is None,
+        "output_path": str(args.output.resolve().parent),
+        "output_file_name": args.output.name,
+    }
+
+    started_at = datetime.now(timezone.utc)
+    with DiffGenerator.from_pretrained(local_mode=True, **server_kwargs) as generator:
+        result = generator.generate(sampling_params_kwargs=sampling_kwargs)
+    finished_at = datetime.now(timezone.utc)
+    if result is None or isinstance(result, list):
+        raise RuntimeError(f"expected one SGLang result, got {type(result).__name__}")
+    output_path = Path(result.output_file_path or args.output).resolve()
+    if not output_path.is_file():
+        raise RuntimeError(f"SGLang did not create the expected output: {output_path}")
+
+    validation_artifacts: dict[str, dict[str, object]] = {}
+    for name, destination, suffix in (
+        ("text_condition", args.text_condition_artifact, ".text.pt"),
+        ("trajectory", args.trajectory_artifact, ".trajectory.pt"),
+    ):
+        if destination is None:
+            continue
+        source = Path(f"{output_path}{suffix}")
+        if not source.is_file():
+            raise RuntimeError(f"instrumented SGLang did not create {source}")
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        if source.resolve() != destination.resolve():
+            shutil.move(source, destination)
+        validation_artifacts[name] = {
+            "path": str(destination.resolve()),
+            "bytes": destination.stat().st_size,
+            "sha256": _sha256(destination),
+        }
+    if args.instrumentation_diff is not None:
+        validation_artifacts["instrumentation_diff"] = {
+            "path": str(args.instrumentation_diff.resolve()),
+            "bytes": args.instrumentation_diff.stat().st_size,
+            "sha256": _sha256(args.instrumentation_diff),
+        }
+
+    raw_artifacts: dict[str, object] = {}
+    if args.artifact_dir is not None:
+        if not result.frames:
+            raise RuntimeError("SGLang raw capture returned no frames")
+        frames = np.stack([np.asarray(frame, dtype=np.uint8) for frame in result.frames])
+        audio = (
+            result.audio.detach().float().cpu().numpy()
+            if isinstance(result.audio, torch.Tensor)
+            else np.asarray(result.audio)
+        )
+        frames_path = args.artifact_dir / "frames_uint8.npy"
+        audio_path = args.artifact_dir / "audio_float32.npy"
+        np.save(frames_path, frames, allow_pickle=False)
+        np.save(audio_path, audio.astype(np.float32, copy=False), allow_pickle=False)
+        raw_artifacts = {
+            "frames": {
+                "path": str(frames_path.resolve()),
+                "shape": list(frames.shape),
+                "dtype": str(frames.dtype),
+                "sha256": _sha256(frames_path),
+            },
+            "audio": {
+                "path": str(audio_path.resolve()),
+                "shape": list(audio.shape),
+                "dtype": str(audio.dtype),
+                "sha256": _sha256(audio_path),
+            },
+        }
+
+    sglang_commit = subprocess.run(
+        ["git", "-C", str(args.sglang_root.resolve()), "rev-parse", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    packages = {}
+    for name in ("sglang", "torch", "transformers", "diffusers", "flashinfer-python", "sglang-kernel"):
+        packages[name] = importlib.metadata.version(name)
+    device = torch.cuda.get_device_properties(0)
+    partition_dir = {"fl2va": "FL2VA", "ref2va": "Ref2VA"}[args.partition]
+    manifest = {
+        "schema_version": 2,
+        "started_at_utc": started_at.isoformat(),
+        "finished_at_utc": finished_at.isoformat(),
+        "duration_seconds": (finished_at - started_at).total_seconds(),
+        "sglang_commit": sglang_commit,
+        "request": str(request_path),
+        "source_request_sha256": _sha256(request_path),
+        "request_sha256": _json_sha256(request),
+        "model_config_sha256": _model_config_hashes(args.model_root.resolve() / partition_dir),
+        "seed": request.get("seed"),
+        "precision": {
+            "text_encoder": "bfloat16",
+            "transformer": "bfloat16",
+            "video_vae_decode_autocast": "float16",
+            "audio_vae": "float32",
+        },
+        "server_kwargs": server_kwargs,
+        "sampling_kwargs": sampling_kwargs,
+        "packages": packages,
+        "cuda": torch.version.cuda,
+        "gpu": {"name": device.name, "memory_bytes": device.total_memory, "count": torch.cuda.device_count()},
+        "result": {
+            "size": _json_value(result.size),
+            "generation_time_seconds": result.generation_time,
+            "peak_memory_mb": result.peak_memory_mb,
+            "metrics": _json_value(result.metrics),
+            "output_path": str(output_path),
+            "output_bytes": output_path.stat().st_size,
+            "output_sha256": _sha256(output_path),
+            "raw_artifacts": raw_artifacts,
+        },
+        "validation_artifacts": validation_artifacts,
+    }
+    args.manifest.write_text(json.dumps(manifest, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+    print(json.dumps(manifest["result"], sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/validation/run_minimax_h3_telefuser_reference.py b/tools/validation/run_minimax_h3_telefuser_reference.py
new file mode 100644
index 00000000..c02a2d77
--- /dev/null
+++ b/tools/validation/run_minimax_h3_telefuser_reference.py
@@ -0,0 +1,457 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Run a frozen MiniMax H3 request with TeleFuser and capture raw outputs."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import json
+import runpy
+import subprocess
+import time
+from collections.abc import Mapping
+from dataclasses import asdict, replace
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import torch
+
+if __package__:
+    from tools.validation.minimax_h3_validation_common import (
+        json_sha256 as _json_sha256,
+    )
+    from tools.validation.minimax_h3_validation_common import (
+        model_config_hashes as _model_config_hashes,
+    )
+    from tools.validation.minimax_h3_validation_common import (
+        sha256 as _sha256,
+    )
+else:
+    from minimax_h3_validation_common import (
+        json_sha256 as _json_sha256,
+    )
+    from minimax_h3_validation_common import (
+        model_config_hashes as _model_config_hashes,
+    )
+    from minimax_h3_validation_common import (
+        sha256 as _sha256,
+    )
+
+
+def _array_summary(array: np.ndarray) -> dict[str, object]:
+    values = array.astype(np.float64, copy=False)
+    return {
+        "shape": list(array.shape),
+        "dtype": str(array.dtype),
+        "min": float(values.min()),
+        "max": float(values.max()),
+        "mean": float(values.mean()),
+        "std": float(values.std()),
+    }
+
+
+def _cpu_capture(value: object) -> object:
+    if isinstance(value, torch.Tensor):
+        return value.detach().cpu().clone()
+    if isinstance(value, Mapping):
+        return {str(key): _cpu_capture(item) for key, item in value.items()}
+    if isinstance(value, tuple):
+        return tuple(_cpu_capture(item) for item in value)
+    if isinstance(value, list):
+        return [_cpu_capture(item) for item in value]
+    return value
+
+
+def _captured_hidden_states(value: object) -> torch.Tensor:
+    if not isinstance(value, Mapping):
+        raise TypeError("captured text condition must be a mapping")
+    hidden_states = value.get("hidden_states")
+    if isinstance(hidden_states, torch.Tensor):
+        return hidden_states
+    positive = value.get("positive")
+    if isinstance(positive, Mapping):
+        hidden_states = positive.get("hidden_states")
+        if isinstance(hidden_states, torch.Tensor):
+            return hidden_states
+    raise KeyError("captured text condition has no hidden_states tensor")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--request", type=Path, required=True)
+    parser.add_argument("--model-root", type=Path, default=Path("/hhb-data/aigc/model_zoo/MiniMaxAI_MiniMax-H3"))
+    parser.add_argument("--partition", choices=("FL2VA", "Ref2VA"), required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--artifact-dir", type=Path, required=True)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--num-inference-steps", type=int, default=2)
+    parser.add_argument("--target-duration-seconds", type=float)
+    parser.add_argument("--device", default="cuda:0")
+    parser.add_argument("--ulysses-degree", type=int, choices=(1, 2, 4), default=1)
+    parser.add_argument("--text-condition-artifact", type=Path)
+    parser.add_argument("--text-condition-input", type=Path)
+    parser.add_argument("--denoise-boundary-artifact", type=Path)
+    parser.add_argument("--dit-layer-artifact", type=Path)
+    parser.add_argument("--dit-layer-input", type=Path)
+    parser.add_argument("--trajectory-artifact", type=Path)
+    parser.add_argument("--trajectory-max-updates", type=int)
+    args = parser.parse_args()
+    run_started = time.perf_counter()
+
+    if args.trajectory_max_updates is not None and args.trajectory_artifact is None:
+        parser.error("--trajectory-max-updates requires --trajectory-artifact")
+
+    request_path = args.request.resolve()
+    request = json.loads(request_path.read_text(encoding="utf-8"))
+    if not isinstance(request, dict):
+        raise ValueError("frozen request must be a JSON object")
+    allowed_tasks = {"FL2VA": {"t2va", "fl2va"}, "Ref2VA": {"ref2va"}}
+    if request.get("task") not in allowed_tasks[args.partition]:
+        raise ValueError(f"request task {request.get('task')!r} is incompatible with {args.partition}")
+    if args.target_duration_seconds is not None:
+        if not 4 <= args.target_duration_seconds <= 15:
+            raise ValueError("target duration must be in [4, 15] seconds")
+        request["target"] = {**request["target"], "duration_seconds": args.target_duration_seconds}
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.artifact_dir.mkdir(parents=True, exist_ok=True)
+    args.manifest.parent.mkdir(parents=True, exist_ok=True)
+    if args.trajectory_artifact is not None:
+        from minimax_h3_trajectory_stage import MiniMaxH3TrajectoryDenoisingStage
+
+        from telefuser.pipelines.minimax_h3 import pipeline as pipeline_module
+
+        trajectory_path = args.trajectory_artifact.resolve()
+
+        def build_trajectory_stage(module_manager: object, model_runtime_config: object) -> object:
+            return MiniMaxH3TrajectoryDenoisingStage(
+                module_manager,
+                model_runtime_config,
+                trajectory_path=trajectory_path,
+                max_updates=args.trajectory_max_updates,
+            )
+
+        pipeline_module.MiniMaxH3DenoisingStage = build_trajectory_stage
+    load_started = time.perf_counter()
+    common = runpy.run_path(str(Path(__file__).resolve().parents[2] / "examples" / "minimax_h3" / "common.py"))
+    load_minimax_h3_pipeline = common["load_minimax_h3_pipeline"]
+    save_generation = common["save_generation"]
+    pipeline = load_minimax_h3_pipeline(
+        args.model_root,
+        partition=args.partition,
+        device=args.device,
+        num_inference_steps=args.num_inference_steps,
+        ulysses_degree=args.ulysses_degree,
+    )
+    load_seconds = time.perf_counter() - load_started
+    if args.text_condition_artifact is not None or args.text_condition_input is not None:
+        if pipeline.text_stage is None:
+            raise RuntimeError("MiniMax H3 text stage is not initialized")
+        injected_condition = (
+            None
+            if args.text_condition_input is None
+            else torch.load(args.text_condition_input, map_location="cpu", weights_only=True)
+        )
+        if args.text_condition_artifact is not None:
+            args.text_condition_artifact.parent.mkdir(parents=True, exist_ok=True)
+        original_encode = pipeline.text_stage.encode
+
+        def capture_text_condition(**kwargs: object) -> object:
+            ref2va_encoder_inputs: dict[str, object] = {}
+            original_encode_ids = pipeline.text_stage.text_encoder.encode_ids
+            if request["task"] == "ref2va":
+
+                def capture_encode_ids(input_ids: torch.Tensor, **encoder_kwargs: object) -> torch.Tensor:
+                    ref2va_encoder_inputs["input_ids"] = input_ids.detach().cpu()
+                    ref2va_encoder_inputs["processor"] = _cpu_capture(encoder_kwargs)
+                    return original_encode_ids(input_ids, **encoder_kwargs)
+
+                pipeline.text_stage.text_encoder.encode_ids = capture_encode_ids
+            try:
+                condition = original_encode(**kwargs)
+            finally:
+                pipeline.text_stage.text_encoder.encode_ids = original_encode_ids
+            if injected_condition is not None:
+                hidden_states = _captured_hidden_states(injected_condition)
+                if tuple(hidden_states.shape) != tuple(condition.hidden_states.shape):
+                    raise ValueError(
+                        "injected text hidden shape "
+                        f"{tuple(hidden_states.shape)} != encoded shape {tuple(condition.hidden_states.shape)}"
+                    )
+                condition = replace(
+                    condition,
+                    hidden_states=hidden_states.to(dtype=condition.hidden_states.dtype),
+                )
+            payload = {
+                "hidden_states": condition.hidden_states.detach().cpu(),
+                "token_tags": condition.token_tags.detach().cpu(),
+            }
+            if request["task"] == "t2va":
+                from telefuser.pipelines.minimax_h3.presentation import minimax_h3_text_only_ids
+
+                payload["input_ids"] = minimax_h3_text_only_ids(
+                    pipeline.text_stage.tokenizer,
+                    request["prompt"],
+                )
+            elif request["task"] == "fl2va":
+                from telefuser.pipelines.minimax_h3.presentation import minimax_h3_multi_image_presentation
+
+                images = kwargs["images"]
+                vision = pipeline.text_stage.processor.image_processor(images=images, return_tensors="pt")
+                grids = vision["image_grid_thw"]
+                merge = int(pipeline.text_stage.processor.image_processor.merge_size) ** 2
+                counts = [int(grids[index].prod().item()) // merge for index in range(len(images))]
+                input_ids, input_tags = minimax_h3_multi_image_presentation(
+                    pipeline.text_stage.tokenizer,
+                    prompt=request["prompt"],
+                    image_token_counts=counts,
+                )
+                if not torch.equal(input_tags, condition.token_tags):
+                    raise RuntimeError("reconstructed FL2VA token tags differ from the encoded condition")
+                payload["input_ids"] = input_ids
+                payload["processor"] = _cpu_capture(vision)
+            elif request["task"] == "ref2va":
+                payload.update(ref2va_encoder_inputs)
+            if args.text_condition_artifact is not None:
+                torch.save(payload, args.text_condition_artifact)
+            return condition
+
+        pipeline.text_stage.encode = capture_text_condition
+    if args.denoise_boundary_artifact is not None:
+        if args.ulysses_degree != 1:
+            raise ValueError("--denoise-boundary-artifact currently requires --ulysses-degree 1")
+        if pipeline.denoising_stage is None:
+            raise RuntimeError("MiniMax H3 denoising stage is not initialized")
+        args.denoise_boundary_artifact.parent.mkdir(parents=True, exist_ok=True)
+        captured_boundaries: dict[str, object] = {}
+        transformer = pipeline.denoising_stage.transformer
+        original_transformer_forward = transformer.forward
+
+        def capture_transformer_forward(*forward_args: object, **forward_kwargs: object) -> object:
+            capture_first_step = "dit_inputs" not in captured_boundaries
+            if capture_first_step:
+                captured_boundaries["dit_inputs"] = {
+                    "args": _cpu_capture(forward_args),
+                    "kwargs": _cpu_capture(forward_kwargs),
+                }
+            output = original_transformer_forward(*forward_args, **forward_kwargs)
+            if capture_first_step:
+                captured_boundaries["dit_outputs"] = _cpu_capture(output)
+            return output
+
+        transformer.forward = capture_transformer_forward
+        original_denoise = pipeline.denoising_stage.denoise
+
+        def capture_denoise(**kwargs: object) -> object:
+            denoised = original_denoise(**kwargs)
+            captured_boundaries["final_video_latent"] = _cpu_capture(denoised.video_latent)
+            captured_boundaries["final_audio_latent"] = _cpu_capture(denoised.audio_latent)
+            captured_boundaries["packed"] = _cpu_capture(denoised.packed)
+            torch.save(captured_boundaries, args.denoise_boundary_artifact)
+            return denoised
+
+        pipeline.denoising_stage.denoise = capture_denoise
+    captured_layers: dict[str, object] = {}
+    if args.dit_layer_artifact is not None or args.dit_layer_input is not None:
+        if args.ulysses_degree != 1:
+            raise ValueError("DiT layer capture and injection currently require --ulysses-degree 1")
+        if pipeline.denoising_stage is None:
+            raise RuntimeError("MiniMax H3 denoising stage is not initialized")
+        if args.dit_layer_artifact is not None:
+            args.dit_layer_artifact.parent.mkdir(parents=True, exist_ok=True)
+        injected_layers = (
+            None
+            if args.dit_layer_input is None
+            else torch.load(args.dit_layer_input, map_location="cpu", weights_only=False)
+        )
+        transformer = pipeline.denoising_stage.transformer
+
+        def capture_output(name: str):
+            def hook(_module: object, _inputs: object, output: object) -> None:
+                if name not in captured_layers:
+                    captured_layers[name] = _cpu_capture(output)
+
+            return hook
+
+        def capture_block_input(
+            _module: object,
+            inputs: tuple[object, ...],
+            kwargs: dict[str, object],
+        ) -> tuple[tuple[object, ...], dict[str, object]] | None:
+            if "block_0_input" in captured_layers:
+                return
+            hidden = inputs[0]
+            effective_kwargs = kwargs
+            if injected_layers is not None:
+                injected_input = injected_layers["block_0_input"]
+                hidden = injected_input["hidden"].to(device=hidden.device, dtype=hidden.dtype)
+                effective_kwargs = {
+                    **kwargs,
+                    "adaln_input": injected_input["adaln_input"].to(
+                        device=kwargs["adaln_input"].device,
+                        dtype=kwargs["adaln_input"].dtype,
+                    ),
+                    "combined_indices": injected_input["combined_indices"].to(
+                        device=kwargs["combined_indices"].device,
+                        dtype=kwargs["combined_indices"].dtype,
+                    ),
+                }
+            captured_layers["block_0_input"] = {
+                "hidden": _cpu_capture(hidden),
+                "adaln_input": _cpu_capture(effective_kwargs["adaln_input"]),
+                "combined_indices": _cpu_capture(effective_kwargs["combined_indices"]),
+                "rope_frequencies": _cpu_capture(effective_kwargs["rope_frequencies"]),
+            }
+            if injected_layers is not None:
+                return (hidden,), effective_kwargs
+
+        transformer.condition_proj.register_forward_hook(capture_output("condition_proj"))
+        transformer.token_refiner.register_forward_hook(capture_output("token_refiner"))
+        transformer.video_patch_proj.register_forward_hook(capture_output("video_patch_proj"))
+        transformer.audio_patch_proj.register_forward_hook(capture_output("audio_patch_proj"))
+        transformer.time_embedder.register_forward_hook(capture_output("time_embedder"))
+        transformer.rope.register_forward_hook(capture_output("rope"))
+        transformer.blocks[0].register_forward_pre_hook(capture_block_input, with_kwargs=True)
+        transformer.blocks[0].attn.register_forward_hook(capture_output("block_0_attention"))
+        transformer.blocks[0].mlp.register_forward_hook(capture_output("block_0_mlp"))
+        for index in (0, len(transformer.blocks) // 2, len(transformer.blocks) - 1):
+            transformer.blocks[index].register_forward_hook(capture_output(f"block_{index}_output"))
+        transformer.final_layer.register_forward_hook(capture_output("final_layer"))
+
+    torch.cuda.reset_peak_memory_stats(args.device)
+    started_at = datetime.now(timezone.utc)
+    generation_started = time.perf_counter()
+    try:
+        result = pipeline(
+            task=request["task"],
+            prompt=request["prompt"],
+            conditions=request.get("conditions"),
+            target=request["target"],
+            seed=request.get("seed"),
+            flow_shift=12.0,
+            audio_flow_shift=3.0,
+            num_inference_steps=args.num_inference_steps,
+        )
+        torch.cuda.synchronize(args.device)
+        if args.dit_layer_artifact is not None:
+            torch.save(captured_layers, args.dit_layer_artifact)
+        generation_compute_seconds = time.perf_counter() - generation_started
+    finally:
+        shutdown_started = time.perf_counter()
+        pipeline.stop()
+        shutdown_seconds = time.perf_counter() - shutdown_started
+    generation_seconds = time.perf_counter() - generation_started
+    finished_at = datetime.now(timezone.utc)
+    artifact_started = time.perf_counter()
+
+    frames = result.video[0].mul(255).clamp(0, 255).to(torch.uint8).numpy()
+    audio = result.audio[0].float().numpy()
+    frames_path = args.artifact_dir / "frames_uint8.npy"
+    audio_path = args.artifact_dir / "audio_float32.npy"
+    np.save(frames_path, frames, allow_pickle=False)
+    np.save(audio_path, audio, allow_pickle=False)
+    save_generation(result, args.output)
+
+    packages = {}
+    for name in ("telefuser", "torch", "transformers", "diffusers", "safetensors"):
+        packages[name] = importlib.metadata.version(name)
+    git_commit = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    manifest = {
+        "schema_version": 2,
+        "started_at_utc": started_at.isoformat(),
+        "finished_at_utc": finished_at.isoformat(),
+        "generation_seconds": generation_seconds,
+        "telefuser_commit": git_commit,
+        "request": str(request_path),
+        "source_request_sha256": _sha256(request_path),
+        "request_sha256": _json_sha256(request),
+        "model_root": str(args.model_root.resolve()),
+        "partition": args.partition,
+        "model_config_sha256": _model_config_hashes(args.model_root.resolve() / args.partition),
+        "seed": request.get("seed"),
+        "precision": {
+            "text_encoder": "bfloat16",
+            "transformer": "bfloat16",
+            "video_vae_weights": "float32",
+            "video_vae_cuda_decode_autocast": "float16",
+            "audio_vae": "float32",
+        },
+        "num_inference_steps": args.num_inference_steps,
+        "device": args.device,
+        "parallel": {"ulysses_degree": args.ulysses_degree, "device_count": args.ulysses_degree},
+        "packages": packages,
+        "cuda": torch.version.cuda,
+        "gpu": torch.cuda.get_device_name(args.device),
+        "peak_allocated_bytes": torch.cuda.max_memory_allocated(args.device),
+        "peak_reserved_bytes": torch.cuda.max_memory_reserved(args.device),
+        "plan": asdict(result.plan),
+        "packed_sequence_length": result.packed_sequence_length,
+        "runtime_metrics": result.runtime_metrics,
+        "artifacts": {
+            "frames": {**_array_summary(frames), "path": str(frames_path.resolve()), "sha256": _sha256(frames_path)},
+            "audio": {**_array_summary(audio), "path": str(audio_path.resolve()), "sha256": _sha256(audio_path)},
+            "mp4": {
+                "path": str(args.output.resolve()),
+                "bytes": args.output.stat().st_size,
+                "sha256": _sha256(args.output),
+                "mux_policy": "complete_generated_audio",
+            },
+        },
+    }
+    if args.text_condition_artifact is not None:
+        manifest["artifacts"]["text_condition"] = {
+            "path": str(args.text_condition_artifact.resolve()),
+            "sha256": _sha256(args.text_condition_artifact),
+        }
+    if args.text_condition_input is not None:
+        manifest["text_condition_input"] = {
+            "path": str(args.text_condition_input.resolve()),
+            "sha256": _sha256(args.text_condition_input),
+        }
+    if args.denoise_boundary_artifact is not None:
+        manifest["artifacts"]["denoise_boundaries"] = {
+            "path": str(args.denoise_boundary_artifact.resolve()),
+            "sha256": _sha256(args.denoise_boundary_artifact),
+        }
+    if args.dit_layer_artifact is not None:
+        manifest["artifacts"]["dit_layers"] = {
+            "path": str(args.dit_layer_artifact.resolve()),
+            "sha256": _sha256(args.dit_layer_artifact),
+        }
+    if args.dit_layer_input is not None:
+        manifest["dit_layer_input"] = {
+            "path": str(args.dit_layer_input.resolve()),
+            "sha256": _sha256(args.dit_layer_input),
+        }
+    if args.trajectory_artifact is not None:
+        manifest["artifacts"]["trajectory"] = {
+            "path": str(args.trajectory_artifact.resolve()),
+            "sha256": _sha256(args.trajectory_artifact),
+        }
+        manifest["trajectory_max_updates"] = args.trajectory_max_updates
+    timings = {
+        "load_seconds": load_seconds,
+        "generation_compute_seconds": generation_compute_seconds,
+        "shutdown_seconds": shutdown_seconds,
+        "generation_seconds": generation_seconds,
+        "artifact_seconds": time.perf_counter() - artifact_started,
+        "total_seconds": time.perf_counter() - run_started,
+    }
+    manifest["timings"] = timings
+    args.manifest.write_text(json.dumps(manifest, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+    print(
+        json.dumps(
+            {"timings": timings, "runtime_metrics": result.runtime_metrics, "artifacts": manifest["artifacts"]},
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/validation/validate_minimax_h3_loading.py b/tools/validation/validate_minimax_h3_loading.py
new file mode 100644
index 00000000..8ba49869
--- /dev/null
+++ b/tools/validation/validate_minimax_h3_loading.py
@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Strictly load one original MiniMax H3 component through ModuleManager."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import torch
+
+from telefuser.core.module_manager import ModuleManager
+from telefuser.models.minimax_h3_audio_vae import MiniMaxH3AudioVAE
+from telefuser.models.minimax_h3_dit import MiniMaxH3DiT
+from telefuser.models.minimax_h3_encoder import MiniMaxH3Encoder
+from telefuser.models.minimax_h3_video_vae import MiniMaxH3VideoVAE
+
+
+def _shards(component: Path) -> list[str]:
+    paths = sorted(str(path) for path in component.glob("model-*.safetensors"))
+    if not paths:
+        raise FileNotFoundError(f"no checkpoint shards found in {component}")
+    return paths
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model-root", default="/hhb-data/aigc/model_zoo/MiniMaxAI_MiniMax-H3")
+    parser.add_argument("--partition", choices=("FL2VA", "Ref2VA"), required=True)
+    parser.add_argument("--component", choices=("transformer", "text_encoder", "video_vae", "audio_vae"), required=True)
+    args = parser.parse_args()
+
+    root = Path(args.model_root) / args.partition
+    specifications = {
+        "transformer": (
+            _shards(root / "transformer"),
+            MiniMaxH3DiT,
+            root / "transformer" / "config.json",
+            torch.bfloat16,
+        ),
+        "text_encoder": (
+            _shards(root / "text_encoder"),
+            MiniMaxH3Encoder,
+            root / "text_encoder",
+            torch.bfloat16,
+        ),
+        "video_vae": (
+            str(root / "video_vae" / "source" / "model.safetensors"),
+            MiniMaxH3VideoVAE,
+            root / "video_vae",
+            torch.float32,
+        ),
+        "audio_vae": (
+            str(root / "audio_vae" / "model.safetensors"),
+            MiniMaxH3AudioVAE,
+            root / "audio_vae",
+            torch.float32,
+        ),
+    }
+    checkpoint, model_class, config_path, dtype = specifications[args.component]
+    name = f"minimax_h3_{args.component}"
+    manager = ModuleManager(device="cpu", torch_dtype=dtype)
+    manager.load_model(
+        checkpoint,
+        device="cpu",
+        torch_dtype=dtype,
+        low_cpu_mem_usage=True,
+        name=name,
+        model_class=model_class,
+        converter_kwargs={"config_path": config_path},
+    )
+    model = manager.fetch_module(name)
+    if model is None:
+        raise RuntimeError(f"ModuleManager did not register {name}")
+    meta_parameters = [parameter_name for parameter_name, parameter in model.named_parameters() if parameter.is_meta]
+    if meta_parameters:
+        raise RuntimeError(f"component retained meta parameters: {meta_parameters[:5]}")
+    payload = {
+        "partition": args.partition,
+        "component": args.component,
+        "state_dict_keys": len(model.state_dict()),
+        "parameter_count": sum(parameter.numel() for parameter in model.parameters()),
+        "dtype": str(dtype),
+    }
+    print(json.dumps(payload, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()