Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Comfyui_Minimax_h3_latent_Upscaler/examples/Minimax_h3_latent_Upscaler_001.mp4 filter=lfs diff=lfs merge=lfs -text
+Comfyui_Minimax_h3_latent_Upscaler/examples/Minimax_h3_latent_Upscaler_002.jpg filter=lfs diff=lfs merge=lfs -text

Comfyui_Minimax_h3_latent_Upscaler/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

Comfyui_Minimax_h3_latent_Upscaler/README.md

@@ -0,0 +1,351 @@
+<p align="center">
+  <a href="./README.md"><strong>English</strong></a> ·
+  <a href="./README_zh.md">中文</a>
+</p>
+
+<div align="center">
+
+# ComfyUI Minimax H3 Latent Upscaler
+
+**Neural Latent Upscaler for Minimax H3 Video Generation**
+Learned · High-fidelity · 2D & 3D Variants
+
+</div>
+
+## 📰 News
+
+- [2026-08-28] 🚀 **New node combo — MMH3 Split Upscale**: three new nodes (`MMH3 Temporal Split Params`, `MMH3 Spatial Split Params`, `MMH3 Split Upscale`) perform a tiled, hires-fix style latent re-sampling upscale for H3 video. Decomposed and optimized from the **Comfyui-MMH3-UltimateUpscale** project — splitting the AV latent into temporal chunks and spatial tiles, resampling each piece, and stitching with seam denoise, two-level color matching and temporal anchors. Key upgrades vs. original: more stable seams (`seam_denoise` + probe-gated seam polish), zero color drift (two-level matching + first-block/every-chunk pin-source), triple temporal anchors (frame-0/motion/identity), easier use (spatial params simplified to overlap/fade percentages snapping to the latent grid), and a lighter footprint (built-in upscale model removed in favor of an external pre-upscaled latent).
+- [2026-08-26] 🚀 **3D node memory & UX optimizations**: zero-copy model loading plus ComfyUI's native `soft_empty_cache` and explicit `.contiguous()` calls reduce RAM/VRAM spikes during load and inference; the post-inference CPU offload is now an optional `force_unload` toggle (default on); `enable_chunking` is renamed to `enable_temporal_chunking` and its effective chunk stride raised from 24 to 32; model files can now live in subfolders (PR #30); `target dimensions` and `megapixels` upper limits raised to 8192 px and 16 MP.
+- [2026-08-23] 🚀 **3D node improvements**: added an `enable_chunking` toggle (turn off for short clips to use full-context inference); fixed temporal-chunk edge artifacts with replicate padding and weighted overlap blending, eliminating end-frame flicker; added ROCm (AMD GPU) backend support via the new `rocm` device option.
+- [2026-08-21] 🚀 **3D node optimization**: The model is automatically offloaded to CPU after execution to free VRAM for subsequent second-pass sampling; width and height are independently aligned to the align grid (default 32), fixing the bottom light band issue; normalization/denormalization is changed from in-place operations to standard operations; temporal chunking is retained to support long videos.
+- [2026-08-19] 🚀 **3D node overhaul**: all three resize modes (`scale by multiplier`, `target dimensions`, `megapixels`) merged into a single node; fixed aspect-ratio mismatch in certain modes and edge artifacts at specific sizes; added a new example workflow and expanded the usage notes.
+- [2026-08-18] 🔥 **Precision selector**: both 2D and 3D nodes now support `fp32` / `fp16` / `bf16` inference.
+- [2026-08-17] 🎉 **Initial release**: Minimax H3 Latent Upscaler 2D + 3D nodes with bilingual README and inline examples.
+
+A custom ComfyUI node that upscales **Minimax H3** VAE latents (24 channels) with a trained
+neural network instead of naive interpolation. Its main purpose is to **accelerate
+high-resolution video generation** and improve quality:
+
+- **Skip the slow decode → pixel-upscale → encode round-trip.** Minimax H3 ships a heavy
+  ~5B-parameter VAE, so decoding and re-encoding latents is expensive. Upscaling directly in
+  latent space avoids that costly round-trip entirely.
+- **Enable a faster generation pipeline:** generate at low resolution (far fewer latent tokens),
+  upscale the latent with this node, then refine at the target resolution.
+
+It also **avoids the ghosting / double-image artifacts** that naive latent interpolation
+(bilinear/bicubic) introduces, and plays a role similar to the latent upscaler in **LTX2.3**.
+
+⚠️ This saves **time, not VRAM** — the refinement pass still runs at the target resolution, so
+peak memory is comparable to generating high-res directly. The win is purely speed.
+
+Two node variants are provided, both registered under the `video/MinimaxH3` category:
+
+- **Minimax H3 Latent Upscaler (2D)** — a 2D ResBlock backbone with Temporal 3D-Conv layers
+  inserted for temporal consistency. Spatial (H×W) upscaling; the time dimension is preserved.
+  Lightweight and fast. Uses a simple `scale` factor (1.0×–4.0×).
+- **Minimax H3 Latent Upscaler (3D)** — a fully 3D-convolution backbone (3D ResBlocks +
+  TemporalConv + trilinear interpolation). Processes the spatiotemporal volume jointly for
+  stronger temporal coherence; heavier on compute/memory. Supports **three resize modes** in one
+  node:
+  - `scale by multiplier` — classic `scale` factor (1.0×–4.0×).
+  - `target dimensions` — directly set target pixel `width`/`height`.
+  - `megapixels` — set a target total pixel count in megapixels (e.g. `1.2`); keeps aspect ratio.
+  Both `target dimensions` and `megapixels` modes align the output to a configurable pixel grid and
+  derive the effective scale automatically.
+
+> The 3D node computes the equivalent `scale` internally for the size-based modes and feeds it to
+> the same trained model, so any target between 1.0×–4.0× works.
+
+> Both nodes support **upscaling only** (`effective scale >= 1.0`). `scale = 1.0` returns the input
+> unchanged; an effective scale below `1.0` raises an error.
+
+### MMH3 Split Upscale (combo)
+
+> **Origin:** this combo is a **decomposed and re-optimized version of the
+> Comfyui-MMH3-UltimateUpscale project**. The original monolithic node was broken into three composable nodes (temporal split /
+> spatial split / main upscaler), and the enhancements below were layered on top of the original tiling
+> logic to improve seam stability, color consistency, temporal coherence, usability, and footprint.
+
+A separate three-node combo that does a **tiled, hires-fix style re-sampling upscale** directly
+inside the diffusion sampler — instead of a pre-trained upscaler network. It takes the H3 **AV
+latent** (nested video 24ch + audio 32ch), splits it into **temporal chunks** and **spatial tiles**,
+runs the sampler on each piece, then stitches them back seamlessly with seam-denoise, two-level color
+matching and temporal anchors so seams and ghosting don't appear. The two `* Split Params` nodes
+configure the splitting and feed the main `MMH3 Split Upscale` node (both optional — leave them
+unconnected for a single full-frame pass). It requires a `model` + `conditioning` + `sampler`/`sigmas`,
+i.e. it re-runs sampling at the higher resolution.
+
+**Key enhancements vs. the original project:**
+
+- **🧩 More stable seams (Seam / Ghosting):** a seam-neighborhood denoise cap (`seam_denoise`) plus a probe-gated second-pass seam polish (`seam_polish`) remove seams and ghosting; even under high denoise + fast motion, moving objects are no longer sliced ("broken limbs").
+- **🎨 Zero color drift (Color Zero-Drift):** spatial + temporal two-level color matching, with a global color reference pinned to the **first block** and to **every chunk** (`grade_pin`) — eliminates inter-tile flicker and the localized cyan/green tint (e.g. top-left corner).
+- **⏱️ Stronger temporal continuity:** a **triple temporal anchor** — `frame-0 anchor` + `motion anchor` + `identity anchor` — automatically backs up identity consistency under high denoise, so subjects don't drift.
+- **🖱️ Easier to use:** spatial parameters cut from 9 fields down to **percentages** (overlap ratio / fade ratio) that auto-snap to the latent grid; `negative` sits right next to `conditioning` for a more intuitive layout.
+- **🪶 Lighter footprint:** the built-in upscale model was removed in favor of an **external pre-upscaled latent** input — more controllable VRAM, and a node that stays focused on its job.
+
+**Modules added / optimized (relative to the original project):**
+
+| Module | What it adds / optimizes |
+| :--- | :--- |
+| **Prevention (预防)** | Freeze-prefill overlap band + **triple temporal anchors** (frame-0 anchor + motion anchor + identity anchor) + cross-fade stitching — stops seams and forks from forming in the first place. |
+| **Correction (校正)** | **Two-level (spatial + temporal) color matching** + first-block source reference + per-chunk global pin-source (`grade_pin`) — keeps color & brightness consistent across tiles and chunks, killing inter-tile flicker and localized cyan/green tint. |
+| **Anti-forking (抗分叉)** | `seam_denoise` cap — under high denoise + fast motion, the seam neighborhood is re-sampled at *medium* denoise so moving objects aren't sliced ("broken limbs"); combined with the probe-gated second-pass seam polish, seams and ghosting are both eliminated (suggested 0.5–0.8; 1.0 = off). |
+| **Fixes (修复)** | **Per-tile independent Guider** + cropped keyframes, and a **fixed probe-gated seam polish** (`seam_polish`) — each tile gets correctly-scoped conditioning/keyframes, and the polish gating no longer over/under-applies. |
+| **Simplification (简化)** | `overlap` / `fade` are now **percentage parameters** (overlap ratio / fade ratio, resolution-independent) instead of absolute pixels, and auto-snap to the latent grid; `negative` sits next to `conditioning` for a more intuitive layout. |
+
+---
+
+## 📸 Examples
+
+**Video upscale comparison**
+
+<video src="examples/Minimax_h3_latent_Upscaler_001.mp4" controls width="640"></video>
+
+**Image upscale comparison**
+
+![](examples/Minimax_h3_latent_Upscaler_002.jpg)
+
+---
+
+## 📁 Project Structure
+
+```text
+Comfyui_Minimax_h3_latent_Upscaler/
+├── examples/
+│   ├── Minimax_h3_latent_Upscaler_001.mp4
+│   └── Minimax_h3_latent_Upscaler_002.jpg
+├── workflow_templates/
+│   └── minimax_h3_r2v_Latent Upscaler example workflow.json  # example workflow for ComfyUI templates
+├── nodes/
+│   ├── __init__.py                       # merges 2D/3D/Split node mappings
+│   ├── minimax_h3_latent_upscaler_2d.py  # 2D backbone + Temporal 3D Conv (scale mode)
+│   ├── minimax_h3_latent_upscaler_3d.py  # pure 3D convolution with 3 resize modes
+│   └── MMH3_Split_Upscale.py             # MMH3 Split Upscale combo (decomposed from Comfyui-MMH3-UltimateUpscale)
+├── README.md
+├── README_zh.md
+└── __init__.py
+```
+
+> The model weights are **not** included in this repo. Place them in your ComfyUI models folder
+> (see Model Placement below).
+
+---
+
+## 🚀 Key Features
+
+- ✅ **Learned latent upscaling** — neural network trained for Minimax H3 latents, far sharper
+  than bilinear/bicubic interpolation.
+- ✅ **Two backbones** — pick the fast **2D** variant or the temporally-coherent **3D** variant.
+- ✅ **Three ways to set output size on the 3D node** — `scale by multiplier`, `target dimensions`,
+  or `megapixels`, all with pixel-grid alignment and aspect-ratio lock.
+- ✅ **Tiled hires-fix upscaler (MMH3 Split Upscale combo)** — re-sample the H3 AV latent at higher
+  resolution by splitting into temporal chunks + spatial tiles, with seam-denoise, two-level color
+  matching and temporal anchors to avoid seams and ghosting.
+- ✅ **24-channel Minimax H3 latent** — uses the exact per-channel mean/std normalization from
+  training.
+- ✅ **Auto architecture detection** — reads `in_channels`, block counts, temporal config and
+  kernel size straight from the checkpoint; no manual config needed.
+- ✅ **Robust weight loader** — supports `.safetensors` and `.pth`; auto-converts FP8→FP16;
+  tolerates the `upscaler.` prefix in merged checkpoints.
+- ✅ **Flexible precision/device** — `cuda`/`cpu` and fp32/fp16/bf16 options.
+- ✅ **Plug-and-play** — standard ComfyUI node, no changes to your existing workflow.
+
+Inference forces attention **off** (`attn=False`) for speed and stability. Loaded models are
+cached by `(name, device, precision)` so repeated runs stay cheap.
+
+---
+
+## 📦 Installation
+
+1. Clone this repository into ComfyUI's `custom_nodes` folder:
+
+   ```bash
+   cd ComfyUI/custom_nodes
+   git clone https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler.git
+   ```
+
+2. Required dependencies (`torch`, `einops`, `safetensors`) are already present in a standard
+   ComfyUI environment — no extra install needed.
+
+3. Restart ComfyUI.
+
+---
+
+## 🤖 Model Placement
+
+The nodes scan and load weights from:
+
+```text
+ComfyUI/models/latent_upscale_models/
+```
+
+Put your Minimax H3 latent upscaler checkpoint (`.safetensors` or `.pth`) there. It will appear
+automatically in the node's `model_name` dropdown.
+
+Pre-trained checkpoints are available at:
+[huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler)
+
+The loader auto-detects the architecture, so a single checkpoint works for both the 2D and 3D
+nodes as long as the stored structure matches.
+
+---
+
+## 🧩 Usage
+
+Add the node you need from the `video/MinimaxH3` menu, connect a `LATENT`, pick the model, set the
+resize mode / scale, and decode.
+
+**Typical workflow:**
+- **Quick preview:** `[Minimax H3 Latent] → [H3 Latent Upscaler] → [VAE Decode]`
+- **High quality / time-saving (recommended):** `[Low-res Latent] → [H3 Latent Upscaler] → [Refine / Re-sample] → [VAE Decode]`
+
+Compared to the naive approach `[Latent] → [VAE Decode] → [Pixel Upscaler] → [VAE Encode] → …`,
+upscaling directly in latent space skips the expensive VAE decode/encode round-trip. Minimax H3's
+~5B-parameter VAE makes decode and re-encode notably slow, so this is where most of the time is
+saved. It also avoids the **ghosting / double-image artifacts** that direct latent interpolation
+(bilinear/bicubic) causes.
+
+⚠️ **Saves time, not VRAM:** the refinement still runs at the target resolution, so peak memory is
+roughly the same as generating high-res directly. The benefit is purely faster turnaround.
+
+### Node Reference — 2D
+
+| Parameter | Type | Default | Range / Options | Description |
+| :--- | :--- | :--- | :--- | :--- |
+| `latent` | LATENT | — | — | Input Minimax H3 latent (B,C,T,H,W) or (B,C,H,W) |
+| `model_name` | dropdown | auto | scanned files | Checkpoint in `latent_upscale_models/` |
+| `scale` | FLOAT | 2.0 | 1.0 – 4.0 (step 0.1) | Spatial upscale factor |
+| `device` | dropdown | cuda | cuda / cpu | Inference device |
+| `precision` | dropdown | fp32 | fp32 / fp16 / bf16 | Inference precision |
+
+**Output:** `LATENT` — the upscaled latent, ready for VAE decode.
+
+### Node Reference — 3D
+
+| Parameter | Type | Default | Range / Options | Description |
+| :--- | :--- | :--- | :--- | :--- |
+| `latent` | LATENT | — | — | Input Minimax H3 latent (B,C,T,H,W) or (B,C,H,W) |
+| `model_name` | dropdown | auto | scanned files | Checkpoint in `latent_upscale_models/` |
+| `mode` | dropdown | `scale by multiplier` | `scale by multiplier` / `target dimensions` / `megapixels` | How the output size is chosen |
+| `scale` | FLOAT | 2.0 | 1.0 – 4.0 (step 0.05) | Used when `mode` is `scale by multiplier` |
+| `width` | INT | 1280 | 64 – 8192 (step 8) | Target pixel width (used by `target dimensions`) |
+| `height` | INT | 704 | 64 – 8192 (step 8) | Target pixel height (used by `target dimensions`) |
+| `megapixels` | FLOAT | 1.0 | 0.1 – 16.0 (step 0.1) | Target total megapixels (used by `megapixels`); keeps aspect ratio |
+| `align` | INT | 32 | 1 – 512 | Pixel-grid alignment: output W/H are independently rounded to multiples of this value (e.g. 16/32/64) |
+| `enable_temporal_chunking` | BOOLEAN | True | True / False | Split long videos into temporal chunks to cap VRAM; disable for short clips for full-context inference |
+| `force_unload` | BOOLEAN | True | True / False | Unload model to CPU after inference to free VRAM for subsequent nodes; disable if you reuse this node repeatedly to avoid reload overhead |
+| `device` | dropdown | cuda | cuda / rocm / cpu | Inference backend (ROCm needs a HIP-enabled PyTorch build) |
+| `precision` | dropdown | fp32 | fp32 / fp16 / bf16 | Inference precision |
+
+**Output:** `LATENT` — the upscaled latent.
+
+> **Which node to pick?** Use **2D** for speed and when frames are already temporally stable; use
+> **3D** when you need stronger motion/temporal coherence or prefer specifying output size by
+> `target dimensions` / `megapixels`.
+
+### Node Reference — MMH3 Split Upscale (combo)
+
+A tiled, **hires-fix style** re-sampling upscaler for H3 video, **decomposed and optimized from the
+Comfyui-MMH3-UltimateUpscale project**. Unlike the 2D/3D nodes (which use a
+pre-trained upscaler network), this combo re-runs the diffusion sampler on a higher-resolution
+version of the latent, split into pieces so it fits in VRAM. It operates on the H3 **AV latent**
+(nested video 24ch + audio 32ch) and requires `model` + `conditioning` + `sampler`/`sigmas`.
+
+**`MMH3 Temporal Split Params`** — how to cut the clip along time (H3's native 5+17·m frame/token grid):
+
+| Parameter | Type | Default | Range / Options | Description |
+| :--- | :--- | :--- | :--- | :--- |
+| `chunk_frames` | INT | 73 | 5 – 100000 | Chunk length in frames (snapped to H3 token grid) |
+| `temporal_overlap_frames` | INT | 22 | 0 – 100000 | Overlap between consecutive chunks |
+| `anchor_strength` | FLOAT | 0.999 | 0.0 – 1.0 | Temporal anchor strength |
+| `motion_anchor_frames` | dropdown | 22 | 0 / 5 / 22 / 39 | Motion anchor length in frames |
+| `identity_anchor_frames` | INT | 24 | 0 – 240 | Spacing of identity anchors |
+
+Output: `temporal_split_param` (custom type, feeds the main node).
+
+**`MMH3 Spatial Split Params`** — how to cut each frame into tiles:
+
+| Parameter | Type | Default | Range / Options | Description |
+| :--- | :--- | :--- | :--- | :--- |
+| `tile_width` | INT | 512 | 64 – 16384 (step 32) | Tile width in pixels |
+| `tile_height` | INT | 512 | 64 – 16384 (step 32) | Tile height in pixels |
+| `overlap_ratio` | FLOAT | 0.25 | 0.0 – 0.90 | Overlap as a fraction of the tile |
+| `fade_ratio` | FLOAT | 0.50 | 0.0 – 1.0 | Fade band width within the overlap |
+| `min_tile_size` | INT | 256 | 0 – 16384 (step 32) | Minimum tile edge; avoids tiny edge tiles |
+| `seam_denoise` | FLOAT | 1.0 | 0.1 – 1.0 | Seam-neighborhood denoise cap; <1 prevents fast objects being cut at seams (suggest 0.5–0.8) |
+
+Outputs: `spatial_split_param` (custom type) + `grid_preview` (string, shows the computed tile/overlap grid).
+
+**`MMH3 Split Upscale`** — the main orchestrator:
+
+| Parameter | Type | Default | Range / Options | Description |
+| :--- | :--- | :--- | :--- | :--- |
+| `model` | MODEL | — | — | Diffusion model used for re-sampling |
+| `conditioning` | CONDITIONING | — | — | Positive conditioning |
+| `negative` | CONDITIONING | — | optional | Negative conditioning |
+| `latent` | LATENT | — | — | Input H3 AV latent (nested video 24ch + audio 32ch); batch 1 only |
+| `noise` | NOISE | — | — | Noise source for the sampler |
+| `sampler` | SAMPLER | — | — | Sampler |
+| `sigmas` | SIGMAS | — | — | Sigma schedule |
+| `cfg` | FLOAT | 1.0 | 0.0 – 100.0 | Classifier-free guidance scale |
+| `temporal_split_param` | custom | — | optional | From `MMH3 Temporal Split Params` |
+| `spatial_split_param` | custom | — | optional | From `MMH3 Spatial Split Params` |
+| `seam_polish` | dropdown | off | off / auto / all | Extra de-seam pass on detected seams |
+| `color_match` | BOOLEAN | True | True / False | Two-level color matching across tiles/chunks |
+
+**Output:** `LATENT` — the upscaled H3 AV latent, ready for VAE decode.
+
+> **Notes:** Both `* Split Params` nodes are optional — leave them unconnected for a single
+> full-frame pass (no temporal/spatial splitting). The combo re-runs the sampler at the higher
+> resolution, so it trades extra compute for VRAM headroom on long / high-res clips.
+
+---
+
+## 🧪 Model / Architecture
+
+- **Latent format:** 24-channel Minimax H3 VAE latent, normalized per-channel with the training
+  mean/std before inference and de-normalized after.
+- **Default detected architecture** (overridden automatically if the checkpoint differs):
+  `in_channels=24`, `in_blocks=12`, `out_blocks=12`, `base_channels=512`, `dropout=0.1`,
+  `temporal_every=2`, `temporal_kernel=5`, `attn=False`.
+- **Interpolation:** the 2D node uses bilinear feature interpolation; the 3D node uses trilinear.
+- **Temporal handling:** both variants preserve the time dimension (only H×W are scaled).
+
+---
+
+## 📊 Training Data
+
+The upscaler was trained on **~80,000 paired samples** (a low-resolution latent paired with its
+high-resolution target), balanced across modalities and scale factors to maximize generalization.
+
+**By data modality:**
+
+| Modality | Pairs | Share |
+| :--- | :--- | :--- |
+| Video clips | ~70,000 | ~87.5% |
+| 2K images | ~8,000 | ~10% |
+
+**By upscale factor (scale distribution, approximate):**
+
+| Scale | Share | Note |
+| :--- | :--- | :--- |
+| 2× | 40% | Dominant factor — the most common real-world case |
+| 1.5× | 10% | — |
+| 2.5× | 10% | — |
+| 3× | 10% | — |
+| 4× | 10% | — |
+| 1.0×–4.0× (arbitrary decimals) | 10% | Improves generalization to in-between / non-fixed scales |
+
+The heavy emphasis on **2× (40%)** matches the most common practical use case, while the **10% spread
+of arbitrary decimal scales between 1 and 4** prevents overfitting to the fixed 1.5×/2×/2.5×/3×/4×
+buckets — letting the model handle any continuous `scale` in the 1.0×–4.0× range at inference time.
+
+---
+
+## 🙏 Acknowledgments
+
+This node follows the neural-latent-upscaling approach pioneered by
+[ComfyUi_NNLatentUpscale](https://github.com/Ttl/ComfyUi_NNLatentUpscale) by **Ttl**
+(https://github.com/Ttl). The model architecture also draws on and references the
+**LTX 2.3 Spatial Upscaler** (`ltx-2.3-spatial-upscaler-x2-1.1.safetensors`).
+Thanks to both projects for the open-source foundation this work builds upon.

Comfyui_Minimax_h3_latent_Upscaler/README_zh.md

@@ -0,0 +1,321 @@
+<p align="center">
+  <a href="./README.md">English</a> ·
+  <a href="./README_zh.md"><strong>中文</strong></a>
+</p>
+
+<div align="center">
+
+# ComfyUI Minimax H3 Latent Upscaler
+
+**Minimax H3 视频生成专用 Latent 神经网络放大节点**
+学习型 · 高保真 · 2D 与 3D 双版本
+
+</div>
+
+## 📰 更新动态
+
+- [2026-08-28] 🚀 **新增组合节点 — MMH3 Split Upscale**：新增三个节点（`MMH3 Temporal Split Params`、`MMH3 Spatial Split Params`、`MMH3 Split Upscale`），对 H3 视频做**分块式「高清重采样」放大**。该组合是在 **Comfyui-MMH3-UltimateUpscale** 项目基础上拆解优化而来——把 AV latent 沿时间切块、沿空间分块，逐块重采样后再无缝拼接；相比原版主要增强：更稳的拼接（`seam_denoise` + probe 门控二道缝修补）、颜色零漂移（空间+时间两级颜色匹配 + 首块/每 chunk 钉源）、三重时间锚（frame-0 / motion / identity）、更易用（空间参数简化为重叠率/渐变率百分比并自动吸附网格）、更轻量（移除内置放大模型，改接外部预放大 latent）。
+- [2026-08-26] 🚀 **3D 节点显存与使用优化**：采用零拷贝模型加载，并接入 ComfyUI 原生 `soft_empty_cache` 与显式 `.contiguous()`，降低加载与推理期间的显存/内存峰值；推理后卸载到 CPU 改为可选开关 `force_unload`（默认开启）；`enable_chunking` 更名为 `enable_temporal_chunking`，分块有效帧数由 24 提升至 32；模型文件现可放入子目录（PR #30）；`target dimensions` 与 `megapixels` 上限分别放宽到 8192 像素与 16 MP。
+- [2026-08-23] 🚀 **3D 节点改进**：新增 `enable_chunking` 开关（短片段可关闭，使用全上下文推理）；修复时间分块边缘伪影——采用 Replicate Padding 与重叠区域加权融合，消除末尾帧闪烁；新增 ROCm（AMD 显卡）后端支持，设备选项新增 `rocm`。
+- [2026-08-21] 🚀 **3D 节点优化**：节点执行后自动将模型卸载到 CPU，为后续二次采样释放显存；宽高分别独立对齐到 `align` 网格（默认 32），修复底部光带问题；归一化/反归一化由原地操作改为标准运算，保留时间分块以支持长视频。
+- [2026-08-19] 🚀 **3D 节点重构**：三种缩放模式（`scale by multiplier`、`target dimensions`、`megapixels`）合并进单一节点；修复特定模式下造成的比例不统一，修复各类特定尺寸造成的边缘伪影；新增示例工作流供参考。
+- [2026-08-18] 🔥 **精度选择**：2D / 3D 节点均支持 `fp32` / `fp16` / `bf16` 推理。
+- [2026-08-17] 🎉 **初始发布**：Minimax H3 Latent Upscaler 2D + 3D 双节点、双语 README、内联示例。
+
+一个 ComfyUI 自定义节点，用训练好的神经网络（而非简单插值）对 **Minimax H3** 的 VAE latent
+（24 通道）进行放大。它的**主要目的是加速高分辨率视频的生成**，并提升画质：
+
+- **跳过「解码 → 像素放大 → 再编码」的慢速往返。** Minimax H3 自带约 5B 参数的笨重 VAE，
+  对 latent 做解码和再编码都很耗时；直接在 latent 空间放大，就彻底省掉了这一往返开销。
+- **支持更快的生成流程：** 先低分辨率生成（latent token 少得多），用本节点放大 latent，再在
+  目标分辨率下二次采样 / 重绘精修。
+
+同时，它**避免了直接对 latent 插值（双线性/双三次）带来的鬼影、重影问题**，作用类似于
+**LTX2.3** 中的 latent 放大模型。
+
+⚠️ 它节省的是**时间，不是显存** —— 精修阶段仍在目标分辨率下运行，峰值显存与直接高清生成接近，
+收益纯粹是更快出片。
+
+提供两个节点变体，均注册在 `video/MinimaxH3` 分类下：
+
+- **Minimax H3 Latent Upscaler (2D)**：2D 残差主干 + 穿插的时序 3D 卷积，仅做空间（H×W）放大，
+  时间维度保持不变，轻量且快速。使用简单的 `scale` 倍数（1.0×–4.0×）。
+- **Minimax H3 Latent Upscaler (3D)**：纯 3D 卷积主干（3D 残差块 + 时序卷积 + 三线性插值），
+  联合处理时空体，时间一致性更强，但算力/显存开销更高。一个节点内置**三种缩放模式**：
+  - `scale by multiplier`：经典 `scale` 倍数（1.0×–4.0×）。
+  - `target dimensions`：直接填目标像素 `width` / `height`。
+  - `megapixels`：填目标总像素（百万像素，例如 `1.2`），保持原宽高比。
+  `target dimensions` 与 `megapixels` 两种模式会按可配置的像素网格对齐输出，并自动反推等效倍率。
+
+> 3D 节点在尺寸模式下会在内部计算出等效 `scale` 并喂给同一个训练好的模型，因此 1.0×–4.0× 之间
+> 任意目标都能用。
+
+> 两个节点均**只支持放大**（等效 `scale >= 1.0`）。`scale = 1.0` 返回输入原样；等效倍率小于 1.0 会报错。
+
+### MMH3 Split Upscale（组合节点）
+
+> **来源：** 该组合是在 **Comfyui-MMH3-UltimateUpscale** 项目���础上**拆解优化**而来。原本的单节点被拆成三个可组合节点（时间切分 / 空间切分 / 主放大），
+> 并在原有分块逻辑之上，针对拼接稳定性、色彩一致性、时间连续性、易用性与轻量化做了系统性增强。
+
+一套独立的**三节点组合**，在扩散采样器内部做**分块式「高清重采样」放大**（而非用预训练放大网络）。
+它接收 H3 的 **AV latent**（嵌套：视频 24 通道 + 音频 32 通道），沿**时间切块**、沿**空间分块**，
+对每一块单独跑采样器，再用缝降噪、两级颜色匹配与时间锚点把结果**无缝拼接**回去，避免出现接缝和鬼影。
+两个 `* Split Params` 节点负责配置切分方式，并喂给主节点 `MMH3 Split Upscale`（两者均可选——
+不连接即为整段/整帧单次处理）。它需要 `model` + `conditioning` + `sampler`/`sigmas`，即会在更高
+分辨率上重新跑一遍采样。
+
+**相比原版主要增强（拆解优化点）：**
+
+- **🔧 更稳的拼接（Seam / Ghosting）**：缝邻域降噪上限（`seam_denoise`）+ probe 门控的**二道缝修补**（`seam_polish`），消除接缝与鬼影；在高降噪 + 快速运动下，运动物体也不再被切断（"断肢"）。
+- **🎨 颜色零漂移（Color Zero-Drift）**：**空间 + 时间两级颜色匹配**，并对**首块**与**每个 chunk** 做全局色基准钉源（`grade_pin`），彻底解决块间闪烁、左上角发青等问题。
+- **⏱️ 更强的时间连续性（Temporal Continuity）**：`frame-0 锚` + `motion 锚` + `identity 锚` **三重时间锚**，高降噪时自动兜底身份一致性，人物不漂移。
+- **🧩 更易用（Usability）**：空间参数由原本的 9 项精简为**百分比**（重叠率 / 渐变率），并自动吸附 latent 网格；`negative` 紧跟 `conditioning` 布局，连线更直观。
+- **🪶 更轻量（Lightweight）**：移除内置放大模型，改接**外部预放大 latent**，显存更可控、节点更专注。
+
+**新增 / 优化的模块（相对于原项目）：**
+
+| 模块 | 新增 / 优化的内容 |
+| :--- | :--- |
+| **预防（Prevention）** | 冻结预填重叠带 + **三重时间锚**（frame-0 锚 + motion 锚 + identity 锚）+ cross-fade 拼接——让接缝与分叉在生成之初就不出现。 |
+| **校正（Correction）** | **空间/时间两级颜色匹配** + 首块源参考 + 每块（chunk）全局钉源（`grade_pin`）——保证各瓦片、各时间块之间的色彩与亮度一致，杜绝块间闪烁与局部发青。 |
+| **抗分叉（Anti-forking）** | `seam_denoise` 上限——在高降噪 + 快速运动下，缝邻域以*中等*降噪续写邻居内容，防止运动物体被切断（"断肢"）；配合 probe 门控的二道缝修补，接缝与鬼影一并消除（建议 0.5–0.8；1.0 = 关闭）。 |
+| **修复（Fixes）** | **每瓦片独立 Guider** + 裁剪 keyframes，以及**修复版 probe 门控去缝**（`seam_polish`）——每个瓦片获得正确作用域的条件/关键帧，去缝门控不再过度或不足。 |
+| **简化（Simplification）** | `overlap` / `fade` 改为**百分比参数**（重叠率 / 渐变率，与分辨率无关），替代原来的绝对像素值，并自动吸附 latent 网格；`negative` 紧跟 `conditioning`，布局更直观。 |
+
+---
+
+## 📸 示例
+
+**视频放大对比**
+
+<video src="examples/Minimax_h3_latent_Upscaler_001.mp4" controls width="640"></video>
+
+**图像放大对比**
+
+![](examples/Minimax_h3_latent_Upscaler_002.jpg)
+
+---
+
+## 📁 项目结构
+
+```text
+Comfyui_Minimax_h3_latent_Upscaler/
+├── examples/
+│   ├── Minimax_h3_latent_Upscaler_001.mp4
+│   └── Minimax_h3_latent_Upscaler_002.jpg
+├── workflow_templates/
+│   └── minimax_h3_r2v_Latent Upscaler example workflow.json  # ComfyUI 模板示例工作流
+├── nodes/
+│   ├── __init__.py                       # 合并 2D/3D/组合节点映射
+│   ├── minimax_h3_latent_upscaler_2d.py  # 2D 主干 + Temporal 3D Conv（倍数模式）
+│   ├── minimax_h3_latent_upscaler_3d.py  # 纯 3D 卷积，支持 3 种缩放模式
+│   └── MMH3_Split_Upscale.py             # MMH3 Split Upscale 组合（基于 Comfyui-MMH3-UltimateUpscale 拆解优化）
+├── README.md
+├── README_zh.md
+└── __init__.py
+```
+
+> 模型权重**不**随仓库提供，请按下方「模型放置」说明放入 ComfyUI 模型目录。
+
+---
+
+## 🚀 核心特性
+
+- ✅ **学习型 latent 放大** — 针对 Minimax H3 latent 训练的神经网络，比双线性/双三次插值清晰得多。
+- ✅ **两种主干** — 追求速度选轻量的 **2D** 版，追求时间一致性选 **3D** 版。
+- ✅ **3D 节点三种输出尺寸方式** — 支持 `scale by multiplier` / `target dimensions` /
+  `megapixels`，均带像素网格对齐与宽高比锁定。
+- ✅ **分块式高清重采样（MMH3 Split Upscale 组合）** — 把 H3 的 AV latent 沿时间切块 + 空间分块，
+  在更高分辨率上重采样，配合缝降噪、两级颜色匹配与时间锚点，避免接缝与鬼影。
+- ✅ **24 通道 Minimax H3 latent** — 使用训练时一致的逐通道均值/标准差做归一化。
+- ✅ **自动识别模型结构** — 直接从权重读取通道数、块数、时序配置与卷积核大小，无需手动配置。
+- ✅ **鲁棒的权重加载器** — 支持 `.safetensors` 与 `.pth`；自动 FP8→FP16；兼容合并权重中的
+  `upscaler.` 前缀。
+- ✅ **可选精度与设备** — `cuda`/`cpu` 与 fp32/fp16/bf16 选项。
+- ✅ **即插即用** — 标准 ComfyUI 节点，不改变现有工作流。
+
+推理时强制关闭注意力（`attn=False`）以提升速度与稳定性；已加载模型按 `(名称, 设备, 精度)`
+缓存，重复调用开销很低。
+
+---
+
+## 📦 安装
+
+1. 将仓库克隆到 ComfyUI 的 `custom_nodes` 文件夹：
+
+   ```bash
+   cd ComfyUI/custom_nodes
+   git clone https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler.git
+   ```
+
+2. 所需依赖（`torch`、`einops`、`safetensors`）在标准 ComfyUI 环境中已自带，无需额外安装。
+
+3. 重启 ComfyUI。
+
+---
+
+## 🤖 模型放置
+
+节点从这里扫描并加载权重：
+
+```text
+ComfyUI/models/latent_upscale_models/
+```
+
+把你的 Minimax H3 latent 放大模型权重（`.safetensors` 或 `.pth`）放进该目录，节点下拉框会自动列出。
+
+预训练权重可在此下载：
+[huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler)
+
+加载器会自动识别结构，只要权重存储的结构匹配，2D 与 3D 节点可共用同一份权重。
+
+---
+
+## 🧩 使用方法
+
+从 `video/MinimaxH3` 菜单中添加所需节点，连入一个 `LATENT`，选择模型、设置缩放模式/参数，再解码即可。
+
+**典型流程：**
+- **快速预览：** `[Minimax H3 Latent] → [H3 Latent Upscaler] → [VAE 解码]`
+- **高品质 / 省时（推荐）：** `[低清 Latent] → [H3 Latent Upscaler] → [二次采样重绘/精修] → [VAE 解码]`
+
+相比「[Latent] → [VAE 解码] → [像素放大] → [VAE 编码] → …」这种朴素做法，直接在 latent 空间
+放大跳过了昂贵的 VAE 解码/编码往返。Minimax H3 的约 5B 参数 VAE 让解码与再编码都明显偏慢，时间
+主要就省在这里。同时也避免了直接对 latent 插值（双线性/双三次）造成的**鬼影 / 重影**问题。
+
+⚠️ **省时间，不省显存：** 精修仍在目标分辨率下运行，峰值显存与直接高清生成接近，收益纯粹是更快出片。
+
+### 节点参数 — 2D
+
+| 参数 | 类型 | 默认值 | 范围 / 选项 | 说明 |
+| :--- | :--- | :--- | :--- | :--- |
+| `latent` | LATENT | — | — | 输入的 Minimax H3 latent（(B,C,T,H,W) 或 (B,C,H,W)） |
+| `model_name` | 下拉框 | 自动 | 扫描到的文件 | `latent_upscale_models/` 中的模型 |
+| `scale` | FLOAT | 2.0 | 1.0 – 4.0（步进 0.1） | 空间放大倍数 |
+| `device` | 下拉框 | cuda | cuda / cpu | 推理设备 |
+| `precision` | 下拉框 | fp32 | fp32 / fp16 / bf16 | 推理精度 |
+
+**输出：** `LATENT` — 放大后的 latent，可直接送 VAE 解码。
+
+### 节点参数 — 3D
+
+| 参数 | 类型 | 默认值 | 范围 / 选项 | 说明 |
+| :--- | :--- | :--- | :--- | :--- |
+| `latent` | LATENT | — | — | 输入的 Minimax H3 latent（(B,C,T,H,W) 或 (B,C,H,W)） |
+| `model_name` | 下拉框 | 自动 | 扫描到的文件 | `latent_upscale_models/` 中的模型 |
+| `mode` | 下拉框 | `scale by multiplier` | `scale by multiplier` / `target dimensions` / `megapixels` | 输出尺寸选择方式 |
+| `scale` | FLOAT | 2.0 | 1.0 – 4.0（步进 0.05） | `mode` 为 `scale by multiplier` 时使用 |
+| `width` | INT | 1280 | 64 – 8192（步进 8） | 目标像素宽（`target dimensions` 使用） |
+| `height` | INT | 704 | 64 – 8192（步进 8） | 目标像素高（`target dimensions` 使用） |
+| `megapixels` | FLOAT | 1.0 | 0.1 – 16.0（步进 0.1） | 目标总百万像素（`megapixels` 使用），保持宽高比 |
+| `align` | INT | 32 | 1 – 512 | 像素网格对齐：输出 W/H 会分别独立取整到该值的倍数（如 16/32/64） |
+| `enable_temporal_chunking` | BOOLEAN | True | True / False | 长视频时间分块以压低显存峰值；短片段可关闭，使用全上下文推理 |
+| `force_unload` | BOOLEAN | True | True / False | 推理后将模型卸载到 CPU，为后续节点释放显存；若重复使用本节点可关闭，避免重复加载开销 |
+| `device` | 下拉框 | cuda | cuda / rocm / cpu | 推理后端（ROCm 需要支持 HIP 的 PyTorch 构建） |
+| `precision` | 下拉框 | fp32 | fp32 / fp16 / bf16 | 推理精度 |
+
+**输出：** `LATENT` — 放大后的 latent。
+
+> **选哪个节点？** 帧间已较稳定、求快时选 **2D**；需要更强运动/时间一致性，或想直接按目标
+> 像素/百万像素出图，选 **3D**。
+
+### 节点参数 — MMH3 Split Upscale（组合）
+
+一套**分块式「高清重采样」**的 H3 视频放大方案，**在 Comfyui-MMH3-UltimateUpscale 项目基础上拆解优化而来**。和 2D/3D 节点（用预训练放大网络）不同，这套组合会在
+latent 的更高分辨率版本上重跑扩散采样器，并切块以适配显存。它操作的是 H3 的 **AV latent**
+（嵌套：视频 24 通道 + 音频 32 通道），需要 `model` + `conditioning` + `sampler`/`sigmas`。
+
+**`MMH3 Temporal Split Params`** — 沿时间怎么切（对齐 H3 原生的 5+17·m 帧/token 网格）：
+
+| 参数 | 类型 | 默认值 | 范围 / 选项 | 说明 |
+| :--- | :--- | :--- | :--- | :--- |
+| `chunk_frames` | INT | 73 | 5 – 100000 | 每块帧数（自动对齐 H3 token 网格） |
+| `temporal_overlap_frames` | INT | 22 | 0 – 100000 | 相邻块之间的重叠帧数 |
+| `anchor_strength` | FLOAT | 0.999 | 0.0 – 1.0 | 时间锚强度 |
+| `motion_anchor_frames` | 下拉框 | 22 | 0 / 5 / 22 / 39 | 运动锚长度（帧） |
+| `identity_anchor_frames` | INT | 24 | 0 – 240 | 身份锚间距 |
+
+输出：`temporal_split_param`（自定义类型，喂给主节点）。
+
+**`MMH3 Spatial Split Params`** — 每帧怎么切瓦片：
+
+| 参数 | 类型 | 默认值 | 范围 / 选项 | 说明 |
+| :--- | :--- | :--- | :--- | :--- |
+| `tile_width` | INT | 512 | 64 – 16384（步进 32） | 瓦片宽（像素） |
+| `tile_height` | INT | 512 | 64 – 16384（步进 32） | 瓦片高（像素） |
+| `overlap_ratio` | FLOAT | 0.25 | 0.0 – 0.90 | 重叠占比（占瓦片） |
+| `fade_ratio` | FLOAT | 0.50 | 0.0 – 1.0 | 重叠区内的渐变带宽度 |
+| `min_tile_size` | INT | 256 | 0 – 16384（步进 32） | 最小瓦片边长；避免边缘出现极小瓦片 |
+| `seam_denoise` | FLOAT | 1.0 | 0.1 – 1.0 | 缝邻域降噪上限；<1 时高降噪下防止快速物体被切断（建议 0.5–0.8） |
+
+输出：`spatial_split_param`（自定义类型）+ `grid_preview`（字符串，显示计算出的瓦片/重叠网格）。
+
+**`MMH3 Split Upscale`** — 主调度节点：
+
+| 参数 | 类型 | 默认值 | 范围 / 选项 | 说明 |
+| :--- | :--- | :--- | :--- | :--- |
+| `model` | MODEL | — | — | 用于重采样的扩散模型 |
+| `conditioning` | CONDITIONING | — | — | 正向条件 |
+| `negative` | CONDITIONING | — | 可选 | 负向条件 |
+| `latent` | LATENT | — | — | 输入的 H3 AV latent（嵌套：视频 24 通道 + 音频 32 通道）；仅支持 batch 1 |
+| `noise` | NOISE | — | — | 采样器用的噪声源 |
+| `sampler` | SAMPLER | — | — | 采样器 |
+| `sigmas` | SIGMAS | — | — | 调度序列（sigma schedule） |
+| `cfg` | FLOAT | 1.0 | 0.0 – 100.0 | 无分类器引导强度 |
+| `temporal_split_param` | 自定义 | — | 可选 | 来自 `MMH3 Temporal Split Params` |
+| `spatial_split_param` | 自定义 | — | 可选 | 来自 `MMH3 Spatial Split Params` |
+| `seam_polish` | 下拉框 | off | off / auto / all | 对检测到的接缝额外做去缝处理 |
+| `color_match` | BOOLEAN | True | True / False | 跨瓦片/块的两级颜色匹配 |
+
+**输出：** `LATENT` — 放大后的 H3 AV latent，可直接送 VAE 解码。
+
+> **注意：** 两个 `* Split Params` 节点都可不接（即为整段/整帧单次处理，不做时间/空间切分）。
+> 该组合会在更高分辨率上重跑采样器，因此以额外算力换取长视频 / 高分辨率下的显存余量。
+
+---
+
+## 🧪 模型与架构
+
+- **Latent 格式：** 24 通道 Minimax H3 VAE latent，推理前按训练均值/标准差逐通道归一化，推理后反归一化。
+- **默认检测结构**（若权重不同会被自动覆盖）：`in_channels=24`、`in_blocks=12`、
+  `out_blocks=12`、`base_channels=512`、`dropout=0.1`、`temporal_every=2`、
+  `temporal_kernel=5`、`attn=False`。
+- **插值方式：** 2D 节点用双线性特征插值；3D 节点用三线性插值。
+- **时间处理：** 两个节点均保持时间长度不变，仅放大空间分辨率（H×W）。
+
+---
+
+## 📊 训练数据
+
+该放大模型在**近 8 万对样本**上训练（低分辨率 latent 与高分辨率目标配对），并在数据类型与缩放倍数上做了均衡，以提升泛化能力。
+
+**按数据类型：**
+
+| 数据类型 | 对数 | 占比 |
+| :--- | :--- | :--- |
+| 视频素材 | 约 70,000 对 | 约 87.5% |
+| 2K 图像 | 约 8,000 对 | 约 10% |
+
+**按缩放倍数（占比，约）：**
+
+| 倍数 | 占比 | 说明 |
+| :--- | :--- | :--- |
+| 2× | 40% | 主力倍数 —— 最常见的实际使用场景 |
+| 1.5× | 10% | — |
+| 2.5× | 10% | — |
+| 3× | 10% | — |
+| 4× | 10% | — |
+| 1.0×–4.0×（任意小数位） | 10% | 增强对中间任意倍数的泛化能力 |
+
+重点放在 **2×（40%）**，对应最常见的实际使用场景；而 **1–4 之间的任意小数位占 10%** 这一设计，
+是为了避免模型只对固定的 1.5×/2×/2.5×/3×/4× 几个档位过拟合，从而能在推理时处理 1.0×–4.0× 区间内
+任意连续 `scale` 值。
+
+---
+
+## 🙏 致谢
+
+本节点沿用了 **Ttl** 提出的「神经网络 latent 放大」思路
+（[ComfyUi_NNLatentUpscale](https://github.com/Ttl/ComfyUi_NNLatentUpscale)，
+https://github.com/Ttl）。本项目模型架构同时参考借鉴了 **LTX 2.3 Spatial Upscaler**
+（`ltx-2.3-spatial-upscaler-x2-1.1.safetensors`）。感谢这些开源工作为本项目奠定基础。

Comfyui_Minimax_h3_latent_Upscaler/__init__.py

@@ -0,0 +1,3 @@
+from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

Comfyui_Minimax_h3_latent_Upscaler/examples/Minimax_h3_latent_Upscaler_001.mp4

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

Comfyui_Minimax_h3_latent_Upscaler/nodes/MMH3_Split_Upscale.py

@@ -0,0 +1,725 @@
+"""MMH3 Split Upscale - 完整最终版 (含 seam_denoise 缝邻域降噪上限)
+预防: 冻结预填重叠带 + 三重时间锚 + cross-fade
+校正: 空间/时间两级颜色匹配 + 首块源参考 + 每 chunk 全局钉源
+抗分叉: seam_denoise 缝邻域降噪上限 (高降噪+快运动防切割残影)
+修复: 每瓦片独立 Guider + 裁剪 keyframes; 修复版 probe 门控 polish
+简化: overlap/fade 百分比参数。
+"""
+
+import math
+import torch
+import comfy.model_management
+import comfy.sample
+import comfy.samplers
+import comfy.utils
+import comfy.nested_tensor
+import latent_preview
+from comfy_api.latest import io
+
+try:
+    from comfy.ldm.minimax.model import FRAME_PER_TOKEN, FRAME_RESCALE
+except Exception:
+    FRAME_PER_TOKEN = (1, 4, 4, 4, 4)
+    FRAME_RESCALE = 5.0 / 3.0
+
+H3_TEMPORAL_PARAM = io.Custom("H3_TEMPORAL_PARAM_V10")
+H3_SPATIAL_PARAM = io.Custom("H3_SPATIAL_PARAM_V10")
+
+VAE_DOWNSAMPLE = 16
+ALIGN = 2
+MAX_IDENTITY_ANCHORS = 6
+POLISH_HALO = 16
+DC_MATCH_CLAMP = 0.05
+SEAM_CORR_GATE, SEAM_DC_GATE = 0.85, 0.6
+COLOR_CLAMP = 0.05
+
+# ---------------------------------------------------------------------------
+# 帧/token 映射
+# ---------------------------------------------------------------------------
+def frames_for_tokens(n): return sum(FRAME_PER_TOKEN[i % 5] for i in range(n))
+
+def tokens_for_frames(f):
+    n, acc = 0, 0
+    while acc < f:
+        acc += FRAME_PER_TOKEN[n % 5]; n += 1
+    return n
+
+def audio_range(f0, f1): return round(f0 * FRAME_RESCALE), round(f1 * FRAME_RESCALE)
+
+def clip_tokens(n): return (n - 5) // 17 * 5 + 2 if n >= 5 else 1
+
+def snap_clip_frames(v): return 5 + 17 * max(1, round((v - 5) / 17)) if v >= 5 else max(1, int(v))
+
+def snap_overlap_frames(v): return 0 if v <= 0 else 5 + 17 * max(0, round((v - 5) / 17))
+
+def token_start_at_or_before(f):
+    k = 0
+    while frames_for_tokens(k + 1) <= f:
+        k += 1
+    return k
+
+def steps_for_frames(n):
+    k, covered = 0, 0
+    while covered < n:
+        covered += FRAME_PER_TOKEN[k % 5]; k += 1
+    return k if covered == n else None
+
+def compute_h3_segments_adaptive(tv, chunk_frames, overlap_frames):
+    tc = clip_tokens(chunk_frames)
+    to = clip_tokens(overlap_frames) if overlap_frames > 0 else 0
+    if to >= tc:
+        to = max(0, tc - 1)
+    if tc >= tv:
+        return [(0, 0, tv, frames_for_tokens(tv))], frames_for_tokens(tv)
+    hop = max(1, tc - to)
+    bounds, prev_k0, i = [], -1, 0
+    while True:
+        k0 = i * hop
+        if k0 + tc >= tv:
+            k1 = tv
+            k0 = max(k0, tv - tc)
+            if prev_k0 >= 0 and k0 <= prev_k0:
+                k0 = prev_k0 + 1
+            if k0 >= tv:
+                break
+            bounds.append((k0, frames_for_tokens(k0), k1, frames_for_tokens(k1)))
+            break
+        bounds.append((k0, frames_for_tokens(k0), k0 + tc, frames_for_tokens(k0 + tc)))
+        prev_k0 = k0
+        i += 1
+    return bounds, frames_for_tokens(tv)
+
+def is_h3_av_latent(samples):
+    return (samples is not None and samples.is_nested and len(samples.tensors) == 2
+            and samples.tensors[0].ndim == 5 and samples.tensors[0].shape[1] == 24
+            and samples.tensors[1].ndim == 4 and samples.tensors[1].shape[1] == 32)
+
+def px_to_lat(px):
+    return max(ALIGN, (round(px / VAE_DOWNSAMPLE) // ALIGN) * ALIGN)
+
+def snap_align(v):
+    return max(0, int(round(v / ALIGN)) * ALIGN)
+
+# ---------------------------------------------------------------------------
+# keyframe 链路
+# ---------------------------------------------------------------------------
+def trim_keyframe(kf, f0, f1):
+    idx = kf["resolved_frame_index"]
+    latent, audio_latent = kf.get("latent"), kf.get("audio_latent")
+    if latent is None and audio_latent is None:
+        return None if (idx < f0 or idx >= f1) else {"resolved_frame_index": idx - f0}
+    out = {}
+    if latent is not None:
+        t_start = t_end = None
+        pos = idx
+        for k in range(latent.shape[2]):
+            span = FRAME_PER_TOKEN[k % 5]
+            if f0 <= pos and pos + span <= f1:
+                if t_start is None: t_start = k
+                t_end = k + 1
+            pos += span
+        if t_start is None: return None
+        out["latent"] = latent[:, :, t_start:t_end].contiguous()
+        out["resolved_frame_index"] = idx + frames_for_tokens(t_start) - f0
+    if audio_latent is not None:
+        rt = audio_latent.shape[-1]
+        a_start = max(0, math.ceil((f0 - idx) * FRAME_RESCALE))
+        a_end = min(rt, math.floor((f1 - idx) / FRAME_RESCALE))
+        if a_end > a_start:
+            out["audio_latent"] = audio_latent[..., a_start:a_end].contiguous()
+            if "resolved_frame_index" not in out:
+                out["resolved_frame_index"] = max(0, idx - f0)
+    return out if ("latent" in out or "audio_latent" in out) else None
+
+def reanchor_conditioning(cond, f0, f1, spatial):
+    out = []
+    for tensor, d in cond:
+        nd = dict(d)
+        kfs = nd.get("minimax_keyframes")
+        if kfs:
+            trimmed = [kf for kf in (trim_keyframe(kf, f0, f1) for kf in kfs) if kf is not None]
+            if trimmed:
+                if spatial is not None:
+                    for kf in trimmed:
+                        lt = kf.get("latent")
+                        if lt is not None and (lt.shape[3] != spatial[0] or lt.shape[4] != spatial[1]):
+                            B, C, T, H, W = lt.shape
+                            kf["latent"] = torch.nn.functional.interpolate(
+                                lt.view(B * T, C, H, W), size=spatial, mode="bilinear",
+                                align_corners=False).view(B, C, T, spatial[0], spatial[1])
+                nd["minimax_keyframes"] = trimmed
+            else:
+                nd.pop("minimax_keyframes", None)
+        out.append([tensor, nd])
+    return out
+
+def prepend_keyframes(cond, kfs):
+    if not kfs:
+        return cond
+    out = []
+    for tensor, d in cond:
+        nd = dict(d)
+        nd["minimax_keyframes"] = kfs + (nd.get("minimax_keyframes") or [])
+        out.append([tensor, nd])
+    return out
+
+def motion_keyframes(prev_video, prev_tokens, f0, n_frames):
+    n = next((g for g in (56, 39, 22, 5) if g <= n_frames), 0)
+    steps = steps_for_frames(n) if n else None
+    if not steps or steps > prev_tokens or (prev_tokens - steps) % 5 != 0:
+        return []
+    start = prev_tokens - steps
+    return [{"resolved_frame_index": frames_for_tokens(start + k) - f0,
+             "latent": prev_video[:, :, start + k:start + k + 1].contiguous()}
+            for k in range(steps)]
+
+def identity_keyframes(source, f0, f1, spacing):
+    kfs, p = [], f0 + spacing
+    while p < f1:
+        k = token_start_at_or_before(p)
+        kfs.append({"resolved_frame_index": frames_for_tokens(k) - f0,
+                    "latent": source[:, :, k:k + 1].contiguous()})
+        p += spacing
+    if len(kfs) > MAX_IDENTITY_ANCHORS:
+        kfs = [kfs[i * len(kfs) // MAX_IDENTITY_ANCHORS] for i in range(MAX_IDENTITY_ANCHORS)]
+    return kfs
+
+def anchor_conditioning(cond, prev_video, f0, strength):
+    t = tokens_for_frames(f0)
+    if t >= prev_video.shape[2]:
+        raise ValueError("previous result does not reach the current segment start")
+    anchor_kf = {"resolved_frame_index": 0, "latent": prev_video[:, :, t:t + 1].contiguous()}
+    aug = max(0.0, min(1.0, float(strength)))
+    out = []
+    for tensor, d in cond:
+        nd = dict(d)
+        kfs = nd.get("minimax_keyframes")
+        if kfs:
+            kept = [kf for kf in kfs if kf.get("resolved_frame_index") != 0 or "latent" not in kf]
+            nd["minimax_keyframes"] = [anchor_kf] + kept
+        else:
+            nd["minimax_keyframes"] = [anchor_kf]
+        nd["minimax_visual_cond_noise_aug"] = aug
+        out.append([tensor, nd])
+    return out
+
+def crop_keyframes_to_tile(cond, src_h, src_w, r0, c0, tr, tc):
+    out = []
+    for tensor, d in cond:
+        nd = dict(d)
+        kfs = nd.get("minimax_keyframes")
+        if kfs:
+            cropped = []
+            for kf in kfs:
+                nkf = dict(kf)
+                lt = kf.get("latent")
+                if lt is not None:
+                    if lt.shape[3] == src_h and lt.shape[4] == src_w:
+                        nkf["latent"] = lt[:, :, :, r0:r0 + tr, c0:c0 + tc].contiguous()
+                    else:
+                        lt_r = torch.nn.functional.interpolate(
+                            lt.to(torch.float32), size=(src_h, src_w),
+                            mode="bilinear", align_corners=False)
+                        nkf["latent"] = lt_r[:, :, :, r0:r0 + tr, c0:c0 + tc].contiguous()
+                cropped.append(nkf)
+            nd["minimax_keyframes"] = cropped
+        out.append([tensor, nd])
+    return out
+
+# ---------------------------------------------------------------------------
+# 空间网格
+# ---------------------------------------------------------------------------
+def _grid_1d(size, tile, ol, min_tile):
+    if size <= tile:
+        return [0], [size], [0]
+    sh = tile - ol
+    n = math.ceil((size - ol) / sh)
+    if (n - 1) * sh + tile < size:
+        n += 1
+    rows = [i * sh for i in range(n)]
+    trows = [min(tile, size - r) for r in rows]
+    if min_tile > 0 and n >= 2:
+        edge = size - rows[-1]
+        if edge < min_tile:
+            new_last = size - min_tile
+            if rows[-2] < new_last < rows[-2] + trows[-2]:
+                rows[-1] = new_last
+                trows[-1] = size - new_last
+    ovl = [0] * n
+    for i in range(1, n):
+        ovl[i] = max(0, rows[i - 1] + trows[i - 1] - rows[i])
+    return rows, trows, ovl
+
+def compute_spatial_grid(h, w, th, tw, ol_h, ol_w, min_th=0, min_tw=0):
+    rows, trows, row_ovl = _grid_1d(h, th, ol_h, min_th)
+    cols, tcols, col_ovl = _grid_1d(w, tw, ol_w, min_tw)
+    return rows, cols, trows, tcols, row_ovl, col_ovl
+
+def spatial_fade_mask(tile_h, tile_w, ovh, ovw, done_top, done_left,
+                      fade_h=0, fade_w=0, seam_cap=1.0):
+    """1=自由重��样, 0=冻结。
+    重叠带 = 冻结段(缝侧) + 渐变段(0->seam_cap);
+    seam_cap<1 时重叠带后再加一段等宽渐变 (cap->1), 让缝邻域以中等降噪
+    "续写"冻结条内容, 高降噪下防止运动物体被切断。seam_cap=1.0 = 经典行为。"""
+    mask = torch.ones(tile_h, tile_w, dtype=torch.float32)
+
+    def profile(n, ov, fade):
+        p = torch.ones(n, dtype=torch.float32)
+        f = min(fade, ov)
+        frozen = ov - f
+        p[:frozen] = 0.0
+        if f > 0:
+            p[frozen:ov] = torch.linspace(0.0, seam_cap, f)
+        ramp = min(ov, n - ov)
+        if ramp > 0 and seam_cap < 1.0:
+            start = seam_cap if f > 0 else 0.0
+            p[ov:ov + ramp] = torch.linspace(start, 1.0, ramp)
+        return p
+
+    if done_left and ovw > 0:
+        mask = torch.minimum(mask, profile(tile_w, ovw, fade_w)[None, :])
+    if done_top and ovh > 0:
+        mask = torch.minimum(mask, profile(tile_h, ovh, fade_h)[:, None])
+    return mask
+
+# ---------------------------------------------------------------------------
+# 校正 + 门控
+# ---------------------------------------------------------------------------
+def dc_correct(new, refs, clamp=COLOR_CLAMP, min_samples=256):
+    pairs = [p for p in refs if p is not None and p[0] is not None
+             and p[0].numel() >= min_samples]
+    if not pairs:
+        return new, None
+    pa = torch.cat([a.float().permute(0, 2, 3, 4, 1).reshape(-1, a.shape[1]) for a, _ in pairs])
+    pb = torch.cat([b.float().permute(0, 2, 3, 4, 1).reshape(-1, b.shape[1]) for _, b in pairs])
+    dc = (pa - pb).median(dim=0).values.clamp(-clamp, clamp)
+    return new - dc.view(1, -1, 1, 1, 1).to(new.device, new.dtype), dc
+
+def grade_pin(chunk, ref, clamp=COLOR_CLAMP):
+    a = chunk.float().permute(0, 2, 3, 4, 1).reshape(-1, chunk.shape[1])
+    b = ref.float().permute(0, 2, 3, 4, 1).reshape(-1, ref.shape[1])
+    dc = (a - b).median(dim=0).values.clamp(-clamp, clamp)
+    return chunk - dc.view(1, -1, 1, 1, 1).to(chunk.device, chunk.dtype), dc
+
+def seam_metrics(sub, region):
+    if sub.numel() < 4096:
+        return None, None
+    sp = sub.float().permute(0, 2, 3, 4, 1).reshape(-1, sub.shape[1])
+    rp = region.float().permute(0, 2, 3, 4, 1).reshape(-1, region.shape[1])
+    dc = (sp - rp).median(dim=0).values.clamp(-DC_MATCH_CLAMP, DC_MATCH_CLAMP)
+    a = sp - sp.mean(dim=0)
+    b = rp - rp.mean(dim=0)
+    corr = ((a * b).mean(dim=0) / (a.std(dim=0) * b.std(dim=0) + 1e-6)).median()
+    return dc, float(corr)
+
+def _should_polish(mode, sub, region):
+    if mode == "all":
+        return True
+    dc, corr = seam_metrics(sub, region)
+    if dc is None:
+        return False
+    return ((corr is not None and corr < SEAM_CORR_GATE)
+            or dc.abs().max().item() > SEAM_DC_GATE * DC_MATCH_CLAMP)
+
+# ---------------------------------------------------------------------------
+# 时间缝合
+# ---------------------------------------------------------------------------
+def _crossfade(a, b, dim):
+    n = a.shape[dim]
+    w = torch.linspace(0.0, 1.0, n, device=a.device, dtype=a.dtype)
+    shape = [1] * a.ndim
+    shape[dim] = n
+    return a + (b - a) * w.view(shape)
+
+def temporal_append(acc_v, acc_a, chunk_v, chunk_a, index, k0, f0, color_match=True):
+    if acc_v is None:
+        return chunk_v, chunk_a
+    gi, agi = k0, round(f0 * FRAME_RESCALE)
+    total_v = max(acc_v.shape[2], gi + chunk_v.shape[2])
+    total_a = max(acc_a.shape[-1], agi + chunk_a.shape[-1])
+    rv = torch.zeros((1, acc_v.shape[1], total_v, acc_v.shape[3], acc_v.shape[4]),
+                     device=acc_v.device, dtype=acc_v.dtype)
+    ra = torch.zeros((1, 32, 2, total_a), device=acc_a.device, dtype=acc_a.dtype)
+    rv[:, :, :acc_v.shape[2]] = acc_v
+    ra[:, :, :, :acc_a.shape[-1]] = acc_a
+    v, a = chunk_v, chunk_a
+    if index > 0:
+        ov = min(acc_v.shape[2] - gi, v.shape[2])
+        if ov > 0:
+            if color_match:
+                v, dc = dc_correct(v, [(v[:, :, :ov], rv[:, :, gi:gi + ov])])
+                if dc is not None:
+                    print(f"[H3] 🎨 chunk {index} 时间颜色匹配 |dc|max={dc.abs().max():.4f}")
+            rv[:, :, gi:gi + ov] = _crossfade(rv[:, :, gi:gi + ov], v[:, :, :ov], dim=2)
+            v = v[:, :, ov:]
+        gi += ov
+        ova = min(acc_a.shape[-1] - agi, a.shape[-1])
+        if ova > 0:
+            ra[:, :, :, agi:agi + ova] = _crossfade(ra[:, :, :, agi:agi + ova], a[:, :, :, :ova], dim=3)
+            a = a[:, :, :, ova:]
+        agi += ova
+    if v.shape[2] > 0:
+        rv[:, :, gi:gi + v.shape[2]] = v
+    if a.shape[-1] > 0:
+        ra[:, :, :, agi:agi + a.shape[-1]] = a
+    return rv, ra
+
+# ---------------------------------------------------------------------------
+# 采样
+# ---------------------------------------------------------------------------
+def build_guider(model, cond, negative, cfg):
+    guider = comfy.samplers.CFGGuider(model)
+    if negative is not None:
+        guider.set_conds(cond, negative)
+        guider.set_cfg(cfg)
+    else:
+        guider.inner_set_conds({"positive": cond})
+    return guider
+
+def sample_piece(piece, guider, noise_tensor, seed, sampler, sigmas, callback=None):
+    latent = dict(piece)
+    latent_image = latent["samples"]
+    latent_image = comfy.sample.fix_empty_latent_channels(
+        model=guider.model_patcher.model, latent_image=latent_image)
+    latent["samples"] = latent_image
+    if callback is None:
+        x0_output = {}
+        callback = latent_preview.prepare_callback(guider.model_patcher, sigmas.shape[-1] - 1, x0_output)
+    samples = guider.sample(noise_tensor, latent_image, sampler, sigmas,
+                            denoise_mask=latent.get("noise_mask"), callback=callback,
+                            disable_pbar=not comfy.utils.PROGRESS_BAR_ENABLED, seed=seed)
+    return samples.to(comfy.model_management.intermediate_device())
+
+def make_tile_progress(model_patcher, steps, n_tiles):
+    previewer = latent_preview.get_previewer(model_patcher.load_device, model_patcher.model.latent_format)
+    total = steps * n_tiles
+    pbar = comfy.utils.ProgressBar(total)
+    def for_tile(idx):
+        def callback(step, x0, x, total_steps):
+            preview = None
+            if previewer is not None and x0 is not None:
+                px0 = x0.tensors[0] if getattr(x0, "is_nested", False) else x0
+                try:
+                    preview = previewer.decode_latent_to_preview_image("JPEG", px0)
+                except Exception:
+                    preview = None
+            pbar.update_absolute(idx * steps + step + 1, total, preview)
+        return callback
+    return for_tile
+
+# ---------------------------------------------------------------------------
+# 参数节点
+# ---------------------------------------------------------------------------
+class H3TemporalSplitParams(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="MMH3TemporalSplitParamsV10", display_name="MMH3 Temporal Split Params",
+            category="latent/upscale/minimax",
+            description="H3 原生网格时间分块 (5+17m 帧) + 三重锚。",
+            inputs=[
+                io.Int.Input("chunk_frames", default=73, min=5, max=100000, step=1),
+                io.Int.Input("temporal_overlap_frames", default=22, min=0, max=100000, step=1),
+                io.Float.Input("anchor_strength", default=0.999, min=0.0, max=1.0, step=0.001),
+                io.Combo.Input("motion_anchor_frames", options=["0", "5", "22", "39"], default="22"),
+                io.Int.Input("identity_anchor_frames", default=24, min=0, max=240, step=1),
+            ],
+            outputs=[H3_TEMPORAL_PARAM.Output("temporal_split_param")],
+        )
+
+    @classmethod
+    def execute(cls, chunk_frames, temporal_overlap_frames, anchor_strength,
+                motion_anchor_frames, identity_anchor_frames) -> io.NodeOutput:
+        chunk = snap_clip_frames(int(chunk_frames))
+        overlap = snap_overlap_frames(int(temporal_overlap_frames))
+        if overlap >= chunk:
+            overlap = snap_overlap_frames(chunk - 17)
+        return io.NodeOutput({"p": (chunk, overlap, float(anchor_strength),
+                                    int(motion_anchor_frames), int(identity_anchor_frames))})
+
+
+class H3SpatialSplitParams(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="MMH3SpatialSplitParamsV10", display_name="MMH3 Spatial Split Params",
+            category="latent/upscale/minimax",
+            description="简化空间分块: 百分比重叠/渐变 + 缝邻域降噪上限。",
+            inputs=[
+                io.Int.Input("tile_width", default=512, min=64, max=16384, step=32),
+                io.Int.Input("tile_height", default=512, min=64, max=16384, step=32),
+                io.Float.Input("overlap_ratio", default=0.25, min=0.0, max=0.90, step=0.05),
+                io.Float.Input("fade_ratio", default=0.50, min=0.0, max=1.0, step=0.05),
+                io.Int.Input("min_tile_size", default=256, min=0, max=16384, step=32),
+                io.Float.Input("seam_denoise", default=1.0, min=0.1, max=1.0, step=0.05,
+                               tooltip="缝邻域降噪上限: <1 时高降噪下缝附近以中等降噪续写邻居内容, "
+                                       "防止快运动物体在缝处被切断; 建议 0.5~0.8; 1.0=关。"),
+            ],
+            outputs=[
+                H3_SPATIAL_PARAM.Output("spatial_split_param"),
+                io.String.Output("grid_preview"),
+            ],
+        )
+
+    @classmethod
+    def execute(cls, tile_width, tile_height, overlap_ratio, fade_ratio,
+                min_tile_size, seam_denoise) -> io.NodeOutput:
+        tw, th = px_to_lat(tile_width), px_to_lat(tile_height)
+        ol_w = min(tw - ALIGN, snap_align(tw * overlap_ratio))
+        ol_h = min(th - ALIGN, snap_align(th * overlap_ratio))
+        fw = min(ol_w, int(round(ol_w * fade_ratio)))
+        fh = min(ol_h, int(round(ol_h * fade_ratio)))
+        mt = min(px_to_lat(min_tile_size), th, tw) if min_tile_size > 0 else 0
+        param = {"tw": tw, "th": th, "ol_w": ol_w, "ol_h": ol_h,
+                 "fw": fw, "fh": fh, "mt": mt, "cap": float(seam_denoise)}
+        preview = (f"Tile: {tile_width}x{tile_height}px -> {tw}x{th}lat | "
+                   f"Overlap: {overlap_ratio:.0%} -> {ol_w}x{ol_h}lat | "
+                   f"Fade: {fade_ratio:.0%} -> {fw}x{fh}lat | SeamDenoise: {seam_denoise:.2f}")
+        print(f"[H3] 📊 {preview}")
+        return io.NodeOutput(param, preview)
+
+
+# ---------------------------------------------------------------------------
+# 主节点
+# ---------------------------------------------------------------------------
+class MMH3SplitUpscale(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="MMH3SplitUpscale", display_name="MMH3 Split Upscale",
+            category="latent/upscale/minimax",
+            description="预防(冻结预填+三重锚) + 校正(颜色匹配+钉源) + 抗分叉(seam_denoise) + probe 门控 polish。",
+            inputs=[
+                io.Model.Input("model"),
+                io.Conditioning.Input("conditioning"),
+                io.Conditioning.Input("negative", optional=True),
+                io.Latent.Input("latent"),
+                io.Noise.Input("noise"),
+                io.Sampler.Input("sampler"),
+                io.Sigmas.Input("sigmas"),
+                io.Float.Input("cfg", default=1.0, min=0.0, max=100.0, step=0.1, round=0.01),
+                H3_TEMPORAL_PARAM.Input("temporal_split_param", optional=True),
+                H3_SPATIAL_PARAM.Input("spatial_split_param", optional=True),
+                io.Combo.Input("seam_polish", options=["off", "auto", "all"], default="off"),
+                io.Boolean.Input("color_match", default=True),
+            ],
+            outputs=[io.Latent.Output("latent")],
+        )
+
+    @classmethod
+    def execute(cls, latent, conditioning, model, noise, sampler, sigmas,
+                negative=None, cfg=1.0, temporal_split_param=None,
+                spatial_split_param=None, seam_polish="off",
+                color_match=True) -> io.NodeOutput:
+        samples = latent["samples"]
+        if not is_h3_av_latent(samples):
+            raise ValueError("期望 MiniMax H3 AV latent (嵌套 video+audio)")
+        video, audio = samples.tensors[0], samples.tensors[1]
+        if video.shape[0] != 1:
+            raise ValueError("仅支持 Batch 1")
+        B, C, T, H, W = video.shape
+
+        if temporal_split_param is not None:
+            cl, ov, anchor_strength, motion_n, identity_n = temporal_split_param["p"]
+            bounds, _ = compute_h3_segments_adaptive(T, cl, ov)
+        else:
+            bounds = [(0, 0, T, frames_for_tokens(T))]
+            anchor_strength, motion_n, identity_n = 0.999, 0, 0
+
+        if spatial_split_param is not None:
+            sp = spatial_split_param
+            rows, cols, trows, tcols, row_ovl, col_ovl = compute_spatial_grid(
+                H, W, sp["th"], sp["tw"], sp["ol_h"], sp["ol_w"], sp["mt"], sp["mt"])
+            seam_cap = sp.get("cap", 1.0)
+        else:
+            rows, cols, trows, tcols, row_ovl, col_ovl = [0], [0], [H], [W], [0], [0]
+            seam_cap = 1.0
+        nrows, ncols = len(rows), len(cols)
+
+        steps = max(int(sigmas.shape[-1]) - 1, 1)
+        n_tiles = len(bounds) * nrows * ncols
+        for_tile = make_tile_progress(model.model_patcher if hasattr(model, "model_patcher") else model,
+                                      steps, n_tiles)
+
+        source = video
+        noise_v = noise.generate_noise({"samples": torch.zeros_like(video, dtype=torch.float32)})
+        noise_a = noise.generate_noise({"samples": torch.zeros_like(audio, dtype=torch.float32)})
+
+        acc_v = acc_a = None
+        polish_queue = {}
+        tile_idx = 0
+
+        for i, (k0, f0, k1, f1) in enumerate(bounds):
+            chunk_v = video[:, :, k0:k1].contiguous()
+            a0, a1 = audio_range(f0, f1)
+            a1 = min(a1, audio.shape[-1])
+            chunk_a = audio[:, :, :, a0:a1].contiguous()
+
+            cond_i = reanchor_conditioning(conditioning, f0, f1, (H, W))
+            if i > 0 and acc_v is not None:
+                if motion_n > 0:
+                    cond_i = prepend_keyframes(cond_i, motion_keyframes(acc_v, k0, f0, motion_n))
+                if identity_n > 0:
+                    cond_i = prepend_keyframes(cond_i, identity_keyframes(source, f0, f1, identity_n))
+                if anchor_strength > 0.0:
+                    cond_i = anchor_conditioning(cond_i, acc_v, f0, anchor_strength)
+            elif identity_n > 0:
+                cond_i = prepend_keyframes(cond_i, identity_keyframes(source, f0, f1, identity_n))
+
+            chunk_out = chunk_v.clone()
+            noise_vc = noise_v[:, :, k0:k1]
+            noise_ac = noise_a[:, :, :, a0:a1]
+
+            # ================= 空间内循环 =================
+            for ri in range(nrows):
+                for cj in range(ncols):
+                    comfy.model_management.throw_exception_if_processing_interrupted()
+                    r0, c0 = rows[ri], cols[cj]
+                    tr, tc = trows[ri], tcols[cj]
+                    ovh, ovw = row_ovl[ri], col_ovl[cj]
+
+                    tile = chunk_out[:, :, :, r0:r0 + tr, c0:c0 + tc].clone()
+
+                    if spatial_split_param is not None:
+                        fh, fw = spatial_split_param["fh"], spatial_split_param["fw"]
+                    else:
+                        fh = fw = 0
+                    m = spatial_fade_mask(tr, tc, ovh, ovw,
+                                          done_top=(ri > 0), done_left=(cj > 0),
+                                          fade_h=fh, fade_w=fw, seam_cap=seam_cap)
+                    mv = m[None, None, None].to(chunk_out.device)
+                    ma = torch.zeros((1, 32, 2, chunk_a.shape[-1]),
+                                     device=chunk_a.device, dtype=torch.float32)
+                    piece = {"samples": comfy.nested_tensor.NestedTensor((tile, chunk_a)),
+                             "noise_mask": comfy.nested_tensor.NestedTensor((mv, ma))}
+                    tile_noise = comfy.nested_tensor.NestedTensor((
+                        noise_vc[:, :, :, r0:r0 + tr, c0:c0 + tc].contiguous(),
+                        noise_ac.contiguous()))
+
+                    cond_tile = crop_keyframes_to_tile(cond_i, H, W, r0, c0, tr, tc)
+                    guider = build_guider(model, cond_tile, negative, cfg)
+                    out = sample_piece(piece, guider, tile_noise, noise.seed, sampler, sigmas,
+                                       for_tile(tile_idx))
+                    tile_v = (out.tensors[0] if out.is_nested else out).to(chunk_out.device)
+
+                    region = chunk_out[:, :, :, r0:r0 + tr, c0:c0 + tc].clone()
+
+                    if color_match:
+                        tile_v, _ = dc_correct(tile_v, [
+                            (tile_v[:, :, :, :, :ovw], region[:, :, :, :, :ovw])
+                                if (cj > 0 and ovw > 0) else None,
+                            (tile_v[:, :, :, :ovh, :], region[:, :, :, :ovh, :])
+                                if (ri > 0 and ovh > 0) else None,
+                            (tile_v, chunk_v[:, :, :, r0:r0 + tr, c0:c0 + tc])
+                                if (ri == 0 and cj == 0) else None,
+                        ])
+
+                    if seam_polish != "off":
+                        if cj > 0 and ovw > 0 and \
+                                _should_polish(seam_polish, tile_v[:, :, :, :, :ovw], region[:, :, :, :, :ovw]):
+                            polish_queue[(i, ri, cj, "W")] = (c0, ovw, (k0, k1))
+                        if ri > 0 and ovh > 0 and \
+                                _should_polish(seam_polish, tile_v[:, :, :, :ovh, :], region[:, :, :, :ovh, :]):
+                            polish_queue[(i, ri, cj, "H")] = (r0, ovh, (k0, k1))
+
+                    if cj > 0 and ovw > 0:
+                        wts = torch.linspace(0.0, 1.0, ovw, device=region.device,
+                                             dtype=region.dtype).view(1, 1, 1, 1, ovw)
+                        region[:, :, :, :, :ovw] = (region[:, :, :, :, :ovw] * (1.0 - wts)
+                                                    + tile_v[:, :, :, :, :ovw] * wts)
+                    if ri > 0 and ovh > 0:
+                        wts = torch.linspace(0.0, 1.0, ovh, device=region.device,
+                                             dtype=region.dtype).view(1, 1, 1, ovh, 1)
+                        region[:, :, :, :ovh, :] = (region[:, :, :, :ovh, :] * (1.0 - wts)
+                                                    + tile_v[:, :, :, :ovh, :] * wts)
+                    band = torch.zeros((1, 1, 1, tr, tc), dtype=torch.bool, device=region.device)
+                    if cj > 0 and ovw > 0:
+                        band[:, :, :, :, :ovw] = True
+                    if ri > 0 and ovh > 0:
+                        band[:, :, :, :ovh, :] = True
+                    region = torch.where(band, region, tile_v)
+                    chunk_out[:, :, :, r0:r0 + tr, c0:c0 + tc] = region
+
+                    tile_idx += 1
+                    comfy.model_management.soft_empty_cache()
+
+            if color_match:
+                chunk_out, dcg = grade_pin(chunk_out, chunk_v)
+                if dcg is not None and dcg.abs().max().item() > 1e-4:
+                    print(f"[H3] 🎯 chunk {i} 全局钉源 |dc|max={dcg.abs().max():.4f}")
+
+            # ================= 修复版 polish 二道缝 =================
+            chunk_polish = [(k, v) for k, v in polish_queue.items() if k[0] == i]
+            if chunk_polish:
+                print(f"[H3] 🔧 chunk {i}: polish {len(chunk_polish)} 条缝")
+                pbar2 = comfy.utils.ProgressBar(steps * len(chunk_polish))
+                for pi, (key, (s0, band_w, (tk0, tk1))) in enumerate(chunk_polish):
+                    comfy.model_management.throw_exception_if_processing_interrupted()
+                    axis = key[3]
+                    t_len = tk1 - tk0
+                    if axis == "W":
+                        w0 = max(0, s0 - POLISH_HALO)
+                        w1 = min(W, s0 + band_w + POLISH_HALO)
+                        win = chunk_out[:, :, :, :, w0:w1].clone()
+                        b0, b1 = s0 - w0, s0 - w0 + band_w
+                        mv = torch.zeros((1, 1, t_len, H, w1 - w0), dtype=torch.float32, device=win.device)
+                        mv[:, :, :, :, b0:b1] = 1.0
+                        r0c, c0c, trc, tcc, ax = 0, w0, H, w1 - w0, 4
+                        nsl = (slice(None), slice(None), slice(tk0, tk1), slice(None), slice(w0, w1))
+                    else:
+                        h0 = max(0, s0 - POLISH_HALO)
+                        h1 = min(H, s0 + band_w + POLISH_HALO)
+                        win = chunk_out[:, :, :, h0:h1, :].clone()
+                        b0, b1 = s0 - h0, s0 - h0 + band_w
+                        mv = torch.zeros((1, 1, t_len, h1 - h0, W), dtype=torch.float32, device=win.device)
+                        mv[:, :, :, b0:b1, :] = 1.0
+                        r0c, c0c, trc, tcc, ax = h0, 0, h1 - h0, W, 3
+                        nsl = (slice(None), slice(None), slice(tk0, tk1), slice(h0, h1), slice(None))
+                    ma = torch.zeros((1, 32, 2, chunk_a.shape[-1]),
+                                     device=chunk_a.device, dtype=torch.float32)
+                    piece = {"samples": comfy.nested_tensor.NestedTensor((win, chunk_a)),
+                             "noise_mask": comfy.nested_tensor.NestedTensor((mv, ma))}
+                    tn = comfy.nested_tensor.NestedTensor((noise_v[nsl].contiguous(), noise_ac.contiguous()))
+
+                    cond_p = crop_keyframes_to_tile(cond_i, H, W, r0c, c0c, trc, tcc)
+                    g = build_guider(model, cond_p, negative, cfg)
+
+                    def _cb(step, x0, x, ts, _pi=pi):
+                        pbar2.update_absolute(_pi * steps + step + 1, steps * len(chunk_polish))
+
+                    out = sample_piece(piece, g, tn, noise.seed, sampler, sigmas, callback=_cb)
+                    pv = (out.tensors[0] if out.is_nested else out).to(chunk_out.device)
+
+                    nlen = (w1 - w0) if ax == 4 else (h1 - h0)
+                    alpha = torch.ones(nlen, dtype=torch.float32)
+                    if b0 > 0:
+                        alpha[:b0] = torch.linspace(0.0, 1.0, b0)
+                    if nlen - b1 > 0:
+                        alpha[b1:] = torch.linspace(1.0, 0.0, nlen - b1)
+                    view = [1, 1, 1, 1, 1]
+                    view[ax] = nlen
+                    avv = alpha.view(view).to(chunk_out.device)
+                    if ax == 4:
+                        chunk_out[:, :, :, :, w0:w1] = avv * pv + (1.0 - avv) * win
+                    else:
+                        chunk_out[:, :, :, h0:h1, :] = avv * pv + (1.0 - avv) * win
+                    comfy.model_management.soft_empty_cache()
+
+            acc_v, acc_a = temporal_append(acc_v, acc_a, chunk_out, chunk_a, i, k0, f0, color_match)
+
+        if hasattr(model, "clone_base_uuid"):
+            comfy.model_management.unload_model_and_clones(model, unload_additional_models=False)
+            comfy.model_management.soft_empty_cache()
+        return io.NodeOutput({"samples": comfy.nested_tensor.NestedTensor((acc_v, acc_a))})
+
+
+NODE_CLASS_MAPPINGS = {
+    "MMH3TemporalSplitParamsV10": H3TemporalSplitParams,
+    "MMH3SpatialSplitParamsV10": H3SpatialSplitParams,
+    "MMH3SplitUpscale": MMH3SplitUpscale,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MMH3TemporalSplitParamsV10": "MMH3 Temporal Split Params",
+    "MMH3SpatialSplitParamsV10": "MMH3 Spatial Split Params",
+    "MMH3SplitUpscale": "MMH3 Split Upscale",
+}

Comfyui_Minimax_h3_latent_Upscaler/nodes/__init__.py

@@ -0,0 +1,37 @@
+import logging
+
+# 2D node: legacy API
+from .minimax_h3_latent_upscaler_2d import (
+    NODE_CLASS_MAPPINGS as NODE_CLASS_MAPPINGS_2D,
+    NODE_DISPLAY_NAME_MAPPINGS as NODE_DISPLAY_NAME_MAPPINGS_2D,
+)
+
+NODE_CLASS_MAPPINGS = {}
+NODE_CLASS_MAPPINGS.update(NODE_CLASS_MAPPINGS_2D)
+
+NODE_DISPLAY_NAME_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS.update(NODE_DISPLAY_NAME_MAPPINGS_2D)
+
+# 3D node: legacy API (same registration mechanism as 2D)
+try:
+    from .minimax_h3_latent_upscaler_3d import (
+        NODE_CLASS_MAPPINGS as NODE_CLASS_MAPPINGS_3D,
+        NODE_DISPLAY_NAME_MAPPINGS as NODE_DISPLAY_NAME_MAPPINGS_3D,
+    )
+    NODE_CLASS_MAPPINGS.update(NODE_CLASS_MAPPINGS_3D)
+    NODE_DISPLAY_NAME_MAPPINGS.update(NODE_DISPLAY_NAME_MAPPINGS_3D)
+except Exception as e:
+    logging.error(f"[MinimaxH3] Failed to import 3D node: {e}")
+
+# MMH3 Split Upscale combo: legacy API (Temporal/Spatial params + main upscale node)
+try:
+    from .MMH3_Split_Upscale import (
+        NODE_CLASS_MAPPINGS as NODE_CLASS_MAPPINGS_SPLIT,
+        NODE_DISPLAY_NAME_MAPPINGS as NODE_DISPLAY_NAME_MAPPINGS_SPLIT,
+    )
+    NODE_CLASS_MAPPINGS.update(NODE_CLASS_MAPPINGS_SPLIT)
+    NODE_DISPLAY_NAME_MAPPINGS.update(NODE_DISPLAY_NAME_MAPPINGS_SPLIT)
+except Exception as e:
+    logging.error(f"[MinimaxH3] Failed to import MMH3 Split Upscale node: {e}")
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

Comfyui_Minimax_h3_latent_Upscaler/nodes/minimax_h3_latent_upscaler_2d.py

@@ -0,0 +1,479 @@
+"""
+Minimax H3 Latent Upscaler - ComfyUI 推理节点 (2D主干 + Temporal 3D卷积)
+- 使用 VideoLatentResizer (与训练代码完全一致)
+- 自动检测模型结构并加载权重 (支持合并文件中的 upscaler. 前缀)
+- 强制关闭注意力 (attn=False) 以优化推理速度
+- 模型从 ComfyUI/models/latent_upscale_models/ 加载
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import os
+import glob
+import folder_paths
+import re
+from einops import rearrange
+
+# ==========================================
+# 注册模型文件夹
+# ==========================================
+_LATENT_UPSCALE_FOLDER = "latent_upscale_models"
+if _LATENT_UPSCALE_FOLDER not in folder_paths.folder_names_and_paths:
+    folder_paths.add_model_folder_path(
+        _LATENT_UPSCALE_FOLDER,
+        os.path.join(folder_paths.models_dir, _LATENT_UPSCALE_FOLDER)
+    )
+
+# ==========================================
+# Minimax H3 归一化参数 (24通道)
+# ==========================================
+LATENTS_MEAN = [
+    0.858090341091156, -0.9606591463088989, 1.0661640167236328, -0.5090325474739075,
+    -0.2727581858634949, -1.3675414323806763, -0.2553254961967468, -0.26907554268836975,
+    -0.5376840829849243, -0.0464097298681736, 0.6657370328903198, 0.19690127670764923,
+    -0.5460608005523682, -0.4035342037677765, -0.23683024942874908, 0.25928452610969543,
+    -0.30133944749832153, 0.211341992020607, -1.1206848621368408, 0.3581933379173279,
+    -0.04225143790245056, 0.2604829967021942, 0.22864092886447906, 0.7056031823158264
+]
+LATENTS_STD  = [
+    1.2223774194717407, 1.2767263650894165, 1.6831774711608887, 1.7549455165863037,
+    1.5636216402053833, 2.194143533706665, 0.9653137922286987, 1.0569885969161987,
+    0.841948926448822, 0.7729952931404114, 1.8955937623977661, 0.946841835975647,
+    0.7996809482574463, 0.44988900423049927, 0.7197399735450745, 0.6936293244361877,
+    2.961095094680786, 2.7694199085235596, 3.0496184825897217, 2.1088054180145264,
+    3.276226282119751, 3.1627357006073, 2.2816812992095947, 2.6127843856811523
+]
+
+def _make_norm_tensors(device, dtype):
+    mean = torch.tensor(LATENTS_MEAN, dtype=dtype, device=device).view(1, -1, 1, 1, 1)
+    std = torch.tensor(LATENTS_STD, dtype=dtype, device=device).view(1, -1, 1, 1, 1)
+    return mean, std
+
+# ==========================================
+# 与训练代码完全一致的网络组件 (2D + Temporal)
+# ==========================================
+def normalization(channels):
+    return nn.GroupNorm(32, channels)
+
+def zero_module(module):
+    for p in module.parameters():
+        p.detach().zero_()
+    return module
+
+class AttnBlock(nn.Module):
+    def __init__(self, in_channels):
+        super().__init__()
+        self.norm = normalization(in_channels)
+        self.q = nn.Conv2d(in_channels, in_channels, 1)
+        self.k = nn.Conv2d(in_channels, in_channels, 1)
+        self.v = nn.Conv2d(in_channels, in_channels, 1)
+        self.proj_out = nn.Conv2d(in_channels, in_channels, 1)
+
+    def forward(self, x):
+        h = self.norm(x)
+        q = rearrange(self.q(h), "b c h w -> b 1 (h w) c")
+        k = rearrange(self.k(h), "b c h w -> b 1 (h w) c")
+        v = rearrange(self.v(h), "b c h w -> b 1 (h w) c")
+        h = F.scaled_dot_product_attention(q, k, v)
+        h = rearrange(h, "b 1 (h w) c -> b c h w", h=x.shape[-2], w=x.shape[-1])
+        return x + self.proj_out(h)
+
+class ResBlockEmb(nn.Module):
+    def __init__(self, channels, emb_channels, dropout=0, out_channels=None):
+        super().__init__()
+        self.out_channels = out_channels or channels
+        self.in_layers = nn.Sequential(
+            normalization(channels), nn.SiLU(),
+            nn.Conv2d(channels, self.out_channels, 3, padding=1),
+        )
+        self.emb_layers = nn.Sequential(
+            nn.SiLU(), nn.Linear(emb_channels, 2 * self.out_channels),
+        )
+        self.out_norm = normalization(self.out_channels)
+        self.out_layers = nn.Sequential(
+            nn.SiLU(), nn.Dropout(p=dropout),
+            zero_module(nn.Conv2d(self.out_channels, self.out_channels, 3, padding=1)),
+        )
+        self.skip = (
+            nn.Conv2d(channels, self.out_channels, 1)
+            if self.out_channels != channels else nn.Identity()
+        )
+
+    def forward(self, x, emb):
+        h = self.in_layers(x)
+        emb_out = self.emb_layers(emb).type(h.dtype)
+        while len(emb_out.shape) < len(h.shape):
+            emb_out = emb_out[..., None]
+        scale, shift = torch.chunk(emb_out, 2, dim=1)
+        h = self.out_norm(h) * (1 + scale) + shift
+        h = self.out_layers(h)
+        return self.skip(x) + h
+
+class TemporalConv(nn.Module):
+    def __init__(self, channels, kernel_size=5):
+        super().__init__()
+        padding = kernel_size // 2
+        self.norm = normalization(channels)
+        self.dwconv = nn.Conv3d(channels, channels,
+                                kernel_size=(kernel_size, 1, 1),
+                                padding=(padding, 0, 0),
+                                groups=channels)
+        self.pwconv = nn.Conv3d(channels, channels, kernel_size=1)
+        nn.init.zeros_(self.pwconv.weight)
+        nn.init.zeros_(self.pwconv.bias)
+
+    def forward(self, x):
+        identity = x
+        B, C, T, H, W = x.shape
+        # 先 reshape 为 (B*T, C, H, W) 应用 2D norm
+        h = rearrange(x, "b c t h w -> (b t) c h w")
+        h = self.norm(h)
+        h = rearrange(h, "(b t) c h w -> b c t h w", b=B, t=T)
+        h = F.silu(h)
+        h = self.dwconv(h)
+        h = self.pwconv(h)
+        return identity + h
+
+class LatentResizer(nn.Module):
+    """2D 主干 (与训练代码完全一致)"""
+    def __init__(self, in_channels=24, in_blocks=12, out_blocks=12,
+                 channels=640, dropout=0.1, attn=False):
+        super().__init__()
+        self.conv_in = nn.Conv2d(in_channels, channels, 3, padding=1)
+        embed_dim = 64
+        self.embed = nn.Sequential(
+            nn.Linear(1, embed_dim), nn.SiLU(), nn.Linear(embed_dim, embed_dim))
+        self.in_blocks = nn.ModuleList()
+        for b in range(in_blocks):
+            if (b == 1 or b == in_blocks - 1) and attn:
+                self.in_blocks.append(AttnBlock(channels))
+            self.in_blocks.append(ResBlockEmb(channels, embed_dim, dropout))
+        self.out_blocks = nn.ModuleList()
+        for b in range(out_blocks):
+            if (b == 1 or b == out_blocks - 1) and attn:
+                self.out_blocks.append(AttnBlock(channels))
+            self.out_blocks.append(ResBlockEmb(channels, embed_dim, dropout))
+        self.norm_out = normalization(channels)
+        self.conv_out = nn.Conv2d(channels, in_channels, 3, padding=1)
+
+    def forward(self, x, scale=None, target_hw=None):
+        if target_hw is not None:
+            size = target_hw
+        elif scale is not None:
+            size = tuple(int(round(s * scale)) for s in x.shape[-2:])
+        else:
+            return x
+        if size == x.shape[-2:]:
+            return x
+
+        scale_emb = torch.tensor(
+            [scale - 1 if scale is not None else 0.0],
+            dtype=x.dtype, device=x.device).unsqueeze(0)
+        emb = self.embed(scale_emb)
+
+        x = self.conv_in(x)
+        for b in self.in_blocks:
+            if isinstance(b, ResBlockEmb):
+                x = b(x, emb)
+            else:
+                x = b(x)
+        x = F.interpolate(x, size=size, mode="bilinear")
+        for b in self.out_blocks:
+            if isinstance(b, ResBlockEmb):
+                x = b(x, emb)
+            else:
+                x = b(x)
+        x = self.norm_out(x)
+        x = F.silu(x)
+        x = self.conv_out(x)
+        return x
+
+class VideoLatentResizer(nn.Module):
+    """5D 包装器 (含 Temporal 块) 与训练代码完全一致"""
+    def __init__(self, in_channels=24, in_blocks=12, out_blocks=12,
+                 channels=640, dropout=0.1, attn=False,
+                 temporal_every=2, temporal_kernel=5):
+        super().__init__()
+        self.resizer = LatentResizer(
+            in_channels=in_channels,
+            in_blocks=in_blocks,
+            out_blocks=out_blocks,
+            channels=channels,
+            dropout=dropout,
+            attn=attn,
+        )
+        self.temporal_blocks = nn.ModuleList()
+        if temporal_every > 0:
+            self.temporal_blocks.append(TemporalConv(channels, temporal_kernel))
+            self.temporal_blocks.append(TemporalConv(channels, temporal_kernel))
+        self.temporal_every = temporal_every
+        self.temporal_kernel = temporal_kernel
+
+    def forward(self, x, scale=None, target_hw=None):
+        B, C, T, H, W = x.shape
+        if target_hw is not None:
+            size = target_hw
+        elif scale is not None:
+            size = (int(round(H * scale)), int(round(W * scale)))
+        else:
+            size = (H, W)
+
+        if len(self.temporal_blocks) == 0:
+            x_flat = rearrange(x, "b c t h w -> (b t) c h w")
+            out = self.resizer(x_flat, scale=scale, target_hw=size)
+            return rearrange(out, "(b t) c h w -> b c t h w", b=B, t=T)
+
+        x_flat = rearrange(x, "b c t h w -> (b t) c h w")
+        emb = torch.tensor(
+            [scale - 1 if scale is not None else 0.0],
+            dtype=x.dtype, device=x.device).unsqueeze(0)
+        emb = self.resizer.embed(emb)
+
+        out = self.resizer.conv_in(x_flat)
+        for i, block in enumerate(self.resizer.in_blocks):
+            if isinstance(block, ResBlockEmb):
+                emb_t = emb.expand(B * T, -1)
+                out = block(out, emb_t)
+            else:
+                out = block(out)
+            if i % self.temporal_every == 0:
+                out_3d = rearrange(out, "(b t) c h w -> b c t h w", b=B, t=T)
+                out_3d = self.temporal_blocks[0](out_3d)
+                out = rearrange(out_3d, "b c t h w -> (b t) c h w")
+
+        out = F.interpolate(out, size=size, mode="bilinear")
+
+        for i, block in enumerate(self.resizer.out_blocks):
+            if isinstance(block, ResBlockEmb):
+                emb_t = emb.expand(B * T, -1)
+                out = block(out, emb_t)
+            else:
+                out = block(out)
+            if i % self.temporal_every == 0:
+                out_3d = rearrange(out, "(b t) c h w -> b c t h w", b=B, t=T)
+                out_3d = self.temporal_blocks[1](out_3d)
+                out = rearrange(out_3d, "b c t h w -> (b t) c h w")
+
+        out = self.resizer.norm_out(out)
+        out = F.silu(out)
+        out = self.resizer.conv_out(out)
+        out = rearrange(out, "(b t) c h w -> b c t h w", b=B, t=T)
+        return out
+
+# ==========================================
+# 模型加载 (适配训练权重)
+# ==========================================
+MODEL_CACHE = {}
+
+def get_models_dir():
+    return folder_paths.get_folder_paths(_LATENT_UPSCALE_FOLDER)[0]
+
+def scan_models():
+    files = []
+    model_dir = get_models_dir()
+    for ext in ("*.pth", "*.safetensors"):
+        files.extend(glob.glob(os.path.join(model_dir, ext)))
+    names = sorted(os.path.basename(f) for f in files)
+    return names if names else [f"(请将模型放入: {model_dir})"]
+
+def _load_raw_sd(path):
+    if path.endswith('.safetensors'):
+        from safetensors.torch import load_file
+        sd = load_file(path, device='cpu')
+    else:
+        sd = torch.load(path, map_location='cpu', weights_only=False)
+    if isinstance(sd, dict) and 'model' in sd:
+        sd = sd['model']
+    # 转换 FP8 为 FP16 方便处理
+    sd = {k: v.to(torch.float16) if v.dtype == torch.float8_e4m3fn else v
+          for k, v in sd.items()}
+    return sd
+
+def _extract_upscaler_sd(sd):
+    # 兼容合并权重中的 upscaler. 前缀
+    if any(k.startswith("upscaler.") for k in sd):
+        return {k[len("upscaler."):]: v for k, v in sd.items() if k.startswith("upscaler.")}
+    return sd
+
+def _detect_arch(sd):
+    """
+    从 state_dict 推断模型结构参数 (与训练代码一致)
+    返回: dict 包含 in_blocks, out_blocks, channels, in_channels,
+          dropout, attn, temporal_every, temporal_kernel
+    """
+    cfg = {
+        "in_channels": 24,
+        "in_blocks": 12,
+        "out_blocks": 12,
+        "channels": 640,
+        "dropout": 0.1,
+        "attn": False,
+        "temporal_every": 2,
+        "temporal_kernel": 5,
+    }
+
+    # 从 conv_in 推断通道数
+    if 'resizer.conv_in.weight' in sd:
+        w = sd['resizer.conv_in.weight']
+        cfg["in_channels"] = w.shape[1]
+        cfg["channels"] = w.shape[0]
+
+    # 统计 in_blocks 中的 ResBlock 数量 (通过 in_layers 键)
+    in_ids = set()
+    out_ids = set()
+    for k in sd.keys():
+        m = re.match(r'resizer\.in_blocks\.(\d+)\.in_layers\.', k)
+        if m:
+            in_ids.add(int(m.group(1)))
+        m = re.match(r'resizer\.out_blocks\.(\d+)\.in_layers\.', k)
+        if m:
+            out_ids.add(int(m.group(1)))
+
+    if in_ids:
+        cfg["in_blocks"] = len(in_ids)
+    if out_ids:
+        cfg["out_blocks"] = len(out_ids)
+
+    # 检测是否包含 temporal 块
+    has_temporal = any('temporal_blocks' in k for k in sd)
+    if has_temporal:
+        # 尝试从 temporal_blocks.0.dwconv.weight 提取 kernel size
+        for k in sd.keys():
+            if 'temporal_blocks.0.dwconv.weight' in k:
+                kernel_t = sd[k].shape[2]
+                cfg["temporal_kernel"] = kernel_t
+                break
+        cfg["temporal_every"] = 2  # 训练固定值
+    else:
+        cfg["temporal_every"] = 0
+
+    # 检测是否包含 attn (但推理时强制关闭)
+    if any('attn' in k for k in sd):
+        cfg["attn"] = True  # 仅用于记录，实际加载时强制 False
+
+    # 推理时强制 attn=False 以提高性能
+    cfg["attn"] = False
+    return cfg
+
+def load_model(name, device, precision):
+    cache_key = f"{name}::{device}::{precision}"
+    if cache_key in MODEL_CACHE:
+        return MODEL_CACHE[cache_key]
+
+    path = os.path.join(get_models_dir(), name)
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"模型文件不存在: {path}")
+
+    raw_sd = _load_raw_sd(path)
+    up_sd = _extract_upscaler_sd(raw_sd)
+
+    cfg = _detect_arch(up_sd)
+
+    # 构建模型 (与训练完全一致)
+    model = VideoLatentResizer(
+        in_channels=cfg["in_channels"],
+        in_blocks=cfg["in_blocks"],
+        out_blocks=cfg["out_blocks"],
+        channels=cfg["channels"],
+        dropout=cfg["dropout"],
+        attn=cfg["attn"],                # 强制 False
+        temporal_every=cfg["temporal_every"],
+        temporal_kernel=cfg["temporal_kernel"],
+    )
+
+    # 加载权重，忽略不匹配的键 (如 attn 层若训练有但推理强制关闭)
+    missing, unexpected = model.load_state_dict(up_sd, strict=False)
+    if missing:
+        print(f"[MinimaxH3] 缺少键: {missing[:5]}... (可能由于 attn 强制关闭)")
+    if unexpected:
+        print(f"[MinimaxH3] 多余键: {unexpected[:5]}... (可能来自合并文件的其他部分)")
+
+    dtype = {"fp32": torch.float32, "fp16": torch.float16, "bf16": torch.bfloat16}.get(precision, torch.float32)
+    model = model.to(device).eval()
+    if dtype != torch.float32:
+        model = model.to(dtype)
+
+    MODEL_CACHE[cache_key] = model
+
+    print(f"[MinimaxH3] 加载放大模型: {name}")
+    print(f"  Params: {sum(p.numel() for p in model.parameters()):,} | "
+          f"Attn: 强制关闭 | Temporal: {'✓' if cfg['temporal_every']>0 else '✗'} "
+          f"(every={cfg['temporal_every']}, kernel={cfg['temporal_kernel']})")
+    return model
+
+# ==========================================
+# ComfyUI 节点 (2D 版本)
+# ==========================================
+class MinimaxH3LatentUpscalerNode2D:
+    """Minimax H3 Latent 放大节点 (2D主干 + Temporal，与训练模型兼容，scale 1.0~4.0)"""
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "latent": ("LATENT",),
+                "model_name": (scan_models(),),
+                "scale": ("FLOAT", {"default": 2.0, "min": 1.0, "max": 4.0, "step": 0.1}),
+                "device": (["cuda", "cpu"], {"default": "cuda"}),
+                "precision": (["fp32", "fp16", "bf16"], {"default": "fp32"}),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "run"
+    CATEGORY = "video/MinimaxH3"
+
+    def run(self, latent, model_name, scale, device, precision):
+        if model_name.startswith('('):
+            raise ValueError("请将模型文件放入 latent_upscale_models 目录")
+
+        if abs(scale - 1.0) < 1e-6:
+            return (latent,)
+
+        if scale < 1.0:
+            raise ValueError("仅支持放大 (scale >= 1.0)")
+
+        dev = torch.device(device if torch.cuda.is_available() else "cpu")
+        model = load_model(model_name, dev, precision)
+
+        s = latent["samples"].clone()
+        orig_dtype = s.dtype
+        # 确保是 5D (B, C, T, H, W)
+        if len(s.shape) == 4:
+            s = s.unsqueeze(2)  # (B, C, 1, H, W)
+
+        compute_dtype = {"fp32": torch.float32, "fp16": torch.float16, "bf16": torch.bfloat16}[precision]
+        s = s.to(dev, compute_dtype)
+
+        # 归一化
+        norm_mean, norm_std = _make_norm_tensors(dev, compute_dtype)
+        s = (s - norm_mean) / norm_std
+
+        with torch.no_grad():
+            # 目标空间尺寸 (H, W)，时间维度不变
+            T, H, W = s.shape[2], s.shape[3], s.shape[4]
+            target_hw = (int(round(H * scale)), int(round(W * scale)))
+            out = model(s, scale=scale, target_hw=target_hw)
+
+        # 反归一化
+        out = out * norm_std + norm_mean
+
+        # 还原维度
+        if len(latent["samples"].shape) == 4:
+            out = out.squeeze(2)
+
+        out = out.cpu().to(orig_dtype)
+
+        if dev.type == "cuda":
+            torch.cuda.empty_cache()
+
+        return ({"samples": out},)
+
+# ==========================================
+# 节点注册
+# ==========================================
+NODE_CLASS_MAPPINGS = {
+    "MinimaxH3LatentUpscalerNode2D": MinimaxH3LatentUpscalerNode2D,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MinimaxH3LatentUpscalerNode2D": "Minimax H3 Latent Upscaler (2D)",
+}

Comfyui_Minimax_h3_latent_Upscaler/nodes/minimax_h3_latent_upscaler_3d.py

@@ -0,0 +1,655 @@
+"""
+Minimax H3 Latent Upscaler - ComfyUI inference node (pure 3D conv version)
+- [终极融合] 引入时间分块(Temporal Chunking)与 Replicate Padding，解决长视频 OOM 与末尾闪烁
+- [底层黑科技] 显式 .contiguous() 消除隐式显存拷贝尖峰
+- [底层黑科技] Zero-Copy 零拷贝加载模型，防止系统内存(RAM)峰值爆满
+- [底层黑科技] 接入 ComfyUI 原生 soft_empty_cache，彻底清理显存碎片
+- [终极整合] 推理结束后将模型踢回CPU，释放显存给后续节点(可选开关)
+- [终极整合] 强制长宽双向对齐到32的倍数，彻底解决底部光带(Light Banding)问题
+- [终极整合] 放弃 In-place 原地操作，保障 FP16/FP32 下的数值精度与画质
+- [新增] 完美支持 ROCm (AMD GPU) 加速
+- [新增] 支持子文件夹模型管理 (PR #30)
+- [新增] 强制卸载模型开关 (force_unload)
+- 3 resize modes: scale by multiplier / target dimensions / megapixels
+- Auto-detects model architecture (channels, blocks, temporal layout)
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import os
+import glob
+import gc
+import folder_paths
+import re
+from einops import rearrange
+from enum import Enum
+from typing import TypedDict
+
+try:
+    import comfy.model_management as mm
+    HAS_COMFY_MM = True
+except ImportError:
+    HAS_COMFY_MM = False
+
+try:
+    from comfy_api.latest import ComfyExtension, io
+    from typing_extensions import override
+    USE_NEW_API = True
+except ImportError:
+    USE_NEW_API = False
+    class io:
+        class ComfyNode: pass
+        class Schema: pass
+        class NodeOutput: pass
+        class AnyType:
+            @staticmethod
+            def Input(*args, **kwargs): return args[0] if args else "ANY"
+            @staticmethod
+            def Output(*args, **kwargs): return args[0] if args else "ANY"
+        class Combo:
+            @staticmethod
+            def Input(*args, **kwargs): return args[0] if args else "COMBO"
+        class Float:
+            @staticmethod
+            def Input(*args, **kwargs): return "FLOAT"
+        class Int:
+            @staticmethod
+            def Input(*args, **kwargs): return "INT"
+        class Boolean:
+            @staticmethod
+            def Input(*args, **kwargs): return "BOOLEAN"
+        class DynamicCombo:
+            @staticmethod
+            def Input(*args, **kwargs): return args[0] if args else "DYNAMIC"
+            class Option: pass
+    class ComfyExtension: pass
+    def override(func): return func
+
+# ==========================================
+# Register model folder
+# ==========================================
+_LATENT_UPSCALE_FOLDER = "latent_upscale_models"
+if _LATENT_UPSCALE_FOLDER not in folder_paths.folder_names_and_paths:
+    folder_paths.add_model_folder_path(
+        _LATENT_UPSCALE_FOLDER,
+        os.path.join(folder_paths.models_dir, _LATENT_UPSCALE_FOLDER)
+    )
+
+VAE_DOWNSAMPLE = 16
+
+# ==========================================
+# Minimax H3 latent normalization stats (24 channels)
+# ==========================================
+LATENTS_MEAN = [
+    0.858090341091156, -0.9606591463088989, 1.0661640167236328, -0.5090325474739075,
+    -0.2727581858634949, -1.3675414323806763, -0.2553254961967468, -0.26907554268836975,
+    -0.5376840829849243, -0.0464097298681736, 0.6657370328903198, 0.19690127670764923,
+    -0.5460608005523682, -0.4035342037677765, -0.23683024942874908, 0.25928452610969543,
+    -0.30133944749832153, 0.211341992020607, -1.1206848621368408, 0.3581933379173279,
+    -0.04225143790245056, 0.2604829967021942, 0.22864092886447906, 0.7056031823158264
+]
+LATENTS_STD = [
+    1.2223774194717407, 1.2767263650894165, 1.6831774711608887, 1.7549455165863037,
+    1.5636216402053833, 2.194143533706665, 0.9653137922286987, 1.0569885969161987,
+    0.841948926448822, 0.7729952931404114, 1.8955937623977661, 0.946841835975647,
+    0.7996809482574463, 0.44988900423049927, 0.7197399735450745, 0.6936293244361877,
+    2.961095094680786, 2.7694199085235596, 3.0496184825897217, 2.1088054180145264,
+    3.276226282119751, 3.1627357006073, 2.2816812992095947, 2.6127843856811523
+]
+
+def _make_norm_tensors(device, dtype):
+    mean = torch.tensor(LATENTS_MEAN, dtype=dtype, device=device).view(1, -1, 1, 1, 1)
+    std = torch.tensor(LATENTS_STD, dtype=dtype, device=device).view(1, -1, 1, 1, 1)
+    return mean, std
+
+# ==========================================
+# ROCm / Device Helper Functions
+# ==========================================
+def _is_rocm_build():
+    return getattr(torch.version, "hip", None) is not None
+
+def _resolve_device(backend):
+    if backend == "cpu":
+        return torch.device("cpu")
+    if backend == "rocm":
+        if not _is_rocm_build():
+            raise RuntimeError("ROCm was selected, but this PyTorch build has no HIP/ROCm support.")
+        if not torch.cuda.is_available():
+            raise RuntimeError("ROCm was selected, but PyTorch cannot access an AMD GPU.")
+        return torch.device("cuda")
+    if backend == "cuda":
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    raise ValueError(f"Unsupported device backend: {backend}")
+
+def _backend_label(device):
+    if device.type == "cuda" and _is_rocm_build():
+        return f"ROCm/HIP {torch.version.hip}"
+    if device.type == "cuda":
+        return f"CUDA {getattr(torch.version, 'cuda', None) or 'unknown'}"
+    return "CPU"
+
+# ==========================================
+# 3D network components
+# ==========================================
+def normalization(channels):
+    return nn.GroupNorm(32, channels)
+
+def zero_module(module):
+    for p in module.parameters():
+        p.detach().zero_()
+    return module
+
+class AttnBlock3D(nn.Module):
+    def __init__(self, in_channels):
+        super().__init__()
+        self.norm = normalization(in_channels)
+        self.q = nn.Conv3d(in_channels, in_channels, 1)
+        self.k = nn.Conv3d(in_channels, in_channels, 1)
+        self.v = nn.Conv3d(in_channels, in_channels, 1)
+        self.proj_out = nn.Conv3d(in_channels, in_channels, 1)
+
+    def forward(self, x):
+        h = self.norm(x)
+        q = rearrange(self.q(h), "b c t h w -> b 1 (t h w) c")
+        k = rearrange(self.k(h), "b c t h w -> b 1 (t h w) c")
+        v = rearrange(self.v(h), "b c t h w -> b 1 (t h w) c")
+        h = F.scaled_dot_product_attention(q, k, v)
+        h = rearrange(h, "b 1 (t h w) c -> b c t h w", t=x.shape[2], h=x.shape[3], w=x.shape[4])
+        return x + self.proj_out(h)
+
+class ResBlockEmb3D(nn.Module):
+    def __init__(self, channels, emb_channels, dropout=0, out_channels=None):
+        super().__init__()
+        self.out_channels = out_channels or channels
+        self.in_layers = nn.Sequential(
+            normalization(channels), nn.SiLU(),
+            nn.Conv3d(channels, self.out_channels, 3, padding=1),
+        )
+        self.emb_layers = nn.Sequential(
+            nn.SiLU(), nn.Linear(emb_channels, 2 * self.out_channels),
+        )
+        self.out_norm = normalization(self.out_channels)
+        self.out_layers = nn.Sequential(
+            nn.SiLU(), nn.Dropout(p=dropout),
+            zero_module(nn.Conv3d(self.out_channels, self.out_channels, 3, padding=1)),
+        )
+        self.skip = (
+            nn.Conv3d(channels, self.out_channels, 1)
+            if self.out_channels != channels else nn.Identity()
+        )
+
+    def forward(self, x, emb):
+        h = self.in_layers(x)
+        emb_out = self.emb_layers(emb).type(h.dtype)
+        while len(emb_out.shape) < len(h.shape):
+            emb_out = emb_out[..., None]
+        scale, shift = torch.chunk(emb_out, 2, dim=1)
+        h = self.out_norm(h) * (1 + scale) + shift
+        h = self.out_layers(h)
+        return self.skip(x) + h
+
+class TemporalConv(nn.Module):
+    def __init__(self, channels, kernel_size=5):
+        super().__init__()
+        padding = kernel_size // 2
+        self.norm = normalization(channels)
+        self.dwconv = nn.Conv3d(channels, channels,
+                                kernel_size=(kernel_size, 1, 1),
+                                padding=(padding, 0, 0),
+                                groups=channels)
+        self.pwconv = nn.Conv3d(channels, channels, kernel_size=1)
+        nn.init.zeros_(self.pwconv.weight)
+        nn.init.zeros_(self.pwconv.bias)
+
+    def forward(self, x):
+        identity = x
+        h = self.norm(x)
+        h = F.silu(h)
+        h = self.dwconv(h)
+        h = self.pwconv(h)
+        return identity + h
+
+# ==========================================
+# Pure-3D backbone with Temporal Chunking
+# ==========================================
+class LatentResizer3D(nn.Module):
+    def __init__(self, in_channels=24, in_blocks=12, out_blocks=12,
+                 channels=512, dropout=0.1, attn=False,
+                 temporal_every=2, temporal_kernel=5):
+        super().__init__()
+        self.conv_in = nn.Conv3d(in_channels, channels, 3, padding=1)
+        embed_dim = 64
+        self.embed = nn.Sequential(
+            nn.Linear(1, embed_dim), nn.SiLU(), nn.Linear(embed_dim, embed_dim))
+
+        self.in_blocks = nn.ModuleList()
+        for b in range(in_blocks):
+            if (b == 1 or b == in_blocks - 1) and attn:
+                self.in_blocks.append(AttnBlock3D(channels))
+            self.in_blocks.append(ResBlockEmb3D(channels, embed_dim, dropout))
+            if temporal_every > 0 and b % temporal_every == 0:
+                self.in_blocks.append(TemporalConv(channels, temporal_kernel))
+
+        self.out_blocks = nn.ModuleList()
+        for b in range(out_blocks):
+            if (b == 1 or b == out_blocks - 1) and attn:
+                self.out_blocks.append(AttnBlock3D(channels))
+            self.out_blocks.append(ResBlockEmb3D(channels, embed_dim, dropout))
+            if temporal_every > 0 and b % temporal_every == 0:
+                self.out_blocks.append(TemporalConv(channels, temporal_kernel))
+
+        self.norm_out = normalization(channels)
+        self.conv_out = nn.Conv3d(channels, in_channels, 3, padding=1)
+
+    def forward(self, x, scale=None, target_size=None, enable_chunking=True):
+        if target_size is not None:
+            size = target_size
+        elif scale is not None:
+            size = tuple(int(round(s * scale)) for s in x.shape[-3:])
+        else:
+            return x
+
+        if size == x.shape[-3:]:
+            return x
+
+        B, C, T, H, W = x.shape
+
+        tk = 0
+        for b in self.in_blocks:
+            if isinstance(b, TemporalConv):
+                tk = b.dwconv.weight.shape[2]
+                break
+
+        overlap = tk
+        chunk = 32
+
+        if not enable_chunking or T <= chunk:
+            return self._forward_seg(x, scale, size)
+
+        print(f"[MinimaxH3-3D] temporal chunking: T={T} chunks={(T + chunk - 1) // chunk} overlap={overlap}")
+
+        x_padded = F.pad(x, (0, 0, 0, 0, overlap, overlap), mode='replicate')
+
+        out_full = torch.zeros(B, C, T, size[-2], size[-1], device=x.device, dtype=x.dtype)
+        weight_full = torch.zeros(1, 1, T, 1, 1, device=x.device, dtype=x.dtype)
+
+        start = 0
+        while start < T:
+            seg_start = start
+            seg_end = min(T, start + chunk)
+            out_start = max(0, seg_start - overlap)
+            out_end = min(T, seg_end + overlap)
+            lo = max(0, out_start - overlap)
+            hi = min(T + 2 * overlap, out_end + overlap)
+
+            seg = x_padded[:, :, lo:hi].contiguous()
+            seg_size = (hi - lo, size[-2], size[-1])
+            seg_out = self._forward_seg(seg, scale, seg_size)
+
+            s0 = (out_start + overlap) - lo
+            s1 = s0 + (out_end - out_start)
+            valid_out = seg_out[:, :, s0:s1]
+            n_valid = out_end - out_start
+
+            weight = torch.ones(n_valid, device=x.device, dtype=x.dtype)
+            if seg_start > out_start:
+                blend_len = seg_start - out_start
+                weight[:blend_len] = torch.arange(1, blend_len + 1, device=x.device, dtype=x.dtype) / (blend_len + 1)
+            if out_end > seg_end:
+                blend_len = out_end - seg_end
+                weight[-blend_len:] = torch.arange(blend_len, 0, -1, device=x.device, dtype=x.dtype) / (blend_len + 1)
+
+            out_full[:, :, out_start:out_end] += valid_out * weight.view(1, 1, n_valid, 1, 1)
+            weight_full[:, :, out_start:out_end] += weight.view(1, 1, n_valid, 1, 1)
+
+            start += chunk
+            del seg, seg_out, valid_out
+            if start % (chunk * 4) == 0:
+                gc.collect()
+
+        out_full = out_full / weight_full.clamp(min=1e-8)
+        return out_full
+
+    def _forward_seg(self, x, scale, size):
+        scale_emb = torch.tensor(
+            [scale - 1 if scale is not None else 0.0],
+            dtype=x.dtype, device=x.device).unsqueeze(0)
+        emb = self.embed(scale_emb)
+
+        x = self.conv_in(x)
+        for b in self.in_blocks:
+            if isinstance(b, ResBlockEmb3D):
+                emb_t = emb.expand(x.shape[0], -1)
+                x = b(x, emb_t)
+            else:
+                x = b(x)
+
+        x = F.interpolate(x, size=size, mode="trilinear", align_corners=False)
+
+        for b in self.out_blocks:
+            if isinstance(b, ResBlockEmb3D):
+                emb_t = emb.expand(x.shape[0], -1)
+                x = b(x, emb_t)
+            else:
+                x = b(x)
+
+        x = self.norm_out(x)
+        x = F.silu(x)
+        x = self.conv_out(x)
+        return x
+
+# ==========================================
+# Model loading
+# ==========================================
+MODEL_CACHE = {}
+
+def get_models_dir():
+    return folder_paths.get_folder_paths(_LATENT_UPSCALE_FOLDER)[0]
+
+def scan_models():
+    names = [
+        name for name in folder_paths.get_filename_list(_LATENT_UPSCALE_FOLDER)
+        if os.path.splitext(name)[1].lower() in (".pth", ".safetensors")
+    ]
+    return names if names else [f"(place models in: {get_models_dir()})"]
+
+def _load_raw_sd(path):
+    if path.endswith('.safetensors'):
+        try:
+            from safetensors import safe_open
+            with safe_open(path, framework="pt", device="cpu") as f:
+                sd = {k: f.get_tensor(k) for k in f.keys()}
+        except ImportError:
+            from safetensors.torch import load_file
+            sd = load_file(path, device='cpu')
+    else:
+        sd = torch.load(path, map_location='cpu', weights_only=False)
+
+    if isinstance(sd, dict) and 'model' in sd:
+        sd = sd['model']
+    sd = {k: v.to(torch.float16) if v.dtype == torch.float8_e4m3fn else v
+          for k, v in sd.items()}
+    return sd
+
+def _extract_upscaler_sd(sd):
+    if any(k.startswith("upscaler.") for k in sd):
+        return {k[len("upscaler."):]: v for k, v in sd.items() if k.startswith("upscaler.")}
+    return sd
+
+def _detect_arch(sd):
+    cfg = {
+        "in_channels": 24, "in_blocks": 12, "out_blocks": 12, "channels": 512,
+        "dropout": 0.1, "attn": False, "temporal_every": 2, "temporal_kernel": 5,
+    }
+    conv_key = 'conv_in.weight'
+    if conv_key in sd:
+        cfg["in_channels"] = sd[conv_key].shape[1]
+        cfg["channels"] = sd[conv_key].shape[0]
+
+    in_ids, out_ids = set(), set()
+    temporal_in_indices, temporal_out_indices = set(), set()
+    for k in sd.keys():
+        m = re.match(r'in_blocks\.(\d+)\.in_layers\.', k)
+        if m: in_ids.add(int(m.group(1)))
+        m = re.match(r'out_blocks\.(\d+)\.in_layers\.', k)
+        if m: out_ids.add(int(m.group(1)))
+        m = re.match(r'in_blocks\.(\d+)\.dwconv\.weight', k)
+        if m: temporal_in_indices.add(int(m.group(1)))
+        m = re.match(r'out_blocks\.(\d+)\.dwconv\.weight', k)
+        if m: temporal_out_indices.add(int(m.group(1)))
+
+    if in_ids: cfg["in_blocks"] = len(in_ids)
+    if out_ids: cfg["out_blocks"] = len(out_ids)
+
+    if temporal_in_indices or temporal_out_indices:
+        cfg["temporal_every"] = 2
+        for k in sd.keys():
+            if 'dwconv.weight' in k and k.endswith('dwconv.weight'):
+                cfg["temporal_kernel"] = sd[k].shape[2]
+                break
+    else:
+        cfg["temporal_every"] = 0
+
+    if any('attn' in k for k in sd): cfg["attn"] = True
+    cfg["attn"] = False
+    return cfg
+
+def load_model(name, device, precision):
+    backend_lbl = _backend_label(device)
+    cache_key = f"{name}::{backend_lbl}::{precision}"
+    if cache_key in MODEL_CACHE:
+        model = MODEL_CACHE[cache_key]
+        return model.to(device, non_blocking=True)
+
+    try:
+        path = folder_paths.get_full_path_or_raise(_LATENT_UPSCALE_FOLDER, name)
+    except Exception as e:
+        raise FileNotFoundError(f"Model file not found: {name}") from e
+
+    raw_sd = _load_raw_sd(path)
+    up_sd = _extract_upscaler_sd(raw_sd)
+    cfg = _detect_arch(up_sd)
+
+    model = LatentResizer3D(
+        in_channels=cfg["in_channels"], in_blocks=cfg["in_blocks"], out_blocks=cfg["out_blocks"],
+        channels=cfg["channels"], dropout=cfg["dropout"], attn=cfg["attn"],
+        temporal_every=cfg["temporal_every"], temporal_kernel=cfg["temporal_kernel"],
+    )
+    model.load_state_dict(up_sd, strict=True)
+    dtype = {"fp32": torch.float32, "fp16": torch.float16, "bf16": torch.bfloat16}.get(precision, torch.float32)
+    model = model.to(device).eval().requires_grad_(False)
+    if dtype != torch.float32:
+        model = model.to(dtype)
+
+    MODEL_CACHE[cache_key] = model
+    print(f"[MinimaxH3-3D] Loaded upscale model: {name}")
+    print(f"  Params: {sum(p.numel() for p in model.parameters()):,} | "
+          f"Attn: forced off | Temporal: {'on' if cfg['temporal_every'] > 0 else 'off'} "
+          f"(every={cfg['temporal_every']}, kernel={cfg['temporal_kernel']}) | "
+          f"Backend: {backend_lbl} | Precision: {precision}")
+    return model
+
+# ==========================================
+# ComfyUI node (new API)
+# ==========================================
+class UpscaleMode(str, Enum):
+    SCALE_BY = "scale by multiplier"
+    TARGET_DIMENSIONS = "target dimensions"
+    MEGAPIXELS = "megapixels"
+
+class UpscaleConfig(TypedDict):
+    mode: UpscaleMode
+    scale: float
+    width: int
+    height: int
+    megapixels: float
+
+class MinimaxH3LatentUpscaler3D(io.ComfyNode):
+    """Minimax H3 latent upscaler with Temporal Chunking and pixel-space alignment."""
+
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="MinimaxH3LatentUpscaler3D",
+            display_name="Minimax H3 Latent Upscaler (3D)",
+            category="video/MinimaxH3",
+            search_aliases=["minimax", "h3", "latent", "upscale", "3d"],
+            inputs=[
+                io.AnyType.Input("latent", tooltip="Input latent (image or video)."),
+                io.Combo.Input("model_name", options=scan_models(), tooltip="Minimax H3 upscale model."),
+
+                io.DynamicCombo.Input(
+                    "mode",
+                    tooltip="How the target size is computed.",
+                    options=[
+                        io.DynamicCombo.Option(UpscaleMode.SCALE_BY, [
+                            io.Float.Input("scale", default=2.0, min=1.0, max=4.0, step=0.05, tooltip="Upscale factor."),
+                        ]),
+                        io.DynamicCombo.Option(UpscaleMode.TARGET_DIMENSIONS, [
+                            io.Int.Input("width", default=1280, min=64, max=8192, step=8, tooltip="Target pixel width."),
+                            io.Int.Input("height", default=704, min=64, max=8192, step=8, tooltip="Target pixel height.")
+                        ]),
+                        io.DynamicCombo.Option(UpscaleMode.MEGAPIXELS, [
+                            io.Float.Input("megapixels", default=1.0, min=0.1, max=16.0, step=0.1, tooltip="Target megapixels.")
+                        ])
+                    ],
+                ),
+
+                io.Int.Input("align", default=32, min=1, max=512, step=1,
+                             tooltip="Pixel-space alignment. 32 is strictly recommended."),
+
+                # ---- 推理行为开关组 ----
+                io.Boolean.Input("enable_temporal_chunking", default=True,
+                                 tooltip="Enable temporal chunking to save VRAM for long videos and fix end-frame flickering."),
+                io.Boolean.Input("force_unload", default=True,
+                                 tooltip="Unload model to CPU after inference to free VRAM for subsequent nodes. "
+                                         "Disable if you run this node repeatedly to avoid reload overhead."),
+
+                # ---- 硬件 / 精度选项组 ----
+                io.Combo.Input("device", options=["cuda", "rocm", "cpu"], default="cuda"),
+                io.Combo.Input("precision", options=["fp32", "fp16", "bf16"], default="fp16"),
+            ],
+            outputs=[
+                io.AnyType.Output("latent", tooltip="Upscaled latent."),
+            ],
+        )
+
+    @classmethod
+    def execute(cls, latent: dict, model_name: str, mode: UpscaleConfig,
+                align: int, enable_temporal_chunking: bool, force_unload: bool,
+                device: str, precision: str) -> io.NodeOutput:
+
+        if model_name.startswith('('):
+            raise ValueError("Please place model files into the latent_upscale_models directory")
+
+        selected_mode = mode["mode"]
+        src = latent["samples"]
+
+        # --- MiniMax H3 AV latent support ---------------------------------
+        # ComfyUI packs H3's joint video+audio latent as a NestedTensor:
+        #   tensors[0] = video (B, 24, T, H, W)
+        #   tensors[1] = audio (B, 32, ...)
+        # Only the video part is spatially upscalable; the audio latent is
+        # carried through untouched and re-packed on the way out.
+        audio_part = None
+        if getattr(src, "is_nested", False):
+            if len(src.tensors) != 2:
+                raise ValueError(
+                    f"Expected a MiniMax H3 AV latent (video+audio), got a nested "
+                    f"tensor with {len(src.tensors)} components."
+                )
+            src, audio_part = src.tensors[0], src.tensors[1]
+            print(f"[MinimaxH3-3D] AV latent detected: video {tuple(src.shape)}, "
+                  f"audio {tuple(audio_part.shape)} (audio passed through).")
+        # -------------------------------------------------------------------
+
+        orig_dtype = src.dtype
+        was_4d = (src.ndim == 4)
+
+        dev = _resolve_device(device)
+        compute_dtype = {"fp32": torch.float32, "fp16": torch.float16, "bf16": torch.bfloat16}[precision]
+
+        s = src.to(device=dev, dtype=compute_dtype, copy=True)
+        if was_4d:
+            s = s.unsqueeze(2)
+
+        b, c, t, h_in, w_in = s.shape
+        downsample = VAE_DOWNSAMPLE
+
+        # 1. Calculate Target Size
+        if selected_mode == UpscaleMode.SCALE_BY:
+            scale_val = mode["scale"]
+            w_pixel_target = w_in * downsample * scale_val
+            h_pixel_target = h_in * downsample * scale_val
+            effective_scale = scale_val
+        elif selected_mode == UpscaleMode.TARGET_DIMENSIONS:
+            w_pixel_target = float(mode["width"])
+            h_pixel_target = float(mode["height"])
+            effective_scale = (w_pixel_target / (w_in * downsample) + h_pixel_target / (h_in * downsample)) / 2.0
+        elif selected_mode == UpscaleMode.MEGAPIXELS:
+            mp = mode["megapixels"]
+            target_pixels = mp * 1024 * 1024
+            aspect_ratio = w_in / h_in
+            h_pixel_target = (target_pixels / aspect_ratio) ** 0.5
+            w_pixel_target = h_pixel_target * aspect_ratio
+            effective_scale = (w_pixel_target / (w_in * downsample) + h_pixel_target / (h_in * downsample)) / 2.0
+        else:
+            raise ValueError(f"Unsupported mode: {selected_mode}")
+
+        # 2. Pixel-space alignment (双向对齐)
+        alignment = max(1, align)
+        w_pixel_aligned = round(w_pixel_target / alignment) * alignment
+        h_pixel_aligned = round(h_pixel_target / alignment) * alignment
+
+        w_pixel_final = round(w_pixel_aligned / downsample) * downsample
+        h_pixel_final = round(h_pixel_aligned / downsample) * downsample
+
+        w_out = max(1, int(w_pixel_final // downsample))
+        h_out = max(1, int(h_pixel_final // downsample))
+
+        if effective_scale < 1.0 and (w_out < w_in or h_out < h_in):
+            raise ValueError("This model only supports upscaling (effective scale >= 1.0).")
+
+        if w_out == w_in and h_out == h_in:
+            return io.NodeOutput(latent)
+
+        print(f"[MinimaxH3-3D] Latent {w_in}x{h_in} -> {w_out}x{h_out} | "
+              f"Pixels {w_out * downsample}x{h_out * downsample} | scale={effective_scale:.3f}")
+
+        # 3. Inference
+        model = load_model(model_name, dev, precision)
+        norm_mean, norm_std = _make_norm_tensors(dev, compute_dtype)
+
+        with torch.inference_mode():
+            s_norm = (s - norm_mean) / norm_std
+            del s
+
+            out = model(s_norm, scale=effective_scale, target_size=(t, h_out, w_out),
+                        enable_chunking=enable_temporal_chunking)
+
+            del s_norm
+            out = out * norm_std + norm_mean
+
+        if was_4d:
+            out = out.squeeze(2)
+
+        out = out.to(device="cpu", dtype=orig_dtype, non_blocking=True)
+
+        # 4. VRAM Management
+        if dev.type == "cuda":
+            if force_unload:
+                model.to("cpu", non_blocking=True)
+                print("[MinimaxH3-3D] ✅ Model offloaded to CPU. VRAM released.")
+            if HAS_COMFY_MM:
+                mm.soft_empty_cache()
+            else:
+                torch.cuda.empty_cache()
+            gc.collect()
+
+        if audio_part is not None:
+            import comfy.nested_tensor
+            audio_out = audio_part.to(device=out.device)
+            return io.NodeOutput(
+                {"samples": comfy.nested_tensor.NestedTensor((out, audio_out))}
+            )
+
+        return io.NodeOutput({"samples": out})
+
+# ==========================================
+# Registration
+# ==========================================
+if USE_NEW_API:
+    class MinimaxH3Extension(ComfyExtension):
+        @override
+        async def get_node_list(self) -> list[type[io.ComfyNode]]:
+            return [MinimaxH3LatentUpscaler3D]
+
+    async def comfy_entrypoint() -> MinimaxH3Extension:
+        return MinimaxH3Extension()
+
+NODE_CLASS_MAPPINGS = {
+    "MinimaxH3LatentUpscaler3D": MinimaxH3LatentUpscaler3D,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "MinimaxH3LatentUpscaler3D": "Minimax H3 Latent Upscaler (3D)",
+}

Comfyui_Minimax_h3_latent_Upscaler/workflow_templates/minimax_h3_i2v_Latent Upscaler example workflow2.json

@@ -0,0 +1,3003 @@
+{
+  "id": "b775e54a-5a89-47be-943b-be5a8059239c",
+  "revision": 0,
+  "last_node_id": 42,
+  "last_link_id": 58,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        3182.018173615327,
+        5760.395250046636
+      ],
+      "size": [
+        210,
+        334
+      ],
+      "flags": {},
+      "order": 34,
+      "mode": 4,
+      "inputs": [
+        {
+          "label": "图像",
+          "name": "images",
+          "type": "IMAGE",
+          "link": 1
+        },
+        {
+          "label": "音频",
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 2
+        },
+        {
+          "label": "批次管理",
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        },
+        {
+          "label": "帧率",
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "widget": {
+            "name": "frame_rate"
+          },
+          "link": null
+        },
+        {
+          "label": "循环次数",
+          "name": "loop_count",
+          "type": "INT",
+          "widget": {
+            "name": "loop_count"
+          },
+          "link": null
+        },
+        {
+          "label": "文件名前缀",
+          "name": "filename_prefix",
+          "type": "STRING",
+          "widget": {
+            "name": "filename_prefix"
+          },
+          "link": null
+        },
+        {
+          "label": "格式",
+          "name": "format",
+          "type": "COMBO",
+          "widget": {
+            "name": "format"
+          },
+          "link": null
+        },
+        {
+          "label": "Ping-Pong",
+          "name": "pingpong",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "pingpong"
+          },
+          "link": null
+        },
+        {
+          "label": "保存到输出文件夹",
+          "name": "save_output",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "save_output"
+          },
+          "link": null
+        },
+        {
+          "label": "保存元数据",
+          "name": "save_metadata",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "save_metadata"
+          },
+          "link": null
+        },
+        {
+          "label": "修剪音频",
+          "name": "trim_to_audio",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "trim_to_audio"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "文件名",
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "title": "合并为视频",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        },
+        "cnr_id": "comfyui-videohelpersuite",
+        "ver": "4ee72c065db22c9d96c2427954dc69e7b908444b",
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001-audio.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4",
+            "frame_rate": 24,
+            "workflow": "AnimateDiff_00001.png",
+            "fullpath": "D:\\AI\\ComfyUI-aki-v2\\ComfyUI\\temp\\AnimateDiff_00001-audio.mp4"
+          }
+        }
+      },
+      "widgets_values_named": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001-audio.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4",
+            "frame_rate": 24,
+            "workflow": "AnimateDiff_00001.png",
+            "fullpath": "D:\\AI\\ComfyUI-aki-v2\\ComfyUI\\temp\\AnimateDiff_00001-audio.mp4"
+          }
+        }
+      }
+    },
+    {
+      "id": 2,
+      "type": "VAEDecodeAudio",
+      "pos": [
+        3176.503986022757,
+        5589.336094022448
+      ],
+      "size": [
+        230.98336128023698,
+        46.99687563323096
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 31,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 3
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": [
+            2
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecodeAudio"
+      }
+    },
+    {
+      "id": 3,
+      "type": "SplitSigmas",
+      "pos": [
+        2823.6430428367066,
+        5558.604634124167
+      ],
+      "size": [
+        308.3164287851357,
+        78
+      ],
+      "flags": {},
+      "order": 24,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "high_sigmas",
+          "type": "SIGMAS",
+          "links": [
+            44
+          ]
+        },
+        {
+          "name": "low_sigmas",
+          "type": "SIGMAS",
+          "links": []
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.0",
+        "Node name for S&R": "SplitSigmas"
+      },
+      "widgets_values": [
+        4
+      ],
+      "widgets_values_named": {
+        "step": 4
+      },
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 4,
+      "type": "SaveVideo",
+      "pos": [
+        4514.64060004999,
+        5293.5022981353995
+      ],
+      "size": [
+        283.126933720908,
+        106
+      ],
+      "flags": {},
+      "order": 41,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 6
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "SaveVideo"
+      },
+      "widgets_values": [
+        "video/MiniMax_H3",
+        "auto",
+        "auto"
+      ],
+      "widgets_values_named": {
+        "filename_prefix": "video/MiniMax_H3",
+        "format": "auto",
+        "codec": "auto"
+      }
+    },
+    {
+      "id": 5,
+      "type": "ManualSigmas",
+      "pos": [
+        3908.508146540855,
+        5496.223458932069
+      ],
+      "size": [
+        308.3164287851357,
+        58
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "sigmas",
+          "name": "sigmas",
+          "type": "STRING",
+          "widget": {
+            "name": "sigmas"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "SIGMAS",
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": []
+        }
+      ],
+      "title": "5 step Sigmas",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "ManualSigmas",
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      },
+      "widgets_values": [
+        "0.9231, 0.8780, 0.8000, 0.6316, 0.3158, 0.0000"
+      ],
+      "widgets_values_named": {
+        "sigmas": "0.9231, 0.8780, 0.8000, 0.6316, 0.3158, 0.0000"
+      }
+    },
+    {
+      "id": 6,
+      "type": "VAEDecode",
+      "pos": [
+        3176.503986022757,
+        5487.163373330627
+      ],
+      "size": [
+        230.98336128023698,
+        46
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 32,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            1
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 7,
+      "type": "VAELoader",
+      "pos": [
+        1022.1892320604375,
+        5463.23147307899
+      ],
+      "size": [
+        640,
+        70
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8,
+            11,
+            16,
+            28
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAELoader",
+        "models": [
+          {
+            "name": "minimax_h3_video_vae_fp16.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors",
+            "directory": "vae"
+          }
+        ]
+      },
+      "widgets_values": [
+        "minimax_h3_video_vae_fp16.safetensors"
+      ],
+      "widgets_values_named": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      }
+    },
+    {
+      "id": 8,
+      "type": "BasicScheduler",
+      "pos": [
+        2823.6430428367066,
+        5388.297356844566
+      ],
+      "size": [
+        308.3164287851357,
+        111.22673919547651
+      ],
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 9
+        }
+      ],
+      "outputs": [
+        {
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            5
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "BasicScheduler"
+      },
+      "widgets_values": [
+        "simple",
+        8,
+        1
+      ],
+      "widgets_values_named": {
+        "scheduler": "simple",
+        "steps": 8,
+        "denoise": 1
+      }
+    },
+    {
+      "id": 9,
+      "type": "LoadImage",
+      "pos": [
+        1343.819198857278,
+        5833.004557721189
+      ],
+      "size": [
+        290,
+        330
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            17,
+            29
+          ]
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "09-55-07_00001.jpg",
+        "image"
+      ],
+      "widgets_values_named": {
+        "image": "09-55-07_00001.jpg",
+        "upload": "image"
+      }
+    },
+    {
+      "id": 10,
+      "type": "LoadImage",
+      "pos": [
+        1676.074249167948,
+        5831.024334938233
+      ],
+      "size": [
+        290,
+        330
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            18,
+            30
+          ]
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "09-55-07_00001.jpg",
+        "image"
+      ],
+      "widgets_values_named": {
+        "image": "09-55-07_00001.jpg",
+        "upload": "image"
+      }
+    },
+    {
+      "id": 11,
+      "type": "VAEDecode",
+      "pos": [
+        4244.023207065458,
+        5433.788422959353
+      ],
+      "size": [
+        230,
+        60
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 38,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 10
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 11
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            53
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 12,
+      "type": "VAEDecodeAudio",
+      "pos": [
+        4246.139687501349,
+        5553.202878575346
+      ],
+      "size": [
+        230,
+        60
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 39,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 12
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 13
+        }
+      ],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": [
+            54
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecodeAudio"
+      }
+    },
+    {
+      "id": 13,
+      "type": "VAELoader",
+      "pos": [
+        1022.1892320604375,
+        5593.23147307899
+      ],
+      "size": [
+        639.8453239311636,
+        58
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            4,
+            13
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAELoader",
+        "models": [
+          {
+            "name": "minimax_h3_audio_vae_fp32.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors",
+            "directory": "vae"
+          }
+        ]
+      },
+      "widgets_values": [
+        "minimax_h3_audio_vae_fp32.safetensors"
+      ],
+      "widgets_values_named": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      }
+    },
+    {
+      "id": 14,
+      "type": "PrimitiveStringMultiline",
+      "pos": [
+        1334.8058493668113,
+        6214.899932141244
+      ],
+      "size": [
+        636.5456880478732,
+        296.4539339258454
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            19,
+            31
+          ]
+        }
+      ],
+      "title": "提示词",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "PrimitiveStringMultiline"
+      },
+      "widgets_values": [
+        "资产角色：\n<Picture 1>\n国风动漫少女，深棕色发髻点缀红梅与蝶形发饰，身穿白金红相间的抹胸上衣与飘逸薄纱灯笼裤，周身环绕金红流光与炽炎花瓣特效。\n<Picture 2>\n硬派白发战将，身穿暗红色皮革长款风衣、黑色内衬与战术皮裤，手持重剑与双枪，周身散发冷冽红黑魔力气浪。\n\n一个低机位推近镜头框住\n<Picture 1>\n与\n<Picture 2>\n在废墟长廊两端对峙。\n<Picture 1>\n率先启动超音速贴地冲刺，足尖踏出金红烈焰莲华，甩出赤红绫缎如游龙贯空；\nthe camera cuts to\n侧面跟摇特写，\n<Picture 2>\n拔出重剑横向重劈，刀锋与炽炎绫缎剧烈碰撞，火星与雷光四向迸射，气浪撕裂地面石板。\nthe shot transitions to\n俯冲环绕镜头，\n<Picture 1>\n借力凌空翻腾，双掌结印召唤暴雨般金红火蝶与符文剑气垂直轰炸；\n<Picture 2>\n单手举剑格挡，魔力红光护盾展开，随即甩动红风衣滑步侧移，拔枪极速连射，火舌与剑气在半空接连引爆。\nthe camera dynamically follows\n贴地高速滑移，\n<Picture 1>\n在弹雨残影中多维瞬闪，瞬身突进至\n<Picture 2>\n身前旋身横扫，赤焰气刃斩开风衣下摆；\nthe shot changes to\n极速下坠定点特写，\n<Picture 2>\n反手抽刀上挑震开攻击，\n<Picture 1>\n空中旋身单手撑地滑退数米，\n<Picture 1>\n与\n<Picture 2>\n同时稳住身形横刃相对，周身烈火与魔能疯狂暴涨，在最强杀意临界点定格。\noverall_soundscape: Explosive shockwaves crack the stone ground as steel clashes with fiery energy ribbons. Gunfire roars in rapid bursts followed by the sizzling hum of burning petals and swirling demonic aura.non_diegetic_music: High-octane heavy metal hybrid with aggressive electric guitar riffs, pounding industrial drums, and intense symphonic brass, cutting off sharply on the final clash."
+      ],
+      "widgets_values_named": {
+        "value": "资产角色：\n<Picture 1>\n国风动漫少女，深棕色发髻点缀红梅与蝶形发饰，身穿白金红相间的抹胸上衣与飘逸薄纱灯笼裤，周身环绕金红流光与炽炎花瓣特效。\n<Picture 2>\n硬派白发战将，身穿暗红色皮革长款风衣、黑色内衬与战术皮裤，手持重剑与双枪，周身散发冷冽红黑魔力气浪。\n\n一个低机位推近镜头框住\n<Picture 1>\n与\n<Picture 2>\n在废墟长廊两端对峙。\n<Picture 1>\n率先启动超音速贴地冲刺，足尖踏出金红烈焰莲华，甩出赤红绫缎如游龙贯空；\nthe camera cuts to\n侧面跟摇特写，\n<Picture 2>\n拔出重剑横向重劈，刀锋与炽炎绫缎剧烈碰撞，火星与雷光四向迸射，气浪撕裂地面石板。\nthe shot transitions to\n俯冲环绕镜头，\n<Picture 1>\n借力凌空翻腾，双掌结印召唤暴雨般金红火蝶与符文剑气垂直轰炸；\n<Picture 2>\n单手举剑格挡，魔力红光护盾展开，随即甩动红风衣滑步侧移，拔枪极速连射，火舌与剑气在半空接连引爆。\nthe camera dynamically follows\n贴地高速滑移，\n<Picture 1>\n在弹雨残影中多维瞬闪，瞬身突进至\n<Picture 2>\n身前旋身横扫，赤焰气刃斩开风衣下摆；\nthe shot changes to\n极速下坠定点特写，\n<Picture 2>\n反手抽刀上挑震开攻击，\n<Picture 1>\n空中旋身单手撑地滑退数米，\n<Picture 1>\n与\n<Picture 2>\n同时稳住身形横刃相对，周身烈火与魔能疯狂暴涨，在最强杀意临界点定格。\noverall_soundscape: Explosive shockwaves crack the stone ground as steel clashes with fiery energy ribbons. Gunfire roars in rapid bursts followed by the sizzling hum of burning petals and swirling demonic aura.non_diegetic_music: High-octane heavy metal hybrid with aggressive electric guitar riffs, pounding industrial drums, and intense symphonic brass, cutting off sharply on the final clash."
+      },
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 15,
+      "type": "ResolutionSelector",
+      "pos": [
+        1757.462855425223,
+        5540.950633219013
+      ],
+      "size": [
+        270.983361280237,
+        126
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "showAdvanced": false,
+      "inputs": [
+        {
+          "name": "megapixels",
+          "type": "FLOAT",
+          "widget": {
+            "name": "megapixels"
+          },
+          "link": 14
+        }
+      ],
+      "outputs": [
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            32,
+            47
+          ]
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            33,
+            48
+          ]
+        }
+      ],
+      "title": "Resolution Selector (Size)",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "ResolutionSelector"
+      },
+      "widgets_values": [
+        "16:9 (Widescreen)",
+        1,
+        32
+      ],
+      "widgets_values_named": {
+        "aspect_ratio": "16:9 (Widescreen)",
+        "megapixels": 1,
+        "multiple": 32
+      },
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 16,
+      "type": "MiniMaxH3ImageToVideo",
+      "pos": [
+        1765.8316212818622,
+        5272.664531479656
+      ],
+      "size": [
+        257.521811503208,
+        220
+      ],
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 15
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 16
+        },
+        {
+          "name": "first_frame",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": 17
+        },
+        {
+          "name": "last_frame",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": 18
+        },
+        {
+          "name": "prompt",
+          "type": "STRING",
+          "widget": {
+            "name": "prompt"
+          },
+          "link": 19
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "widget": {
+            "name": "width"
+          },
+          "link": 20
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "widget": {
+            "name": "height"
+          },
+          "link": 21
+        },
+        {
+          "name": "length",
+          "type": "INT",
+          "widget": {
+            "name": "length"
+          },
+          "link": 22
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            50
+          ]
+        },
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            45
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.32.0",
+        "Node name for S&R": "MiniMaxH3ImageToVideo"
+      },
+      "widgets_values": [
+        "",
+        1344,
+        768,
+        73
+      ],
+      "widgets_values_named": {
+        "prompt": "",
+        "width": 1344,
+        "height": 768,
+        "length": 73
+      }
+    },
+    {
+      "id": 17,
+      "type": "ModelPreviewOverrideKJ",
+      "pos": [
+        2417.54562531032,
+        5122.681252342183
+      ],
+      "size": [
+        319.39965668617606,
+        411.607317175336
+      ],
+      "flags": {},
+      "order": 27,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 23
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        },
+        {
+          "name": "preview_frames",
+          "type": "INT",
+          "widget": {
+            "name": "preview_frames"
+          },
+          "link": 24
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            49
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        },
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "3f20054214fec9f9234fd3841ae6f1e4287948f6",
+        "Node name for S&R": "ModelPreviewOverrideKJ"
+      },
+      "widgets_values": [
+        1024,
+        80,
+        true,
+        9,
+        12,
+        "taeh3.safetensors",
+        ""
+      ],
+      "widgets_values_named": {
+        "max_resolution": 1024,
+        "jpeg_quality": 80,
+        "suppress_default_preview": true,
+        "preview_frames": 9,
+        "preview_fps": 12,
+        "tiny_vae": "taeh3.safetensors",
+        "preview": ""
+      },
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 18,
+      "type": "LTXVConcatAVLatent",
+      "pos": [
+        3519.8709916998964,
+        5544.8126149799
+      ],
+      "size": [
+        286.8360679651149,
+        46
+      ],
+      "flags": {},
+      "order": 36,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "video_latent",
+          "name": "video_latent",
+          "type": "LATENT",
+          "link": 25
+        },
+        {
+          "label": "audio_latent",
+          "name": "audio_latent",
+          "type": "LATENT",
+          "link": 26
+        }
+      ],
+      "outputs": [
+        {
+          "label": "latent",
+          "name": "latent",
+          "type": "LATENT",
+          "links": [
+            40
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "LTXVConcatAVLatent",
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      }
+    },
+    {
+      "id": 19,
+      "type": "MiniMaxH3ImageToVideo",
+      "pos": [
+        2053.827625494082,
+        5271.729493415262
+      ],
+      "size": [
+        254.68831917761077,
+        220
+      ],
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 27
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 28
+        },
+        {
+          "name": "first_frame",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": 29
+        },
+        {
+          "name": "last_frame",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": 30
+        },
+        {
+          "name": "prompt",
+          "type": "STRING",
+          "widget": {
+            "name": "prompt"
+          },
+          "link": 31
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "widget": {
+            "name": "width"
+          },
+          "link": 32
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "widget": {
+            "name": "height"
+          },
+          "link": 33
+        },
+        {
+          "name": "length",
+          "type": "INT",
+          "widget": {
+            "name": "length"
+          },
+          "link": 34
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            52
+          ]
+        },
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": []
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.32.0",
+        "Node name for S&R": "MiniMaxH3ImageToVideo"
+      },
+      "widgets_values": [
+        "",
+        1344,
+        768,
+        73
+      ],
+      "widgets_values_named": {
+        "prompt": "",
+        "width": 1344,
+        "height": 768,
+        "length": 73
+      }
+    },
+    {
+      "id": 20,
+      "type": "PrimitiveFloat",
+      "pos": [
+        1032.884221724624,
+        6014.891597108754
+      ],
+      "size": [
+        270,
+        70
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            35
+          ]
+        }
+      ],
+      "title": "Float (Duration)",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "PrimitiveFloat"
+      },
+      "widgets_values": [
+        5
+      ],
+      "widgets_values_named": {
+        "value": 5
+      },
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 21,
+      "type": "CLIPLoader",
+      "pos": [
+        1022.1892320604375,
+        5283.23147307899
+      ],
+      "size": [
+        640,
+        120
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            15,
+            27
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "CLIPLoader",
+        "models": [
+          {
+            "name": "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+            "directory": "text_encoders"
+          }
+        ]
+      },
+      "widgets_values": [
+        "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "minimax",
+        "default"
+      ],
+      "widgets_values_named": {
+        "clip_name": "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "type": "minimax",
+        "device": "default"
+      }
+    },
+    {
+      "id": 22,
+      "type": "ResolutionSelector",
+      "pos": [
+        1035.834305565335,
+        5835.209409598467
+      ],
+      "size": [
+        270.983361280237,
+        126
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "showAdvanced": false,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            20
+          ]
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            21
+          ]
+        }
+      ],
+      "title": "Resolution Selector (Size)",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "ResolutionSelector"
+      },
+      "widgets_values": [
+        "16:9 (Widescreen)",
+        0.2,
+        32
+      ],
+      "widgets_values_named": {
+        "aspect_ratio": "16:9 (Widescreen)",
+        "megapixels": 0.2,
+        "multiple": 32
+      },
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 23,
+      "type": "ComfyMathExpression",
+      "pos": [
+        1161.2203497483204,
+        6140.088998712415
+      ],
+      "size": [
+        225,
+        116
+      ],
+      "flags": {
+        "collapsed": true
+      },
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "a",
+          "name": "values.a",
+          "type": "FLOAT,INT,BOOLEAN",
+          "link": 35
+        },
+        {
+          "label": "b",
+          "name": "values.b",
+          "shape": 7,
+          "type": "FLOAT,INT,BOOLEAN",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": []
+        },
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            22,
+            24,
+            34
+          ]
+        },
+        {
+          "name": "BOOL",
+          "type": "BOOLEAN",
+          "links": []
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "ComfyMathExpression"
+      },
+      "widgets_values": [
+        "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17"
+      ],
+      "widgets_values_named": {
+        "expression": "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17"
+      }
+    },
+    {
+      "id": 24,
+      "type": "ManualSigmas",
+      "pos": [
+        3908.508146540855,
+        5381.63001827778
+      ],
+      "size": [
+        308.3164287851357,
+        58
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "sigmas",
+          "name": "sigmas",
+          "type": "STRING",
+          "widget": {
+            "name": "sigmas"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "SIGMAS",
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": []
+        }
+      ],
+      "title": "4 step Sigmas",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "ManualSigmas",
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      },
+      "widgets_values": [
+        "0.9035, 0.8000, 0.6316, 0.3158, 0.0000"
+      ],
+      "widgets_values_named": {
+        "sigmas": "0.9035, 0.8000, 0.6316, 0.3158, 0.0000"
+      }
+    },
+    {
+      "id": 25,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        4246.03966844866,
+        5134.519207068676
+      ],
+      "size": [
+        230,
+        244.65625
+      ],
+      "flags": {},
+      "order": 37,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 36
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 37
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 38
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 39
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 40
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": [
+            10,
+            12
+          ]
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": []
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "SamplerCustomAdvanced"
+      }
+    },
+    {
+      "id": 26,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        3176.503986022757,
+        5128.316087104825
+      ],
+      "size": [
+        230.98336128023698,
+        302.67456553398097
+      ],
+      "flags": {},
+      "order": 30,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 41
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 42
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 43
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 44
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 45
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": []
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": [
+            3,
+            7,
+            55
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "SamplerCustomAdvanced"
+      }
+    },
+    {
+      "id": 27,
+      "type": "PrimitiveFloat",
+      "pos": [
+        1029.8193877921321,
+        6209.720798413607
+      ],
+      "size": [
+        275.0797862917766,
+        58
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            14
+          ]
+        }
+      ],
+      "title": "target_megapixels(放大的像素数)",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "PrimitiveFloat"
+      },
+      "widgets_values": [
+        1
+      ],
+      "widgets_values_named": {
+        "value": 1
+      },
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 28,
+      "type": "MinimaxH3LatentUpscaler3D",
+      "pos": [
+        3517.3533034183665,
+        5256.613801714128
+      ],
+      "size": [
+        286.836067965115,
+        226
+      ],
+      "flags": {},
+      "order": 35,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "link": 46
+        },
+        {
+          "name": "mode.width",
+          "type": "INT",
+          "widget": {
+            "name": "mode.width"
+          },
+          "link": 47
+        },
+        {
+          "name": "mode.height",
+          "type": "INT",
+          "widget": {
+            "name": "mode.height"
+          },
+          "link": 48
+        }
+      ],
+      "outputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "links": [
+            25
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        },
+        "Node name for S&R": "MinimaxH3LatentUpscaler3D"
+      },
+      "widgets_values": [
+        "minimax_h3_latent_upscaler_3d_fp16.safetensors",
+        "target dimensions",
+        1280,
+        704,
+        32,
+        false,
+        "cuda",
+        "fp16"
+      ],
+      "widgets_values_named": {
+        "model_name": "minimax_h3_latent_upscaler_3d_fp16.safetensors",
+        "mode": "target dimensions",
+        "mode.width": 1280,
+        "mode.height": 704,
+        "align": 32,
+        "keep_proportion": false,
+        "device": "cuda",
+        "precision": "fp16"
+      }
+    },
+    {
+      "id": 29,
+      "type": "KSamplerSelect",
+      "pos": [
+        2823.6430428367066,
+        5271.216818760441
+      ],
+      "size": [
+        308.3164287851357,
+        58
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "SAMPLER",
+          "type": "SAMPLER",
+          "links": [
+            38,
+            43
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "KSamplerSelect"
+      },
+      "widgets_values": [
+        "euler"
+      ],
+      "widgets_values_named": {
+        "sampler_name": "euler"
+      }
+    },
+    {
+      "id": 30,
+      "type": "ManualSigmas",
+      "pos": [
+        3908.508146540855,
+        5278.999981525025
+      ],
+      "size": [
+        308.3164287851357,
+        58
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "sigmas",
+          "name": "sigmas",
+          "type": "STRING",
+          "widget": {
+            "name": "sigmas"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "SIGMAS",
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            39
+          ]
+        }
+      ],
+      "title": "3 step Sigmas",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "ManualSigmas",
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      },
+      "widgets_values": [
+        "0.9035, 0.6316, 0.3158, 0.0000"
+      ],
+      "widgets_values_named": {
+        "sigmas": "0.9035, 0.6316, 0.3158, 0.0000"
+      }
+    },
+    {
+      "id": 31,
+      "type": "MarkdownNote",
+      "pos": [
+        494.78201888763215,
+        5065.247043792415
+      ],
+      "size": [
+        440,
+        823.8125
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Note: Model Links",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "Guide: [Subgraph](https://docs.comfy.org/interface/features/subgraph)\n\n## Model Links\n\n**vae**\n\n- [minimax_h3_video_vae_fp16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors)\n- [minimax_h3_audio_vae_fp32.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors)\n\n**diffusion_models**\n\n- [minimax_h3_fl2va_pruned_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors)\n\n**text_encoders**\n\n- [qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors)\n\n**loras**\n\n- 8 steps:  [minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors](https://huggingface.co/lightx2v/Minimax-h3-Turbo/resolve/main/minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors)\n-  4 steps: [minimax_h3_fl2v_turbo_4step_v1.0_768p_comfyui_bf16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/loras/minimax_h3_fl2v_turbo_4step_v1.0_768p_comfyui_bf16.safetensors)\n\n## Model Storage Location\n\n```\n📂 ComfyUI/\n├── 📂 models/\n│   ├── 📂 vae/\n│   │   ├── minimax_h3_video_vae_fp16.safetensors\n│   │   └── minimax_h3_audio_vae_fp32.safetensors\n│   ├── 📂 diffusion_models/\n│   │   └── minimax_h3_fl2va_pruned_int8_convrot.safetensors\n│   ├── 📂 text_encoders/\n│   │   └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors\n│   └── 📂 loras/\n│       └── minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors\n```\n\n## Report Issue\n\nNote: Please update ComfyUI first ([guide](https://docs.comfy.org/installation/update_comfyui)) and prepare required models. Desktop/Cloud updates follow stable releases, so some nightly-supported models may not be available yet.\n\n- Cannot run / runtime errors: [ComfyUI/issues](https://github.com/comfyanonymous/ComfyUI/issues)\n- UI / frontend issues: [ComfyUI_frontend/issues](https://github.com/Comfy-Org/ComfyUI_frontend/issues)\n- Workflow issues: [workflow_templates/issues](https://github.com/Comfy-Org/workflow_templates/issues)\n"
+      ],
+      "widgets_values_named": {
+        "text": "Guide: [Subgraph](https://docs.comfy.org/interface/features/subgraph)\n\n## Model Links\n\n**vae**\n\n- [minimax_h3_video_vae_fp16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors)\n- [minimax_h3_audio_vae_fp32.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors)\n\n**diffusion_models**\n\n- [minimax_h3_fl2va_pruned_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors)\n\n**text_encoders**\n\n- [qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors)\n\n**loras**\n\n- 8 steps:  [minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors](https://huggingface.co/lightx2v/Minimax-h3-Turbo/resolve/main/minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors)\n-  4 steps: [minimax_h3_fl2v_turbo_4step_v1.0_768p_comfyui_bf16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/loras/minimax_h3_fl2v_turbo_4step_v1.0_768p_comfyui_bf16.safetensors)\n\n## Model Storage Location\n\n```\n📂 ComfyUI/\n├── 📂 models/\n│   ├── 📂 vae/\n│   │   ├── minimax_h3_video_vae_fp16.safetensors\n│   │   └── minimax_h3_audio_vae_fp32.safetensors\n│   ├── 📂 diffusion_models/\n│   │   └── minimax_h3_fl2va_pruned_int8_convrot.safetensors\n│   ├── 📂 text_encoders/\n│   │   └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors\n│   └── 📂 loras/\n│       └── minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors\n```\n\n## Report Issue\n\nNote: Please update ComfyUI first ([guide](https://docs.comfy.org/installation/update_comfyui)) and prepare required models. Desktop/Cloud updates follow stable releases, so some nightly-supported models may not be available yet.\n\n- Cannot run / runtime errors: [ComfyUI/issues](https://github.com/comfyanonymous/ComfyUI/issues)\n- UI / frontend issues: [ComfyUI_frontend/issues](https://github.com/Comfy-Org/ComfyUI_frontend/issues)\n- Workflow issues: [workflow_templates/issues](https://github.com/Comfy-Org/workflow_templates/issues)\n"
+      },
+      "color": "#222",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 32,
+      "type": "MarkdownNote",
+      "pos": [
+        619.2485783896982,
+        5976.897338708028
+      ],
+      "size": [
+        300,
+        520
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Note: Size Settings Reference",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "| megapixels | Aspect | Output (multiple=32) |\n|---|---|---|\n| 0.2 | 16:9 | 608 x 352 |\n| 0.3 | 16:9 | 736 x 416 |\n| 0.4 | 16:9 | 864 x 480 |\n| 0.5 | 16:9 | 960 x 544 |\n| 0.6 | 16:9 | 1056 x 608 |\n| 0.7 | 16:9 | 1152 x 640 |\n| 0.8 | 16:9 | 1216 x 672 |\n| 0.9 | 16:9 | 1280 x 736 |\n| 0.98 | 16:9 | 1344 x 768 |\n| 1.0 | 16:9 | 1376 x 768 |\n| 1.2 | 16:9 | 1504 x 832 |\n| 1.5 | 16:9 | 1664 x 928 |\n| 1.8 | 16:9 | 1824 x 1024 |\n| 2.0 | 16:9 | 1920 x 1088 |\n"
+      ],
+      "widgets_values_named": {
+        "text": "| megapixels | Aspect | Output (multiple=32) |\n|---|---|---|\n| 0.2 | 16:9 | 608 x 352 |\n| 0.3 | 16:9 | 736 x 416 |\n| 0.4 | 16:9 | 864 x 480 |\n| 0.5 | 16:9 | 960 x 544 |\n| 0.6 | 16:9 | 1056 x 608 |\n| 0.7 | 16:9 | 1152 x 640 |\n| 0.8 | 16:9 | 1216 x 672 |\n| 0.9 | 16:9 | 1280 x 736 |\n| 0.98 | 16:9 | 1344 x 768 |\n| 1.0 | 16:9 | 1376 x 768 |\n| 1.2 | 16:9 | 1504 x 832 |\n| 1.5 | 16:9 | 1664 x 928 |\n| 1.8 | 16:9 | 1824 x 1024 |\n| 2.0 | 16:9 | 1920 x 1088 |\n"
+      },
+      "color": "#222",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 33,
+      "type": "BasicGuider",
+      "pos": [
+        2823.6430428367066,
+        5152.136280676316
+      ],
+      "size": [
+        308.3164287851357,
+        60
+      ],
+      "flags": {},
+      "order": 29,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 49
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 50
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            42
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "BasicGuider"
+      }
+    },
+    {
+      "id": 34,
+      "type": "UNETLoader",
+      "pos": [
+        1021.6194926311771,
+        5128.795241774153
+      ],
+      "size": [
+        640,
+        90
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            9,
+            57
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "UNETLoader",
+        "models": [
+          {
+            "name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+            "directory": "diffusion_models"
+          }
+        ]
+      },
+      "widgets_values": [
+        "minimax_h3_fl2va_int8_convrot.safetensors",
+        "default"
+      ],
+      "widgets_values_named": {
+        "unet_name": "minimax_h3_fl2va_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      }
+    },
+    {
+      "id": 35,
+      "type": "BasicGuider",
+      "pos": [
+        3908.508146540855,
+        5153.527207254698
+      ],
+      "size": [
+        308.3164287851357,
+        60
+      ],
+      "flags": {},
+      "order": 28,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 51
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 52
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            37
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "BasicGuider"
+      }
+    },
+    {
+      "id": 36,
+      "type": "CreateVideo",
+      "pos": [
+        4513.419976243165,
+        5133.073653450162
+      ],
+      "size": [
+        283.1269337209078,
+        102
+      ],
+      "flags": {},
+      "order": 40,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 53
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 54
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VIDEO",
+          "type": "VIDEO",
+          "links": [
+            6
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "CreateVideo"
+      },
+      "widgets_values": [
+        24,
+        8
+      ],
+      "widgets_values_named": {
+        "fps": 24,
+        "bit_depth": 8
+      }
+    },
+    {
+      "id": 37,
+      "type": "RandomNoise",
+      "pos": [
+        1762.6607460983612,
+        5127.777700325522
+      ],
+      "size": [
+        258.683290941065,
+        82
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "NOISE",
+          "type": "NOISE",
+          "links": [
+            36,
+            41
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "RandomNoise"
+      },
+      "widgets_values": [
+        42,
+        "fixed"
+      ],
+      "widgets_values_named": {
+        "noise_seed": 42,
+        "control_after_generate": "fixed"
+      }
+    },
+    {
+      "id": 38,
+      "type": "LTXVSeparateAVLatent",
+      "pos": [
+        3515.6748445640137,
+        5141.589345008434
+      ],
+      "size": [
+        286.836067965115,
+        48.43467905382113
+      ],
+      "flags": {},
+      "order": 33,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "av_latent",
+          "name": "av_latent",
+          "type": "LATENT",
+          "link": 55
+        }
+      ],
+      "outputs": [
+        {
+          "label": "video_latent",
+          "name": "video_latent",
+          "type": "LATENT",
+          "links": [
+            46
+          ]
+        },
+        {
+          "label": "audio_latent",
+          "name": "audio_latent",
+          "type": "LATENT",
+          "links": [
+            26
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "LTXVSeparateAVLatent",
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      }
+    },
+    {
+      "id": 39,
+      "type": "MarkdownNote",
+      "pos": [
+        -248.89143937390827,
+        5059.017541561554
+      ],
+      "size": [
+        704.1847986543371,
+        1486.7010497507154
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Note: Model Links",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "# 工作流说明 / Workflow Notes\n\n## 需要安装的第三方节点\n\n[🤗 H3 的浅空间放大节点](https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler)\n\n```bash\ncd ComfyUI/custom_nodes\ngit clone https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler.git\n```\n\n---\n\n## 模型下载与放置\n\n**H3 浅空间放大模型，放置在 `ComfyUI/models/latent_upscale_models/`**\n\n| 文件名 | 精度 | 大小 | 适用场景 |\n| :--- | :--- | :--- | :--- |\n| [minimax_h3_latent_upscaler_3d_bf16.safetensors](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler/blob/main/minimax_h3_latent_upscaler_3d_bf16.safetensors) | bf16 | ~691 MB | Ampere/Ada 显卡上最快 |\n| [minimax_h3_latent_upscaler_3d_fp16.safetensors](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler/blob/main/minimax_h3_latent_upscaler_3d_fp16.safetensors) | fp16 | ~691 MB | 速度与显存平衡（推荐） |\n| [minimax_h3_latent_upscaler_3d_fp32.pth](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler/blob/main/minimax_h3_latent_upscaler_3d_fp32.pth) | fp32 | ~1.38 GB | 数值精度最高 |\n\n> 三个文件结构相同，选一个你显卡和 workflow 能承受的精度即可。节点下拉框会自动扫描到它们。\n\n---\n\n\n### ⚠️ 3D 倍率节点必须配合音视频分离/合并节���\n\n`Minimax H3 Latent Upscaler (3D)` 因为 H3 latent 里同时含视频与音频，不能直接接原始 `latent`：\n\n```\n[LTXV分离音视频潜空间]  →  video_latent  →  [Minimax H3 Latent Upscaler (3D)]  →  [LTXVConcatAVLatent]\n                                                        │ audio_latent（原样传回）\n```\n\n即：前接 `LTXV分离音视频潜空间`，只把 `video_latent` 喂给放大节点，放大后由 `LTXVConcatAVLatent` 把 `audio_latent` 合并回去。\n\n> 其余2个节点（Target Resolution / Megapixels）都不会处理音频，直接接 `latent` 即可，无需分离/合并。\n\n\n\n# 工作流说明 / Workflow Notes\n\n## ⚠️ 重要：`Minimax H3 Latent Upscaler (3D) 节点必须配合音视频分离节点使用\n\n`Minimax H3 Latent Upscaler (3D)` 节点**不能直接接在原始 `latent` 后面**，因为 Minimax H3 的 latent 里同时包含了视频和音频潜空间，直接一起放大可能会破坏音频。\n\n正确连接方式（参考截图）：\n\n```\n[av_latent]\n    │\n    ▼\n┌─────────────────────────┐\n│ LTXV分离音视频潜空间     │  ← 把 latent 拆成 video_latent + audio_latent\n└─────────────────────────┘\n    │ video_latent\n    ▼\n┌─────────────────────────┐\n│ Minimax H3 Latent       │  ← 只放大 video_latent\n│ Upscaler (3D)           │\n└─────────────────────────┘\n    │ latent (已放大)\n    ▼\n┌─────────────────────────┐\n│ LTXVConcatAVLatent      │  ← 把放大的 video_latent 和原始 audio_latent 合并\n└─────────────────────────┘\n    │\n    ▼\n[VAE Decode / 后续节点]\n```\n\n即：\n\n- **前节点**：`LTXV分离音视频潜空间`（输出 `video_latent` + `audio_latent`）\n- **中间**：`Minimax H3 Latent Upscaler (3D)`，只连接 `video_latent`\n- **后节点**：`LTXVConcatAVLatent`，把放大后的 `latent` 和未改动的 `audio_latent` 重新拼回\n\n---\n\n## 节点参数建议\n\n| 参数 | 推荐值 | 说明 |\n| :--- | :--- | :--- |\n| `model_name` | `minimax_h3_latent_upscaler_3d_fp16.safetensors` | 按需选择精度 |\n| `scale` | `2.0` | 1.0–4.0，常用 2× |\n| `device` | `cuda` | 没有显卡可选 `cpu`，但速度很慢 |\n| `precision` | `fp16` | 与模型文件对应；想稳可选 `fp32` |\n\n---\n\n## 完整流程示意\n\n```\nH3 低分辨率生成\n      │\n      ▼\nVAE Encode（得到 av_latent）\n      │\n      ▼\nLTXV分离音视频潜空间\n      │ video_latent\n      ▼\nMinimax H3 Latent Upscaler (3D)   ← 在这里放大\n      │\n      ▼\nLTXVConcatAVLatent\n      │\n      ▼\n第二阶段二次采样/重绘精修\n      │\n      ▼\nVAE Decode → 高清视频\n```\n\n> 这个流程跳过了「VAE 解码 → 像素放大 → 再编码」的笨重往返，也避免了对 latent 直接插值带来的鬼影/重影问题。\n"
+      ],
+      "widgets_values_named": {
+        "text": "# 工作流说明 / Workflow Notes\n\n## 需要安装的第三方节点\n\n[🤗 H3 的浅空间放大节点](https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler)\n\n```bash\ncd ComfyUI/custom_nodes\ngit clone https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler.git\n```\n\n---\n\n## 模型下载与放置\n\n**H3 浅空间放大模型，放置在 `ComfyUI/models/latent_upscale_models/`**\n\n| 文件名 | 精度 | 大小 | 适用场景 |\n| :--- | :--- | :--- | :--- |\n| [minimax_h3_latent_upscaler_3d_bf16.safetensors](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler/blob/main/minimax_h3_latent_upscaler_3d_bf16.safetensors) | bf16 | ~691 MB | Ampere/Ada 显卡上最快 |\n| [minimax_h3_latent_upscaler_3d_fp16.safetensors](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler/blob/main/minimax_h3_latent_upscaler_3d_fp16.safetensors) | fp16 | ~691 MB | 速度与显存平衡（推荐） |\n| [minimax_h3_latent_upscaler_3d_fp32.pth](https://huggingface.co/LBH-123-AI/Minimax_h3_latent_Upscaler/blob/main/minimax_h3_latent_upscaler_3d_fp32.pth) | fp32 | ~1.38 GB | 数值精度最高 |\n\n> 三个文件结构相同，选一个你显卡和 workflow 能承受的精度即可。节点下拉框会自动扫描到它们。\n\n---\n\n\n### ⚠️ 3D 倍率节点必须配合音视频分离/合并节点\n\n`Minimax H3 Latent Upscaler (3D)` 因为 H3 latent 里同时含视频与音频，不能直接接原始 `latent`：\n\n```\n[LTXV分离音视频潜空间]  →  video_latent  →  [Minimax H3 Latent Upscaler (3D)]  →  [LTXVConcatAVLatent]\n                                                        │ audio_latent（原样传回）\n```\n\n即：前接 `LTXV分离音视频潜空间`，只把 `video_latent` 喂给放大节点，放大后由 `LTXVConcatAVLatent` 把 `audio_latent` 合并回去。\n\n> 其余2个节点（Target Resolution / Megapixels）都不会处理音频，直接接 `latent` 即可，无需分离/合并。\n\n\n\n# 工作流说明 / Workflow Notes\n\n## ⚠️ 重要：`Minimax H3 Latent Upscaler (3D) 节点必须配合音视频分离节点使用\n\n`Minimax H3 Latent Upscaler (3D)` 节点**不能直接接在原始 `latent` 后面**，因为 Minimax H3 的 latent 里同时包含了视频和音频潜空间，直接一起放大可能会破坏音频。\n\n正确连接方式（参考截图）：\n\n```\n[av_latent]\n    │\n    ▼\n┌─────────────────────────┐\n│ LTXV分离音视频潜空间     │  ← 把 latent 拆成 video_latent + audio_latent\n└─────────────────────────┘\n    │ video_latent\n    ▼\n┌─────────────────────────┐\n│ Minimax H3 Latent       │  ← 只放大 video_latent\n│ Upscaler (3D)           │\n└─────────────────────────┘\n    │ latent (已放大)\n    ▼\n┌─────────────────────────┐\n│ LTXVConcatAVLatent      │  ← 把放大的 video_latent 和原始 audio_latent 合并\n└─────────────────────────┘\n    │\n    ▼\n[VAE Decode / 后续节点]\n```\n\n即：\n\n- **前节点**：`LTXV分离音视频潜空间`（输出 `video_latent` + `audio_latent`）\n- **中间**：`Minimax H3 Latent Upscaler (3D)`，只连接 `video_latent`\n- **后节点**：`LTXVConcatAVLatent`，把放大后的 `latent` 和未改动的 `audio_latent` 重新拼回\n\n---\n\n## 节点参数建议\n\n| 参数 | 推荐值 | 说明 |\n| :--- | :--- | :--- |\n| `model_name` | `minimax_h3_latent_upscaler_3d_fp16.safetensors` | 按需选择精度 |\n| `scale` | `2.0` | 1.0–4.0，常用 2× |\n| `device` | `cuda` | 没有显卡可选 `cpu`，但速度很慢 |\n| `precision` | `fp16` | 与模型文件对应；想稳可选 `fp32` |\n\n---\n\n## 完整流程示意\n\n```\nH3 低分辨率生成\n      │\n      ▼\nVAE Encode（得到 av_latent）\n      │\n      ▼\nLTXV分离音视频潜空间\n      │ video_latent\n      ▼\nMinimax H3 Latent Upscaler (3D)   ← 在这里放大\n      │\n      ▼\nLTXVConcatAVLatent\n      │\n      ▼\n第二阶段二次采样/重绘精修\n      │\n      ▼\nVAE Decode → 高清视频\n```\n\n> 这个流程跳过了「VAE 解码 → 像素放大 → 再编码」的笨重往返，也避免了对 latent 直接插值带来的鬼影/重影问题。\n"
+      },
+      "color": "#222",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 40,
+      "type": "ModelAttentionBackend",
+      "pos": [
+        2428.2578085907203,
+        4920.293966332052
+      ],
+      "size": [
+        270,
+        62
+      ],
+      "flags": {},
+      "order": 26,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 56
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            23,
+            51
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "ModelAttentionBackend"
+      },
+      "widgets_values": [
+        "comfy kitchen attention"
+      ],
+      "widgets_values_named": {
+        "attention": "comfy kitchen attention"
+      }
+    },
+    {
+      "id": 41,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        1733.9262755570603,
+        4920.745239746706
+      ],
+      "size": [
+        381.22282887292226,
+        82
+      ],
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 57
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            58
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "LoraLoaderModelOnly"
+      },
+      "widgets_values": [
+        "Minimax_H3\\minimax_h3_fl2v_lightx2v_turbo_4step_v0.1_comfy.safetensors",
+        1
+      ],
+      "widgets_values_named": {
+        "lora_name": "Minimax_H3\\minimax_h3_fl2v_lightx2v_turbo_4step_v0.1_comfy.safetensors",
+        "strength_model": 1
+      }
+    },
+    {
+      "id": 42,
+      "type": "MiniMaxH3SigmaShift",
+      "pos": [
+        2138.9374852454953,
+        4919.377082432047
+      ],
+      "size": [
+        265.53194252971207,
+        82
+      ],
+      "flags": {},
+      "order": 25,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 58
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            56
+          ]
+        }
+      ],
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        },
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "MiniMaxH3SigmaShift"
+      },
+      "widgets_values": [
+        12,
+        3
+      ],
+      "widgets_values_named": {
+        "shift_video": 12,
+        "shift_audio": 3
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      6,
+      0,
+      1,
+      0,
+      "IMAGE"
+    ],
+    [
+      2,
+      2,
+      0,
+      1,
+      1,
+      "AUDIO"
+    ],
+    [
+      3,
+      26,
+      1,
+      2,
+      0,
+      "LATENT"
+    ],
+    [
+      4,
+      13,
+      0,
+      2,
+      1,
+      "VAE"
+    ],
+    [
+      5,
+      8,
+      0,
+      3,
+      0,
+      "SIGMAS"
+    ],
+    [
+      6,
+      36,
+      0,
+      4,
+      0,
+      "VIDEO"
+    ],
+    [
+      7,
+      26,
+      1,
+      6,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      7,
+      0,
+      6,
+      1,
+      "VAE"
+    ],
+    [
+      9,
+      34,
+      0,
+      8,
+      0,
+      "MODEL"
+    ],
+    [
+      10,
+      25,
+      0,
+      11,
+      0,
+      "LATENT"
+    ],
+    [
+      11,
+      7,
+      0,
+      11,
+      1,
+      "VAE"
+    ],
+    [
+      12,
+      25,
+      0,
+      12,
+      0,
+      "LATENT"
+    ],
+    [
+      13,
+      13,
+      0,
+      12,
+      1,
+      "VAE"
+    ],
+    [
+      14,
+      27,
+      0,
+      15,
+      0,
+      "FLOAT"
+    ],
+    [
+      15,
+      21,
+      0,
+      16,
+      0,
+      "CLIP"
+    ],
+    [
+      16,
+      7,
+      0,
+      16,
+      1,
+      "VAE"
+    ],
+    [
+      17,
+      9,
+      0,
+      16,
+      2,
+      "IMAGE"
+    ],
+    [
+      18,
+      10,
+      0,
+      16,
+      3,
+      "IMAGE"
+    ],
+    [
+      19,
+      14,
+      0,
+      16,
+      4,
+      "STRING"
+    ],
+    [
+      20,
+      22,
+      0,
+      16,
+      5,
+      "INT"
+    ],
+    [
+      21,
+      22,
+      1,
+      16,
+      6,
+      "INT"
+    ],
+    [
+      22,
+      23,
+      1,
+      16,
+      7,
+      "INT"
+    ],
+    [
+      23,
+      40,
+      0,
+      17,
+      0,
+      "MODEL"
+    ],
+    [
+      24,
+      23,
+      1,
+      17,
+      2,
+      "INT"
+    ],
+    [
+      25,
+      28,
+      0,
+      18,
+      0,
+      "LATENT"
+    ],
+    [
+      26,
+      38,
+      1,
+      18,
+      1,
+      "LATENT"
+    ],
+    [
+      27,
+      21,
+      0,
+      19,
+      0,
+      "CLIP"
+    ],
+    [
+      28,
+      7,
+      0,
+      19,
+      1,
+      "VAE"
+    ],
+    [
+      29,
+      9,
+      0,
+      19,
+      2,
+      "IMAGE"
+    ],
+    [
+      30,
+      10,
+      0,
+      19,
+      3,
+      "IMAGE"
+    ],
+    [
+      31,
+      14,
+      0,
+      19,
+      4,
+      "STRING"
+    ],
+    [
+      32,
+      15,
+      0,
+      19,
+      5,
+      "INT"
+    ],
+    [
+      33,
+      15,
+      1,
+      19,
+      6,
+      "INT"
+    ],
+    [
+      34,
+      23,
+      1,
+      19,
+      7,
+      "INT"
+    ],
+    [
+      35,
+      20,
+      0,
+      23,
+      0,
+      "FLOAT"
+    ],
+    [
+      36,
+      37,
+      0,
+      25,
+      0,
+      "NOISE"
+    ],
+    [
+      37,
+      35,
+      0,
+      25,
+      1,
+      "GUIDER"
+    ],
+    [
+      38,
+      29,
+      0,
+      25,
+      2,
+      "SAMPLER"
+    ],
+    [
+      39,
+      30,
+      0,
+      25,
+      3,
+      "SIGMAS"
+    ],
+    [
+      40,
+      18,
+      0,
+      25,
+      4,
+      "LATENT"
+    ],
+    [
+      41,
+      37,
+      0,
+      26,
+      0,
+      "NOISE"
+    ],
+    [
+      42,
+      33,
+      0,
+      26,
+      1,
+      "GUIDER"
+    ],
+    [
+      43,
+      29,
+      0,
+      26,
+      2,
+      "SAMPLER"
+    ],
+    [
+      44,
+      3,
+      0,
+      26,
+      3,
+      "SIGMAS"
+    ],
+    [
+      45,
+      16,
+      1,
+      26,
+      4,
+      "LATENT"
+    ],
+    [
+      46,
+      38,
+      0,
+      28,
+      0,
+      "LATENT"
+    ],
+    [
+      47,
+      15,
+      0,
+      28,
+      1,
+      "INT"
+    ],
+    [
+      48,
+      15,
+      1,
+      28,
+      2,
+      "INT"
+    ],
+    [
+      49,
+      17,
+      0,
+      33,
+      0,
+      "MODEL"
+    ],
+    [
+      50,
+      16,
+      0,
+      33,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      51,
+      40,
+      0,
+      35,
+      0,
+      "MODEL"
+    ],
+    [
+      52,
+      19,
+      0,
+      35,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      53,
+      11,
+      0,
+      36,
+      0,
+      "IMAGE"
+    ],
+    [
+      54,
+      12,
+      0,
+      36,
+      1,
+      "AUDIO"
+    ],
+    [
+      55,
+      26,
+      1,
+      38,
+      0,
+      "LATENT"
+    ],
+    [
+      56,
+      42,
+      0,
+      40,
+      0,
+      "MODEL"
+    ],
+    [
+      57,
+      34,
+      0,
+      41,
+      0,
+      "MODEL"
+    ],
+    [
+      58,
+      41,
+      0,
+      42,
+      0,
+      "MODEL"
+    ]
+  ],
+  "groups": [
+    {
+      "id": 1,
+      "title": "User Inputs",
+      "bounding": [
+        992.884221724624,
+        5724.891597108754,
+        1208.9503194675362,
+        834.450029042503
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 2,
+      "title": "Models",
+      "bounding": [
+        992.1892320604375,
+        5033.23147307899,
+        700,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 3,
+      "title": "Sampling",
+      "bounding": [
+        2786.1892320604375,
+        5033.23147307899,
+        670.6723003979018,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 4,
+      "title": "Conditioning",
+      "bounding": [
+        1710.1892320604375,
+        5033.23147307899,
+        657,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 5,
+      "title": "Two-stage sampling upscaling - Decoding and create video",
+      "bounding": [
+        3876.1892320604375,
+        5033.23147307899,
+        963,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 6,
+      "title": "H3 Latent Upscaler",
+      "bounding": [
+        3474.8615324583393,
+        5033.23147307899,
+        383,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 7,
+      "title": "preview",
+      "bounding": [
+        2385.1892320604375,
+        5033.23147307899,
+        383,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.392221789683935,
+      "offset": [
+        1806.6773443253683,
+        -4318.606286467836
+      ]
+    },
+    "ue_links": [],
+    "frontendVersion": "1.49.6",
+    "VHS_latentpreview": false,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": true,
+    "VHS_KeepIntermediate": true
+  },
+  "version": 0.4
+}

Comfyui_Minimax_h3_latent_Upscaler/workflow_templates/minimax_h3_r2v_Latent Upscaler example workflow3.json

@@ -0,0 +1,2671 @@
+{
+  "id": "1e132da8-4308-4d7e-b766-009313e961c8",
+  "revision": 0,
+  "last_node_id": 38,
+  "last_link_id": 49,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        1672.3340244896142,
+        5341.889808999437
+      ],
+      "size": [
+        210,
+        334
+      ],
+      "flags": {},
+      "order": 30,
+      "mode": 4,
+      "inputs": [
+        {
+          "label": "图像",
+          "name": "images",
+          "type": "IMAGE",
+          "link": 1
+        },
+        {
+          "label": "音频",
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 2
+        },
+        {
+          "label": "批次管理",
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        },
+        {
+          "label": "帧率",
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "widget": {
+            "name": "frame_rate"
+          },
+          "link": null
+        },
+        {
+          "label": "循环次数",
+          "name": "loop_count",
+          "type": "INT",
+          "widget": {
+            "name": "loop_count"
+          },
+          "link": null
+        },
+        {
+          "label": "文件名前缀",
+          "name": "filename_prefix",
+          "type": "STRING",
+          "widget": {
+            "name": "filename_prefix"
+          },
+          "link": null
+        },
+        {
+          "label": "格式",
+          "name": "format",
+          "type": "COMBO",
+          "widget": {
+            "name": "format"
+          },
+          "link": null
+        },
+        {
+          "label": "Ping-Pong",
+          "name": "pingpong",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "pingpong"
+          },
+          "link": null
+        },
+        {
+          "label": "保存到输出文件夹",
+          "name": "save_output",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "save_output"
+          },
+          "link": null
+        },
+        {
+          "label": "保存元数据",
+          "name": "save_metadata",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "save_metadata"
+          },
+          "link": null
+        },
+        {
+          "label": "修剪音频",
+          "name": "trim_to_audio",
+          "type": "BOOLEAN",
+          "widget": {
+            "name": "trim_to_audio"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "文件名",
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "title": "合并为视频",
+      "properties": {
+        "cnr_id": "comfyui-videohelpersuite",
+        "ver": "4ee72c065db22c9d96c2427954dc69e7b908444b",
+        "Node name for S&R": "VHS_VideoCombine",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001-audio.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4",
+            "frame_rate": 24,
+            "workflow": "AnimateDiff_00001.png",
+            "fullpath": "D:\\AI\\ComfyUI-aki-v2\\ComfyUI\\temp\\AnimateDiff_00001-audio.mp4"
+          }
+        }
+      },
+      "widgets_values_named": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001-audio.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4",
+            "frame_rate": 24,
+            "workflow": "AnimateDiff_00001.png",
+            "fullpath": "D:\\AI\\ComfyUI-aki-v2\\ComfyUI\\temp\\AnimateDiff_00001-audio.mp4"
+          }
+        }
+      }
+    },
+    {
+      "id": 2,
+      "type": "PrimitiveStringMultiline",
+      "pos": [
+        337.6228951554299,
+        5390.6781334546085
+      ],
+      "size": [
+        370,
+        390
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": []
+        }
+      ],
+      "title": "提示词",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "PrimitiveStringMultiline",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "资产角色：\n<Picture 1>\n国风动漫少女，深棕色发髻点缀红梅与蝶形发饰，身穿白金红相间的抹胸上衣与飘逸薄纱灯笼裤，周身环绕金红流光与炽炎花瓣特效。\n<Picture 2>\n硬派白发战将，身穿暗红色皮革长款风衣、黑色内衬与战术皮裤，手持重剑与双枪，周身散发冷冽红黑魔力气浪。\n\n一个低机位推近镜头框住\n<Picture 1>\n与\n<Picture 2>\n在废墟长廊两端对峙。\n<Picture 1>\n率先启动超音速贴地冲刺，足尖踏出金红烈焰莲华，甩出赤红绫缎如游龙贯空；\nthe camera cuts to\n侧面跟摇特写，\n<Picture 2>\n拔出重剑横向重劈，刀锋与炽炎绫缎剧烈碰撞，火星与雷光四向迸射，气浪撕裂地面石板。\nthe shot transitions to\n俯冲环绕镜头，\n<Picture 1>\n借力凌空翻腾，双掌结印召唤暴雨般金红火蝶与符文剑气垂直轰炸；\n<Picture 2>\n单手举剑格挡，魔力红光护盾展开，随即甩动红风衣滑步侧移，拔枪极速连射，火舌与剑气在半空接连引爆。\nthe camera dynamically follows\n贴地高速滑移，\n<Picture 1>\n在弹雨残影中多维瞬闪，瞬身突进至\n<Picture 2>\n身前旋身横扫，赤焰气刃斩开风衣下摆；\nthe shot changes to\n极速下坠定点特写，\n<Picture 2>\n反手抽刀上挑震开攻击，\n<Picture 1>\n空中旋身单手撑地滑退数米，\n<Picture 1>\n与\n<Picture 2>\n同时稳住身形横刃相对，周身烈火与魔能疯狂暴涨，在最强杀意临界点定格。\noverall_soundscape: Explosive shockwaves crack the stone ground as steel clashes with fiery energy ribbons. Gunfire roars in rapid bursts followed by the sizzling hum of burning petals and swirling demonic aura.non_diegetic_music: High-octane heavy metal hybrid with aggressive electric guitar riffs, pounding industrial drums, and intense symphonic brass, cutting off sharply on the final clash."
+      ],
+      "widgets_values_named": {
+        "value": "资产角色：\n<Picture 1>\n国风动漫少女，深棕色发髻点缀红梅与蝶形发饰，身穿白金红相间的抹胸上衣与飘逸薄纱灯笼裤，周身环绕金红流光与炽炎花瓣特效。\n<Picture 2>\n硬派白发战将，身穿暗红色皮革长款风衣、黑色内衬与战术皮裤，手持重剑与双枪，周身散发冷冽红黑魔力气浪。\n\n一个低机位推近镜头框住\n<Picture 1>\n与\n<Picture 2>\n在废墟长廊两端对峙。\n<Picture 1>\n率先启动超音速贴地冲刺，足尖踏出金红烈焰莲华，甩出赤红绫缎如游龙贯空；\nthe camera cuts to\n侧面跟摇特写，\n<Picture 2>\n拔出重剑横向重劈，刀锋与炽炎绫缎剧烈碰撞，火星与雷光四向迸射，气浪撕裂地面石板。\nthe shot transitions to\n俯冲环绕镜头，\n<Picture 1>\n借力凌空翻腾，双掌结印召唤暴雨般金红火蝶与符文剑气垂直轰炸；\n<Picture 2>\n单手举剑格挡，魔力红光护盾展开，随即甩动红风衣滑步侧移，拔枪极速连射，火舌与剑气在半空接连引爆。\nthe camera dynamically follows\n贴地高速滑移，\n<Picture 1>\n在弹雨残影中多维瞬闪，瞬身突进至\n<Picture 2>\n身前旋身横扫，赤焰气刃斩开风衣下摆；\nthe shot changes to\n极速下坠定点特写，\n<Picture 2>\n反手抽刀上挑震开攻击，\n<Picture 1>\n空中旋身单手撑地滑退数米，\n<Picture 1>\n与\n<Picture 2>\n同时稳住身形横刃相对，周身烈火与魔能疯狂暴涨，在最强杀意临界点定格。\noverall_soundscape: Explosive shockwaves crack the stone ground as steel clashes with fiery energy ribbons. Gunfire roars in rapid bursts followed by the sizzling hum of burning petals and swirling demonic aura.non_diegetic_music: High-octane heavy metal hybrid with aggressive electric guitar riffs, pounding industrial drums, and intense symphonic brass, cutting off sharply on the final clash."
+      },
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 3,
+      "type": "VAELoader",
+      "pos": [
+        -306.15299615894105,
+        5023.880667348764
+      ],
+      "size": [
+        640,
+        70
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            5,
+            11,
+            34
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAELoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "models": [
+          {
+            "name": "minimax_h3_video_vae_fp16.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors",
+            "directory": "vae"
+          }
+        ]
+      },
+      "widgets_values": [
+        "minimax_h3_video_vae_fp16.safetensors"
+      ],
+      "widgets_values_named": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      }
+    },
+    {
+      "id": 4,
+      "type": "VAELoader",
+      "pos": [
+        -306.15299615894105,
+        5153.880667348764
+      ],
+      "size": [
+        650,
+        70
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            7,
+            12,
+            20
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAELoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "models": [
+          {
+            "name": "minimax_h3_audio_vae_fp32.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors",
+            "directory": "vae"
+          }
+        ]
+      },
+      "widgets_values": [
+        "minimax_h3_audio_vae_fp32.safetensors"
+      ],
+      "widgets_values_named": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      }
+    },
+    {
+      "id": 5,
+      "type": "SaveVideo",
+      "pos": [
+        2942.544119477948,
+        4853.660006083442
+      ],
+      "size": [
+        283.126933720908,
+        106
+      ],
+      "flags": {},
+      "order": 37,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "SaveVideo",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "video/MiniMax_H3",
+        "auto",
+        "auto"
+      ],
+      "widgets_values_named": {
+        "filename_prefix": "video/MiniMax_H3",
+        "format": "auto",
+        "codec": "auto"
+      }
+    },
+    {
+      "id": 6,
+      "type": "ManualSigmas",
+      "pos": [
+        2358.2357570959043,
+        5038.7065251752965
+      ],
+      "size": [
+        266.579898552601,
+        58
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "sigmas",
+          "name": "sigmas",
+          "type": "STRING",
+          "widget": {
+            "name": "sigmas"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "SIGMAS",
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": []
+        }
+      ],
+      "title": "5 step Sigmas",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "ManualSigmas",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      },
+      "widgets_values": [
+        "0.9231, 0.8780, 0.8000, 0.6316, 0.3158, 0.0000"
+      ],
+      "widgets_values_named": {
+        "sigmas": "0.9231, 0.8780, 0.8000, 0.6316, 0.3158, 0.0000"
+      }
+    },
+    {
+      "id": 7,
+      "type": "VAEDecode",
+      "pos": [
+        1637.6859974582662,
+        5047.812567600401
+      ],
+      "size": [
+        230.98336128023698,
+        46
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 27,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 4
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            1
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 8,
+      "type": "VAEDecodeAudio",
+      "pos": [
+        1637.6859974582662,
+        5149.985288292222
+      ],
+      "size": [
+        230.98336128023698,
+        46.99687563323096
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 28,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 6
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": [
+            2
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecodeAudio",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 9,
+      "type": "LoadImage",
+      "pos": [
+        15.476970637899512,
+        5397.098522753795
+      ],
+      "size": [
+        290,
+        330
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            13
+          ]
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "LoadImage",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "09-55-07_00001.jpg",
+        "image"
+      ],
+      "widgets_values_named": {
+        "image": "09-55-07_00001.jpg",
+        "upload": "image"
+      }
+    },
+    {
+      "id": 10,
+      "type": "LTXVConcatAVLatent",
+      "pos": [
+        1970.9114206444888,
+        5102.2627638016265
+      ],
+      "size": [
+        286.8360679651149,
+        46
+      ],
+      "flags": {},
+      "order": 32,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "video_latent",
+          "name": "video_latent",
+          "type": "LATENT",
+          "link": 8
+        },
+        {
+          "label": "audio_latent",
+          "name": "audio_latent",
+          "type": "LATENT",
+          "link": 9
+        }
+      ],
+      "outputs": [
+        {
+          "label": "latent",
+          "name": "latent",
+          "type": "LATENT",
+          "links": [
+            25
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "LTXVConcatAVLatent",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      }
+    },
+    {
+      "id": 11,
+      "type": "MiniMaxH3ReferenceToVideo",
+      "pos": [
+        427.616431673551,
+        4842.454751659
+      ],
+      "size": [
+        375.96979953612185,
+        348.76458454401836
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 10
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 11
+        },
+        {
+          "name": "audio_vae",
+          "type": "VAE",
+          "link": 12
+        },
+        {
+          "label": "ref_image_0",
+          "name": "ref_images.ref_image_0",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": 13
+        },
+        {
+          "label": "ref_image_1",
+          "name": "ref_images.ref_image_1",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "label": "ref_video_0",
+          "name": "ref_videos.ref_video_0",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "label": "ref_video_audio_0",
+          "name": "ref_video_audios.ref_video_audio_0",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "label": "ref_audio_0",
+          "name": "ref_audios.ref_audio_0",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "widget": {
+            "name": "width"
+          },
+          "link": 47
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "widget": {
+            "name": "height"
+          },
+          "link": 48
+        },
+        {
+          "name": "length",
+          "type": "INT",
+          "widget": {
+            "name": "length"
+          },
+          "link": 49
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            38,
+            40
+          ]
+        },
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            31
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "MiniMaxH3ReferenceToVideo",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "prompt": true,
+            "width": true,
+            "height": true,
+            "length": true
+          },
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "",
+        1344,
+        768,
+        124,
+        "match"
+      ],
+      "widgets_values_named": {
+        "prompt": "",
+        "width": 1344,
+        "height": 768,
+        "length": 124,
+        "ref_image_size": "match"
+      }
+    },
+    {
+      "id": 12,
+      "type": "ModelPreviewOverrideKJ",
+      "pos": [
+        904.139041498252,
+        4675.511346038954
+      ],
+      "size": [
+        296.3668204268381,
+        462.7777453538065
+      ],
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 16
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        },
+        {
+          "name": "preview_frames",
+          "type": "INT",
+          "widget": {
+            "name": "preview_frames"
+          },
+          "link": 17
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            37
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "3f20054214fec9f9234fd3841ae6f1e4287948f6",
+        "Node name for S&R": "ModelPreviewOverrideKJ",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "widgets_values": [
+        1024,
+        80,
+        true,
+        9,
+        12,
+        "taeh3.safetensors",
+        ""
+      ],
+      "widgets_values_named": {
+        "max_resolution": 1024,
+        "jpeg_quality": 80,
+        "suppress_default_preview": true,
+        "preview_frames": 9,
+        "preview_fps": 12,
+        "tiny_vae": "taeh3.safetensors",
+        "preview": ""
+      },
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 13,
+      "type": "SplitSigmas",
+      "pos": [
+        1284.8250542722158,
+        5119.253828393941
+      ],
+      "size": [
+        308.3164287851357,
+        78
+      ],
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 18
+        }
+      ],
+      "outputs": [
+        {
+          "name": "high_sigmas",
+          "type": "SIGMAS",
+          "links": [
+            30
+          ]
+        },
+        {
+          "name": "low_sigmas",
+          "type": "SIGMAS",
+          "links": []
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.0",
+        "Node name for S&R": "SplitSigmas",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.2"
+        }
+      },
+      "widgets_values": [
+        4
+      ],
+      "widgets_values_named": {
+        "step": 4
+      },
+      "color": "#223",
+      "bgcolor": "#335"
+    },
+    {
+      "id": 14,
+      "type": "VAEDecodeAudio",
+      "pos": [
+        2670.464205116373,
+        5117.045715347668
+      ],
+      "size": [
+        230,
+        60
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 34,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 19
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 20
+        }
+      ],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": [
+            42
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecodeAudio",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 15,
+      "type": "CLIPLoader",
+      "pos": [
+        -306.15299615894105,
+        4843.880667348764
+      ],
+      "size": [
+        640,
+        120
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            10
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "CLIPLoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "models": [
+          {
+            "name": "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+            "directory": "text_encoders"
+          }
+        ]
+      },
+      "widgets_values": [
+        "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "minimax",
+        "default"
+      ],
+      "widgets_values_named": {
+        "clip_name": "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "type": "minimax",
+        "device": "default"
+      }
+    },
+    {
+      "id": 16,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        2671.2544142840693,
+        4689.961821972248
+      ],
+      "size": [
+        230,
+        244.65625
+      ],
+      "flags": {},
+      "order": 33,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 21
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 22
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 23
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 24
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 25
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": [
+            19,
+            33
+          ]
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": []
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "SamplerCustomAdvanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 17,
+      "type": "PrimitiveFloat",
+      "pos": [
+        -295.4580064947545,
+        5575.5407913785275
+      ],
+      "size": [
+        270,
+        70
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            26
+          ]
+        }
+      ],
+      "title": "Float (Duration)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "PrimitiveFloat",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        5
+      ],
+      "widgets_values_named": {
+        "value": 5
+      },
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 18,
+      "type": "KSamplerSelect",
+      "pos": [
+        1284.8250542722158,
+        4831.866013030215
+      ],
+      "size": [
+        308.3164287851357,
+        58
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "SAMPLER",
+          "type": "SAMPLER",
+          "links": [
+            23,
+            29
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "KSamplerSelect",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "euler"
+      ],
+      "widgets_values_named": {
+        "sampler_name": "euler"
+      }
+    },
+    {
+      "id": 21,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        1637.6859974582662,
+        4688.965281374599
+      ],
+      "size": [
+        230.98336128023698,
+        302.67456553398097
+      ],
+      "flags": {},
+      "order": 26,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 27
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 28
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 29
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 30
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 31
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": []
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": [
+            4,
+            6,
+            43
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "SamplerCustomAdvanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 22,
+      "type": "ManualSigmas",
+      "pos": [
+        2358.2357570959043,
+        4924.113084521008
+      ],
+      "size": [
+        266.579898552601,
+        58
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "sigmas",
+          "name": "sigmas",
+          "type": "STRING",
+          "widget": {
+            "name": "sigmas"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "SIGMAS",
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": []
+        }
+      ],
+      "title": "4 step Sigmas",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "ManualSigmas",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      },
+      "widgets_values": [
+        "0.9035, 0.8000, 0.6316, 0.3158, 0.0000"
+      ],
+      "widgets_values_named": {
+        "sigmas": "0.9035, 0.8000, 0.6316, 0.3158, 0.0000"
+      }
+    },
+    {
+      "id": 23,
+      "type": "PrimitiveFloat",
+      "pos": [
+        -300.93105593155974,
+        5772.312661072873
+      ],
+      "size": [
+        291.8643748353079,
+        58
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            36
+          ]
+        }
+      ],
+      "title": "target_megapixels(放大的像素数)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "PrimitiveFloat",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        1
+      ],
+      "widgets_values_named": {
+        "value": 1
+      },
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 24,
+      "type": "BasicScheduler",
+      "pos": [
+        1284.8250542722158,
+        4948.94655111434
+      ],
+      "size": [
+        308.3164287851357,
+        111.22673919547651
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 32
+        }
+      ],
+      "outputs": [
+        {
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            18
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "BasicScheduler",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "simple",
+        8,
+        1
+      ],
+      "widgets_values_named": {
+        "scheduler": "simple",
+        "steps": 8,
+        "denoise": 1
+      }
+    },
+    {
+      "id": 25,
+      "type": "VAEDecode",
+      "pos": [
+        2671.3761513913773,
+        4995.482627248038
+      ],
+      "size": [
+        230,
+        60
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 35,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 33
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 34
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            41
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 27,
+      "type": "MarkdownNote",
+      "pos": [
+        -827.4982958786786,
+        4626.87618265607
+      ],
+      "size": [
+        440,
+        740
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Note: Model Links",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "## Model Links\n[🤗 Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3)\n\n**vae**\n\n- [minimax_h3_video_vae_fp16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors)\n- [minimax_h3_audio_vae_fp32.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors)\n\n**diffusion_models**\n\n- [minimax_h3_ref2va_pruned_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors)\n\n**text_encoders**\n\n- [qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors)\n\n\n## Model Storage Location\n\n```\n📂 ComfyUI/\n├── 📂 models/\n│   ├── 📂 vae/\n│   │   ├── minimax_h3_video_vae_fp16.safetensors\n│   │   └── minimax_h3_audio_vae_fp32.safetensors\n│   ├── 📂 diffusion_models/\n│   │   └── minimax_h3_ref2va_pruned_int8_convrot.safetensors\n│   └── 📂 text_encoders/\n│       └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors\n```\n\n## Report Issue\n\nNote: Please update ComfyUI first ([guide](https://docs.comfy.org/installation/update_comfyui)) and prepare required models. Desktop/Cloud updates follow stable releases, so some nightly-supported models may not be available yet.\n\n- Cannot run / runtime errors: [ComfyUI/issues](https://github.com/comfyanonymous/ComfyUI/issues)\n- UI / frontend issues: [ComfyUI_frontend/issues](https://github.com/Comfy-Org/ComfyUI_frontend/issues)\n- Workflow issues: [workflow_templates/issues](https://github.com/Comfy-Org/workflow_templates/issues)\n"
+      ],
+      "widgets_values_named": {
+        "text": "## Model Links\n[🤗 Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3)\n\n**vae**\n\n- [minimax_h3_video_vae_fp16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors)\n- [minimax_h3_audio_vae_fp32.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors)\n\n**diffusion_models**\n\n- [minimax_h3_ref2va_pruned_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors)\n\n**text_encoders**\n\n- [qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors)\n\n\n## Model Storage Location\n\n```\n📂 ComfyUI/\n├── 📂 models/\n│   ├── 📂 vae/\n│   │   ├── minimax_h3_video_vae_fp16.safetensors\n│   │   └── minimax_h3_audio_vae_fp32.safetensors\n│   ├── 📂 diffusion_models/\n│   │   └── minimax_h3_ref2va_pruned_int8_convrot.safetensors\n│   └── 📂 text_encoders/\n│       └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors\n```\n\n## Report Issue\n\nNote: Please update ComfyUI first ([guide](https://docs.comfy.org/installation/update_comfyui)) and prepare required models. Desktop/Cloud updates follow stable releases, so some nightly-supported models may not be available yet.\n\n- Cannot run / runtime errors: [ComfyUI/issues](https://github.com/comfyanonymous/ComfyUI/issues)\n- UI / frontend issues: [ComfyUI_frontend/issues](https://github.com/Comfy-Org/ComfyUI_frontend/issues)\n- Workflow issues: [workflow_templates/issues](https://github.com/Comfy-Org/workflow_templates/issues)\n"
+      },
+      "color": "#222",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 28,
+      "type": "MarkdownNote",
+      "pos": [
+        -698.29987297497,
+        5452.995280949237
+      ],
+      "size": [
+        300,
+        520
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Note: Size Settings Reference",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "| megapixels | Aspect | Output (multiple=32) |\n|---|---|---|\n| 0.2 | 16:9 | 608 x 352 |\n| 0.3 | 16:9 | 736 x 416 |\n| 0.4 | 16:9 | 864 x 480 |\n| 0.5 | 16:9 | 960 x 544 |\n| 0.6 | 16:9 | 1056 x 608 |\n| 0.7 | 16:9 | 1152 x 640 |\n| 0.8 | 16:9 | 1216 x 672 |\n| 0.9 | 16:9 | 1280 x 736 |\n| 0.98 | 16:9 | 1344 x 768 |\n| 1.0 | 16:9 | 1376 x 768 |\n| 1.2 | 16:9 | 1504 x 832 |\n| 1.5 | 16:9 | 1664 x 928 |\n| 1.8 | 16:9 | 1824 x 1024 |\n| 2.0 | 16:9 | 1920 x 1088 |\n"
+      ],
+      "widgets_values_named": {
+        "text": "| megapixels | Aspect | Output (multiple=32) |\n|---|---|---|\n| 0.2 | 16:9 | 608 x 352 |\n| 0.3 | 16:9 | 736 x 416 |\n| 0.4 | 16:9 | 864 x 480 |\n| 0.5 | 16:9 | 960 x 544 |\n| 0.6 | 16:9 | 1056 x 608 |\n| 0.7 | 16:9 | 1152 x 640 |\n| 0.8 | 16:9 | 1216 x 672 |\n| 0.9 | 16:9 | 1280 x 736 |\n| 0.98 | 16:9 | 1344 x 768 |\n| 1.0 | 16:9 | 1376 x 768 |\n| 1.2 | 16:9 | 1504 x 832 |\n| 1.5 | 16:9 | 1664 x 928 |\n| 1.8 | 16:9 | 1824 x 1024 |\n| 2.0 | 16:9 | 1920 x 1088 |\n"
+      },
+      "color": "#222",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 29,
+      "type": "BasicGuider",
+      "pos": [
+        1284.8250542722158,
+        4712.78547494609
+      ],
+      "size": [
+        308.3164287851357,
+        60
+      ],
+      "flags": {},
+      "order": 25,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 37
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 38
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            28
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "BasicGuider",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 30,
+      "type": "UNETLoader",
+      "pos": [
+        -306.72273558820143,
+        4689.4444360439265
+      ],
+      "size": [
+        640,
+        90
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            32,
+            44
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "UNETLoader",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        },
+        "models": [
+          {
+            "name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+            "directory": "diffusion_models"
+          }
+        ]
+      },
+      "widgets_values": [
+        "minimax_h3_ref2va_int8_convrot.safetensors",
+        "default"
+      ],
+      "widgets_values_named": {
+        "unet_name": "minimax_h3_ref2va_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      }
+    },
+    {
+      "id": 31,
+      "type": "RandomNoise",
+      "pos": [
+        427.616431673551,
+        4690.66092333044
+      ],
+      "size": [
+        375.96979953612185,
+        82
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "NOISE",
+          "type": "NOISE",
+          "links": [
+            21,
+            27
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "RandomNoise",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        42,
+        "fixed"
+      ],
+      "widgets_values_named": {
+        "noise_seed": 42,
+        "control_after_generate": "fixed"
+      }
+    },
+    {
+      "id": 32,
+      "type": "BasicGuider",
+      "pos": [
+        2357.730698917854,
+        4699.904827320822
+      ],
+      "size": [
+        270,
+        60
+      ],
+      "flags": {},
+      "order": 24,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 39
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 40
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            22
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "BasicGuider",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 33,
+      "type": "ManualSigmas",
+      "pos": [
+        2358.2357570959043,
+        4821.483047768253
+      ],
+      "size": [
+        266.579898552601,
+        58
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "sigmas",
+          "name": "sigmas",
+          "type": "STRING",
+          "widget": {
+            "name": "sigmas"
+          },
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "label": "SIGMAS",
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            24
+          ]
+        }
+      ],
+      "title": "3 step Sigmas",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "ManualSigmas",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      },
+      "widgets_values": [
+        "0.9035, 0.6316, 0.3158, 0.0000"
+      ],
+      "widgets_values_named": {
+        "sigmas": "0.9035, 0.6316, 0.3158, 0.0000"
+      }
+    },
+    {
+      "id": 34,
+      "type": "CreateVideo",
+      "pos": [
+        2941.323495671123,
+        4693.231361398204
+      ],
+      "size": [
+        283.1269337209078,
+        102
+      ],
+      "flags": {},
+      "order": 36,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 41
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 42
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VIDEO",
+          "type": "VIDEO",
+          "links": [
+            3
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "CreateVideo",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        24,
+        8
+      ],
+      "widgets_values_named": {
+        "fps": 24,
+        "bit_depth": 8
+      }
+    },
+    {
+      "id": 35,
+      "type": "LTXVSeparateAVLatent",
+      "pos": [
+        1966.715273508606,
+        4699.039493830161
+      ],
+      "size": [
+        286.836067965115,
+        48.43467905382113
+      ],
+      "flags": {},
+      "order": 29,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "av_latent",
+          "name": "av_latent",
+          "type": "LATENT",
+          "link": 43
+        }
+      ],
+      "outputs": [
+        {
+          "label": "video_latent",
+          "name": "video_latent",
+          "type": "LATENT",
+          "links": [
+            35
+          ]
+        },
+        {
+          "label": "audio_latent",
+          "name": "audio_latent",
+          "type": "LATENT",
+          "links": [
+            9
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.5.1",
+        "Node name for S&R": "LTXVSeparateAVLatent",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.2",
+          "input_ue_unconnectable": {}
+        },
+        "enableTabs": false,
+        "tabWidth": 65,
+        "tabXOffset": 10,
+        "hasSecondTab": false,
+        "secondTabText": "Send Back",
+        "secondTabOffset": 80,
+        "secondTabWidth": 65
+      }
+    },
+    {
+      "id": 36,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        437.53065825024066,
+        4481.39443401648
+      ],
+      "size": [
+        453.3210289616586,
+        82
+      ],
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 44
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            46
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "LoraLoaderModelOnly",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "Minimax_H3\\minimax_h3_fl2v_lightx2v_turbo_4step_v0.1_comfy.safetensors",
+        1
+      ],
+      "widgets_values_named": {
+        "lora_name": "Minimax_H3\\minimax_h3_fl2v_lightx2v_turbo_4step_v0.1_comfy.safetensors",
+        "strength_model": 1
+      }
+    },
+    {
+      "id": 37,
+      "type": "ModelAttentionBackend",
+      "pos": [
+        1212.250299654286,
+        4477.499802262122
+      ],
+      "size": [
+        270,
+        62
+      ],
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 45
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            16,
+            39
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "ModelAttentionBackend",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "comfy kitchen attention"
+      ],
+      "widgets_values_named": {
+        "attention": "comfy kitchen attention"
+      }
+    },
+    {
+      "id": 26,
+      "type": "MinimaxH3LatentUpscaler3D",
+      "pos": [
+        1969.409199969843,
+        4827.265029425342
+      ],
+      "size": [
+        286.836067965115,
+        202
+      ],
+      "flags": {},
+      "order": 31,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "link": 35
+        },
+        {
+          "name": "mode.megapixels",
+          "type": "FLOAT",
+          "widget": {
+            "name": "mode.megapixels"
+          },
+          "link": 36
+        }
+      ],
+      "outputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "links": [
+            8
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "MinimaxH3LatentUpscaler3D",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        "minimax_h3_latent_upscaler_3d_fp16.safetensors",
+        "megapixels",
+        1,
+        32,
+        false,
+        "cuda",
+        "fp16"
+      ],
+      "widgets_values_named": {
+        "model_name": "minimax_h3_latent_upscaler_3d_fp16.safetensors",
+        "mode": "megapixels",
+        "mode.megapixels": 1,
+        "align": 32,
+        "keep_proportion": false,
+        "device": "cuda",
+        "precision": "fp16"
+      }
+    },
+    {
+      "id": 20,
+      "type": "ResolutionSelector",
+      "pos": [
+        -292.50792265404357,
+        5395.858603868241
+      ],
+      "size": [
+        270.983361280237,
+        126
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "showAdvanced": false,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            47
+          ]
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            48
+          ]
+        }
+      ],
+      "title": "Resolution Selector (Size)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "ResolutionSelector",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "16:9 (Widescreen)",
+        0.2,
+        32
+      ],
+      "widgets_values_named": {
+        "aspect_ratio": "16:9 (Widescreen)",
+        "megapixels": 0.2,
+        "multiple": 32
+      },
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 19,
+      "type": "ComfyMathExpression",
+      "pos": [
+        -168.6086245942965,
+        5700.738192982189
+      ],
+      "size": [
+        225,
+        116
+      ],
+      "flags": {
+        "collapsed": true
+      },
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "a",
+          "name": "values.a",
+          "type": "FLOAT,INT,BOOLEAN",
+          "link": 26
+        },
+        {
+          "label": "b",
+          "name": "values.b",
+          "shape": 7,
+          "type": "FLOAT,INT,BOOLEAN",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": []
+        },
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            17,
+            49
+          ]
+        },
+        {
+          "name": "BOOL",
+          "type": "BOOLEAN",
+          "links": []
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.2",
+        "Node name for S&R": "ComfyMathExpression",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.8",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17"
+      ],
+      "widgets_values_named": {
+        "expression": "max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17"
+      }
+    },
+    {
+      "id": 38,
+      "type": "MiniMaxH3SigmaShift",
+      "pos": [
+        913.6385462171465,
+        4479.056966713434
+      ],
+      "size": [
+        272.23402873514397,
+        82
+      ],
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 46
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            45
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "MiniMaxH3SigmaShift",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        12,
+        3
+      ],
+      "widgets_values_named": {
+        "shift_video": 12,
+        "shift_audio": 3
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      7,
+      0,
+      1,
+      0,
+      "IMAGE"
+    ],
+    [
+      2,
+      8,
+      0,
+      1,
+      1,
+      "AUDIO"
+    ],
+    [
+      3,
+      34,
+      0,
+      5,
+      0,
+      "VIDEO"
+    ],
+    [
+      4,
+      21,
+      1,
+      7,
+      0,
+      "LATENT"
+    ],
+    [
+      5,
+      3,
+      0,
+      7,
+      1,
+      "VAE"
+    ],
+    [
+      6,
+      21,
+      1,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      7,
+      4,
+      0,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      8,
+      26,
+      0,
+      10,
+      0,
+      "LATENT"
+    ],
+    [
+      9,
+      35,
+      1,
+      10,
+      1,
+      "LATENT"
+    ],
+    [
+      10,
+      15,
+      0,
+      11,
+      0,
+      "CLIP"
+    ],
+    [
+      11,
+      3,
+      0,
+      11,
+      1,
+      "VAE"
+    ],
+    [
+      12,
+      4,
+      0,
+      11,
+      2,
+      "VAE"
+    ],
+    [
+      13,
+      9,
+      0,
+      11,
+      3,
+      "IMAGE"
+    ],
+    [
+      16,
+      37,
+      0,
+      12,
+      0,
+      "MODEL"
+    ],
+    [
+      17,
+      19,
+      1,
+      12,
+      2,
+      "INT"
+    ],
+    [
+      18,
+      24,
+      0,
+      13,
+      0,
+      "SIGMAS"
+    ],
+    [
+      19,
+      16,
+      0,
+      14,
+      0,
+      "LATENT"
+    ],
+    [
+      20,
+      4,
+      0,
+      14,
+      1,
+      "VAE"
+    ],
+    [
+      21,
+      31,
+      0,
+      16,
+      0,
+      "NOISE"
+    ],
+    [
+      22,
+      32,
+      0,
+      16,
+      1,
+      "GUIDER"
+    ],
+    [
+      23,
+      18,
+      0,
+      16,
+      2,
+      "SAMPLER"
+    ],
+    [
+      24,
+      33,
+      0,
+      16,
+      3,
+      "SIGMAS"
+    ],
+    [
+      25,
+      10,
+      0,
+      16,
+      4,
+      "LATENT"
+    ],
+    [
+      26,
+      17,
+      0,
+      19,
+      0,
+      "FLOAT"
+    ],
+    [
+      27,
+      31,
+      0,
+      21,
+      0,
+      "NOISE"
+    ],
+    [
+      28,
+      29,
+      0,
+      21,
+      1,
+      "GUIDER"
+    ],
+    [
+      29,
+      18,
+      0,
+      21,
+      2,
+      "SAMPLER"
+    ],
+    [
+      30,
+      13,
+      0,
+      21,
+      3,
+      "SIGMAS"
+    ],
+    [
+      31,
+      11,
+      1,
+      21,
+      4,
+      "LATENT"
+    ],
+    [
+      32,
+      30,
+      0,
+      24,
+      0,
+      "MODEL"
+    ],
+    [
+      33,
+      16,
+      0,
+      25,
+      0,
+      "LATENT"
+    ],
+    [
+      34,
+      3,
+      0,
+      25,
+      1,
+      "VAE"
+    ],
+    [
+      35,
+      35,
+      0,
+      26,
+      0,
+      "LATENT"
+    ],
+    [
+      36,
+      23,
+      0,
+      26,
+      1,
+      "FLOAT"
+    ],
+    [
+      37,
+      12,
+      0,
+      29,
+      0,
+      "MODEL"
+    ],
+    [
+      38,
+      11,
+      0,
+      29,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      39,
+      37,
+      0,
+      32,
+      0,
+      "MODEL"
+    ],
+    [
+      40,
+      11,
+      0,
+      32,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      41,
+      25,
+      0,
+      34,
+      0,
+      "IMAGE"
+    ],
+    [
+      42,
+      14,
+      0,
+      34,
+      1,
+      "AUDIO"
+    ],
+    [
+      43,
+      21,
+      1,
+      35,
+      0,
+      "LATENT"
+    ],
+    [
+      44,
+      30,
+      0,
+      36,
+      0,
+      "MODEL"
+    ],
+    [
+      45,
+      38,
+      0,
+      37,
+      0,
+      "MODEL"
+    ],
+    [
+      46,
+      36,
+      0,
+      38,
+      0,
+      "MODEL"
+    ],
+    [
+      47,
+      20,
+      0,
+      11,
+      8,
+      "INT"
+    ],
+    [
+      48,
+      20,
+      1,
+      11,
+      9,
+      "INT"
+    ],
+    [
+      49,
+      19,
+      1,
+      11,
+      10,
+      "INT"
+    ]
+  ],
+  "groups": [
+    {
+      "id": 1,
+      "title": "User Inputs",
+      "bounding": [
+        -335.4580064947545,
+        5285.5407913785275,
+        1208.9503194675362,
+        834.450029042503
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 2,
+      "title": "Models",
+      "bounding": [
+        -336.15299615894105,
+        4593.880667348764,
+        700,
+        674
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 3,
+      "title": "Sampling",
+      "bounding": [
+        1247.847003841059,
+        4593.880667348764,
+        659,
+        674
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 4,
+      "title": "Conditioning",
+      "bounding": [
+        381.84700384105895,
+        4593.880667348764,
+        480,
+        674
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 5,
+      "title": "Two-stage sampling upscaling - Decoding and create video",
+      "bounding": [
+        2310.3892605227284,
+        4593.880667348764,
+        948.4270012610004,
+        674.0547621542864
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 6,
+      "title": "H3 Latent Upscaler",
+      "bounding": [
+        1924.847003841059,
+        4593.880667348764,
+        368,
+        674
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 7,
+      "title": "preview",
+      "bounding": [
+        879.847003841059,
+        4593.880667348764,
+        350,
+        674
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {
+    "ue_links": [],
+    "ds": {
+      "scale": 0.6316771145038458,
+      "offset": [
+        2201.5181287178216,
+        -4262.109523178327
+      ]
+    },
+    "frontendVersion": "1.49.6",
+    "VHS_latentpreview": false,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": true,
+    "VHS_KeepIntermediate": true
+  },
+  "version": 0.4
+}

h3_bundle/__init__.py

@@ -0,0 +1,475 @@
+"""
+H3 Bundle — sauvegarde et rechargement de latents AV + conditioning MiniMax H3.
+
+Objectif : découpler la passe de génération (locale) de la passe d'upscaling
+(instance Vast.ai), sans avoir à réimporter les images de référence ni le
+CLIP qwen3vl 32B.
+
+Installation :
+    cp -r h3_bundle /workspace/ComfyUI/custom_nodes/
+    (idem en local dans ComfyUI/custom_nodes/)
+"""
+
+import os
+import json
+import time
+import shutil
+import torch
+
+import folder_paths
+
+
+# --------------------------------------------------------------------------
+# helpers
+# --------------------------------------------------------------------------
+
+def _to_cpu(obj):
+    """Descend récursivement la structure et rapatrie tous les tenseurs en CPU."""
+    if torch.is_tensor(obj):
+        return obj.detach().cpu()
+    if isinstance(obj, dict):
+        return {k: _to_cpu(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return type(obj)(_to_cpu(v) for v in obj)
+    return obj
+
+
+def _shapes(obj):
+    """Cartographie des shapes/dtypes — c'est ce qui te sert à câbler l'amont."""
+    if torch.is_tensor(obj):
+        return f"Tensor{tuple(obj.shape)} {str(obj.dtype).replace('torch.', '')}"
+    if isinstance(obj, dict):
+        return {k: _shapes(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_shapes(v) for v in obj]
+    if isinstance(obj, (int, float, str, bool, type(None))):
+        return repr(obj)
+    return type(obj).__name__
+
+
+def _dir_size(path):
+    total = 0
+    for root, _, files in os.walk(path):
+        for f in files:
+            total += os.path.getsize(os.path.join(root, f))
+    return total
+
+
+def _human(n):
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+def _bundles_root():
+    return os.path.join(folder_paths.get_output_directory(), "h3_bundles")
+
+
+# --------------------------------------------------------------------------
+# preview
+# --------------------------------------------------------------------------
+
+def _tensor_to_pil(frame, max_width=512):
+    """[H,W,C] float 0-1 -> PIL, redimensionné pour rester léger."""
+    from PIL import Image
+    import numpy as np
+    arr = (frame.cpu().numpy() * 255.0).clip(0, 255).astype(np.uint8)
+    img = Image.fromarray(arr)
+    if img.width > max_width:
+        ratio = max_width / img.width
+        img = img.resize((max_width, int(img.height * ratio)), Image.LANCZOS)
+    return img
+
+
+def _sample_frames(images, count):
+    """Échantillonne count frames réparties sur toute la séquence."""
+    total = images.shape[0]
+    if total <= count:
+        return list(range(total))
+    step = (total - 1) / (count - 1) if count > 1 else 1
+    return [min(total - 1, int(round(i * step))) for i in range(count)]
+
+
+def _write_wav(audio, path):
+    """AUDIO ComfyUI ({waveform:[B,C,S], sample_rate}) -> wav 16 bits."""
+    import wave
+    import numpy as np
+    wav = audio["waveform"]
+    if wav.dim() == 3:
+        wav = wav[0]
+    data = wav.transpose(0, 1).cpu().numpy()
+    data = (data.clip(-1, 1) * 32767).astype(np.int16)
+    with wave.open(path, "wb") as fh:
+        fh.setnchannels(data.shape[1])
+        fh.setsampwidth(2)
+        fh.setframerate(int(audio["sample_rate"]))
+        fh.writeframes(data.tobytes())
+
+
+def _encode_mp4(images, fps, out_path, audio=None):
+    """Encode la séquence en mp4 via ffmpeg. Retourne True si ça a marché."""
+    import subprocess
+    import tempfile
+
+    if shutil.which("ffmpeg") is None:
+        print("[SaveH3Bundle] ffmpeg introuvable, preview mp4 ignorée.")
+        return False
+
+    tmp = tempfile.mkdtemp(prefix="h3prev_")
+    try:
+        for i in range(images.shape[0]):
+            _tensor_to_pil(images[i], max_width=720).save(
+                os.path.join(tmp, f"{i:06d}.png"))
+
+        cmd = ["ffmpeg", "-y", "-loglevel", "error",
+               "-framerate", str(fps), "-i", os.path.join(tmp, "%06d.png")]
+
+        wav_path = None
+        if audio is not None:
+            wav_path = os.path.join(tmp, "audio.wav")
+            try:
+                _write_wav(audio, wav_path)
+                cmd += ["-i", wav_path]
+            except Exception as exc:
+                print(f"[SaveH3Bundle] audio preview ignoré : {exc}")
+                wav_path = None
+
+        cmd += ["-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "20"]
+        if wav_path:
+            cmd += ["-c:a", "aac", "-shortest"]
+        cmd.append(out_path)
+
+        subprocess.run(cmd, check=True)
+        return True
+    except Exception as exc:
+        print(f"[SaveH3Bundle] échec encodage preview : {exc}")
+        return False
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+# --------------------------------------------------------------------------
+# SAVE
+# --------------------------------------------------------------------------
+
+class SaveH3Bundle:
+    """
+    Regroupe tout ce dont la passe d'upscale a besoin dans un dossier unique.
+
+    Le latent MiniMax H3 porte déjà vidéo + audio dans sa structure nested,
+    donc un seul torch.save suffit — contrairement au SaveLatent natif qui
+    ne sérialise que la clé `samples`.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "latent": ("LATENT",),
+                "bundle_name": ("STRING", {"default": "run"}),
+                "mode": (["save", "replace_last", "skip"],),
+            },
+            "optional": {
+                "conditioning": ("CONDITIONING",),
+                "video": ("VIDEO",),
+                "video_path": ("STRING", {"default": ""}),
+                "images": ("IMAGE",),
+                "audio": ("AUDIO",),
+                "preview_frames": ("INT", {"default": 6, "min": 0, "max": 24}),
+                "preview_mp4": ("BOOLEAN", {"default": True}),
+                "keep_last_n": ("INT", {"default": 0, "min": 0, "max": 999}),
+                "width": ("INT", {"default": 0, "min": 0, "max": 16384}),
+                "height": ("INT", {"default": 0, "min": 0, "max": 16384}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xFFFFFFFFFFFFFFFF}),
+                "fps": ("INT", {"default": 24, "min": 1, "max": 240}),
+                "generation_seconds": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 600.0}),
+                "notes": ("STRING", {"default": "", "multiline": True}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("bundle_path",)
+    FUNCTION = "save"
+    OUTPUT_NODE = True
+    CATEGORY = "vast/h3"
+
+    @staticmethod
+    def _existing_bundles():
+        """Bundles valides, du plus ancien au plus récent."""
+        root = _bundles_root()
+        if not os.path.isdir(root):
+            return []
+        found = []
+        for name in sorted(os.listdir(root)):
+            path = os.path.join(root, name)
+            if os.path.isdir(path) and os.path.isfile(os.path.join(path, "latent.pt")):
+                found.append(path)
+        return found
+
+    @staticmethod
+    def _delete_bundle(path):
+        """Suppression volontairement paranoïaque : jamais hors de h3_bundles,
+        et uniquement un dossier qui contient bien un latent.pt."""
+        root = os.path.abspath(_bundles_root())
+        target = os.path.abspath(path)
+        if not target.startswith(root + os.sep):
+            print(f"[SaveH3Bundle] REFUS suppression hors bundles : {target}")
+            return False
+        if not os.path.isfile(os.path.join(target, "latent.pt")):
+            print(f"[SaveH3Bundle] REFUS suppression, pas un bundle : {target}")
+            return False
+        shutil.rmtree(target)
+        print(f"[SaveH3Bundle] supprimé : {os.path.basename(target)}")
+        return True
+
+    def save(self, latent, bundle_name, mode="save", conditioning=None,
+             video=None, video_path="", images=None, audio=None,
+             preview_frames=6, preview_mp4=True,
+             keep_last_n=0, width=0, height=0, seed=0, fps=24,
+             generation_seconds=0.0, notes=""):
+
+        if mode == "skip":
+            print("[SaveH3Bundle] mode 'skip' — rien n'est écrit sur le disque.")
+            return {"ui": {"text": ["skip"]}, "result": ("",)}
+
+        if mode == "replace_last":
+            existing = self._existing_bundles()
+            if existing:
+                self._delete_bundle(existing[-1])
+            else:
+                print("[SaveH3Bundle] 'replace_last' : aucun bundle à supprimer.")
+
+        safe = "".join(c for c in bundle_name if c.isalnum() or c in "-_") or "run"
+        stamp = time.strftime("%Y%m%d_%H%M%S")
+        root = os.path.join(_bundles_root(), f"{safe}_{stamp}")
+        os.makedirs(root, exist_ok=True)
+
+        manifest = {
+            "bundle_name": safe,
+            "created": stamp,
+            "width": width,
+            "height": height,
+            "seed": seed,
+            "fps": fps,
+            "generation_seconds": generation_seconds,
+            "notes": notes,
+            "has_conditioning": conditioning is not None,
+        }
+
+        torch.save(_to_cpu(latent), os.path.join(root, "latent.pt"))
+        manifest["latent_structure"] = _shapes(latent)
+
+        if conditioning is not None:
+            torch.save(_to_cpu(conditioning), os.path.join(root, "cond.pt"))
+            manifest["cond_structure"] = _shapes(conditioning)
+
+        manifest["files"] = {
+            f: _human(os.path.getsize(os.path.join(root, f)))
+            for f in sorted(os.listdir(root))
+        }
+        manifest["total_size"] = _human(_dir_size(root))
+
+        with open(os.path.join(root, "manifest.json"), "w") as fh:
+            json.dump(manifest, fh, indent=2, default=str)
+
+        print("\n" + "=" * 66)
+        print(f"[SaveH3Bundle] {root}")
+        print(f"  total : {manifest['total_size']}")
+        print("  structure latent :")
+        print(json.dumps(manifest["latent_structure"], indent=4, default=str))
+        if conditioning is not None:
+            print("  structure conditioning :")
+            print(json.dumps(manifest["cond_structure"], indent=4, default=str))
+        print("=" * 66 + "\n")
+
+        # ---- preview ----------------------------------------------------
+        ui_images = []
+        dest_mp4 = os.path.join(root, "preview.mp4")
+        got_video = False
+
+        # 1. objet VIDEO natif (sortie de CreateVideo) — écriture directe
+        if video is not None:
+            try:
+                video.save_to(dest_mp4)
+                got_video = True
+                print(f"[SaveH3Bundle] vidéo écrite : {dest_mp4}")
+            except Exception as exc:
+                print(f"[SaveH3Bundle] save_to a échoué ({exc}), on tente autre chose.")
+
+        # 2. chemin d'un fichier déjà écrit par un autre node — simple copie
+        if not got_video and video_path:
+            src = video_path
+            if not os.path.isabs(src):
+                src = os.path.join(folder_paths.get_output_directory(), src)
+            if os.path.isfile(src):
+                shutil.copy2(src, os.path.join(root, os.path.basename(src)))
+                got_video = True
+                print(f"[SaveH3Bundle] vidéo copiée : {os.path.basename(src)}")
+            else:
+                print(f"[SaveH3Bundle] video_path introuvable : {src}")
+
+        # 3. dernier recours — ré-encodage depuis les frames
+        if not got_video and preview_mp4 and images is not None and images.shape[0] > 0:
+            if _encode_mp4(images, fps, dest_mp4, audio=audio):
+                got_video = True
+
+        manifest["has_video"] = got_video
+
+        if images is not None and images.shape[0] > 0 and preview_frames > 0:
+            sub = os.path.join("h3_bundles", os.path.basename(root))
+            for n, idx in enumerate(_sample_frames(images, preview_frames)):
+                fname = f"preview_{n:02d}.png"
+                _tensor_to_pil(images[idx]).save(os.path.join(root, fname))
+                ui_images.append({
+                    "filename": fname,
+                    "subfolder": sub,
+                    "type": "output",
+                })
+
+        manifest["files"] = {
+            f: _human(os.path.getsize(os.path.join(root, f)))
+            for f in sorted(os.listdir(root)) if os.path.isfile(os.path.join(root, f))
+        }
+        manifest["total_size"] = _human(_dir_size(root))
+        with open(os.path.join(root, "manifest.json"), "w") as fh:
+            json.dump(manifest, fh, indent=2, default=str)
+
+        if keep_last_n > 0:
+            everything = self._existing_bundles()
+            for old in everything[:-keep_last_n]:
+                self._delete_bundle(old)
+
+        return {"ui": {"images": ui_images, "text": [root]}, "result": (root,)}
+
+
+# --------------------------------------------------------------------------
+# LOAD
+# --------------------------------------------------------------------------
+
+class LoadH3BundleBatch:
+    """
+    Recharge un bundle. ComfyUI n'a pas de boucle interne : le batch séquentiel
+    se fait en empilant N runs dans la queue.
+
+    mode = "index"        -> tu choisis le bundle à la main (debug / rerun)
+    mode = "next_pending" -> avance tout seul dans le dossier, un bundle par
+                             run. Tu cliques Queue N fois (ou tu mets le batch
+                             count à N) et il déroule la liste.
+
+    Un bundle est considéré comme traité si un fichier de sortie portant son
+    nom existe déjà dans output/<output_subdir>/. Pas de marqueur : un run qui
+    plante est repris automatiquement au run suivant.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "bundles_dir": ("STRING", {"default": "h3_bundles"}),
+                "mode": (["next_pending", "index"],),
+                "index": ("INT", {"default": 0, "min": 0, "max": 9999}),
+            },
+            "optional": {
+                "output_subdir": ("STRING", {"default": "minimax-h3"}),
+            },
+        }
+
+    RETURN_TYPES = ("LATENT", "CONDITIONING", "STRING", "INT", "INT", "INT")
+    RETURN_NAMES = ("latent", "conditioning", "filename_prefix",
+                    "width", "height", "remaining")
+    FUNCTION = "load"
+    CATEGORY = "vast/h3"
+
+    @classmethod
+    def IS_CHANGED(cls, mode, **kwargs):
+        # en next_pending l'état change à chaque run : on casse le cache
+        if mode == "next_pending":
+            return float("nan")
+        return json.dumps(kwargs, sort_keys=True, default=str)
+
+    def _resolve_dir(self, bundles_dir):
+        if os.path.isabs(bundles_dir):
+            return bundles_dir
+        for base in (folder_paths.get_output_directory(),
+                     folder_paths.get_input_directory()):
+            cand = os.path.join(base, bundles_dir)
+            if os.path.isdir(cand):
+                return cand
+        return os.path.join(folder_paths.get_output_directory(), bundles_dir)
+
+    def _list_bundles(self, root):
+        if not os.path.isdir(root):
+            raise FileNotFoundError(f"Dossier de bundles introuvable : {root}")
+        out = []
+        for name in sorted(os.listdir(root)):
+            path = os.path.join(root, name)
+            if os.path.isdir(path) and os.path.isfile(os.path.join(path, "latent.pt")):
+                out.append(path)
+        if not out:
+            raise FileNotFoundError(f"Aucun bundle valide dans {root}")
+        return out
+
+    def _has_output(self, bundle_path, output_subdir):
+        """Un bundle est traité si un fichier de sortie porte son nom."""
+        out_dir = os.path.join(folder_paths.get_output_directory(), output_subdir)
+        if not os.path.isdir(out_dir):
+            return False
+        name = os.path.basename(bundle_path)
+        return any(f.startswith(name) for f in os.listdir(out_dir))
+
+    def load(self, bundles_dir, mode, index, output_subdir="minimax-h3"):
+        root = self._resolve_dir(bundles_dir)
+        bundles = self._list_bundles(root)
+
+        if mode == "index":
+            if index >= len(bundles):
+                raise IndexError(f"index {index} hors bornes ({len(bundles)} bundles)")
+            target = bundles[index]
+            remaining = len(bundles) - index - 1
+        else:
+            pending = [b for b in bundles if not self._has_output(b, output_subdir)]
+            if not pending:
+                raise RuntimeError(
+                    f"Les {len(bundles)} bundles de {root} ont déjà une sortie dans "
+                    f"output/{output_subdir}/. Supprime les mp4 correspondants pour "
+                    f"les relancer, ou passe en mode 'index'."
+                )
+            target = pending[0]
+            remaining = len(pending) - 1
+
+        latent = torch.load(os.path.join(target, "latent.pt"),
+                            map_location="cpu", weights_only=False)
+
+        cond_file = os.path.join(target, "cond.pt")
+        conditioning = []
+        if os.path.isfile(cond_file):
+            conditioning = torch.load(cond_file, map_location="cpu", weights_only=False)
+
+        width = height = 0
+        manifest_file = os.path.join(target, "manifest.json")
+        if os.path.isfile(manifest_file):
+            with open(manifest_file) as fh:
+                m = json.load(fh)
+            width = int(m.get("width", 0) or 0)
+            height = int(m.get("height", 0) or 0)
+
+        name = os.path.basename(target)
+        prefix = f"minimax-h3/{name}_upscaled"
+
+        print(f"[LoadH3BundleBatch] {name} | cond={'oui' if conditioning else 'non'} "
+              f"| {width}x{height} | restants : {remaining}")
+
+        return (latent, conditioning, prefix, width, height, remaining)
+
+
+NODE_CLASS_MAPPINGS = {
+    "SaveH3Bundle": SaveH3Bundle,
+    "LoadH3BundleBatch": LoadH3BundleBatch,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "SaveH3Bundle": "Save H3 Bundle (latent AV + cond)",
+    "LoadH3BundleBatch": "Load H3 Bundle (batch séquentiel)",
+}

note.txt

@@ -0,0 +1 @@
+https://github.com/Saganaki22/ComfyUI-VDN-H3

workflow/Bundle_h3.json

@@ -0,0 +1,1978 @@
+{
+  "id": "159c3537-7c23-4c93-bd07-e5439b5c4017",
+  "revision": 0,
+  "last_node_id": 36,
+  "last_link_id": 38,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "MinimaxH3LatentUpscaler3D",
+      "pos": [
+        3856.1660843903683,
+        5916.413832444967
+      ],
+      "size": [
+        461.3766842951726,
+        226
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "link": 18
+        }
+      ],
+      "outputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "links": [
+            36
+          ]
+        }
+      ],
+      "properties": {
+        "aux_id": "LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler",
+        "ver": "d7c01b9011f2e8439493f6c02c29995a27df276f",
+        "Node name for S&R": "MinimaxH3LatentUpscaler3D",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "minimax_h3_latent_upscaler_3d_bf16.safetensors",
+        "scale by multiplier",
+        1.5,
+        32,
+        true,
+        true,
+        "cuda",
+        "fp16"
+      ],
+      "widgets_values_named": {
+        "model_name": "minimax_h3_latent_upscaler_3d_bf16.safetensors",
+        "mode": "scale by multiplier",
+        "mode.scale": 1.5,
+        "align": 32,
+        "enable_temporal_chunking": true,
+        "force_unload": true,
+        "device": "cuda",
+        "precision": "fp16"
+      }
+    },
+    {
+      "id": 2,
+      "type": "GetNode",
+      "pos": [
+        4189.533821259078,
+        6352.722810277472
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1,
+            3
+          ]
+        }
+      ],
+      "title": "Get_model_VDN",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "model_VDN"
+      ],
+      "widgets_values_named": {
+        "Constant": "model_VDN"
+      },
+      "color": "#1f1f48",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 4,
+      "type": "KSamplerSelect",
+      "pos": [
+        4540.866963201227,
+        6206.558421641109
+      ],
+      "size": [
+        361.19999999999993,
+        66.19999999999982
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "SAMPLER",
+          "type": "SAMPLER",
+          "links": [
+            6
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "KSamplerSelect",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "euler"
+      ],
+      "widgets_values_named": {
+        "sampler_name": "euler"
+      }
+    },
+    {
+      "id": 5,
+      "type": "BasicGuider",
+      "pos": [
+        4530.087815400926,
+        6089.176927689423
+      ],
+      "size": [
+        360,
+        60
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 19
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            5
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "BasicGuider",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 6,
+      "type": "RandomNoise",
+      "pos": [
+        4540.866963201227,
+        5947.758421641106
+      ],
+      "size": [
+        360,
+        90
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "NOISE",
+          "type": "NOISE",
+          "links": [
+            4
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "RandomNoise",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        42,
+        "fixed"
+      ],
+      "widgets_values_named": {
+        "noise_seed": 42,
+        "control_after_generate": "fixed"
+      }
+    },
+    {
+      "id": 7,
+      "type": "BasicScheduler",
+      "pos": [
+        4540.866963201227,
+        6328.758421641109
+      ],
+      "size": [
+        370,
+        130
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            7
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "BasicScheduler",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "simple",
+        3,
+        0.2
+      ],
+      "widgets_values_named": {
+        "scheduler": "simple",
+        "steps": 3,
+        "denoise": 0.2
+      }
+    },
+    {
+      "id": 8,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        5102.116963201228,
+        6078.758421641109
+      ],
+      "size": [
+        239.76709241172045,
+        326
+      ],
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 4
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 5
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 6
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 7
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 36
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": [
+            9
+          ]
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": []
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "SamplerCustomAdvanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 9,
+      "type": "GetNode",
+      "pos": [
+        5462.805825592742,
+        6109.340215847699
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 5,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            10
+          ]
+        }
+      ],
+      "title": "Get_vae_video",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "vae_video"
+      ],
+      "widgets_values_named": {
+        "Constant": "vae_video"
+      },
+      "color": "#af3535",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 10,
+      "type": "VAEDecode",
+      "pos": [
+        5477.721985489667,
+        6271.643325921581
+      ],
+      "size": [
+        230,
+        60
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 9
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 10
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            11
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 11,
+      "type": "MathExpression|pysssss",
+      "pos": [
+        5860.105045064689,
+        6373.189217624035
+      ],
+      "size": [
+        400,
+        200
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "a",
+          "shape": 7,
+          "type": "INT,FLOAT,IMAGE,LATENT",
+          "link": null
+        },
+        {
+          "name": "b",
+          "shape": 7,
+          "type": "INT,FLOAT,IMAGE,LATENT",
+          "link": null
+        },
+        {
+          "name": "c",
+          "shape": 7,
+          "type": "INT,FLOAT,IMAGE,LATENT",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            14,
+            35
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-custom-scripts",
+        "ver": "1.2.5",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "24*2"
+      ],
+      "widgets_values_named": {
+        "expression": "24*2"
+      }
+    },
+    {
+      "id": 12,
+      "type": "RIFEInterpolation",
+      "pos": [
+        6289.458038457433,
+        6271.208568461926
+      ],
+      "size": [
+        270,
+        178
+      ],
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 11
+        },
+        {
+          "name": "target_fps",
+          "type": "FLOAT",
+          "widget": {
+            "name": "target_fps"
+          },
+          "link": 35
+        }
+      ],
+      "outputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "links": [
+            12
+          ]
+        }
+      ],
+      "properties": {
+        "aux_id": "GACLove/ComfyUI-VFI",
+        "ver": "6176a430f12cd16003f4664c1e3c6af8e96cc3c6",
+        "Node name for S&R": "RIFEInterpolation",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        24,
+        48,
+        1,
+        "flownet.pkl",
+        8,
+        true
+      ],
+      "widgets_values_named": {
+        "source_fps": 24,
+        "target_fps": 48,
+        "scale": 1,
+        "model_name": "flownet.pkl",
+        "batch_size": 8,
+        "use_fp16": true
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 13,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        7003.629054557495,
+        5614.858443597528
+      ],
+      "size": [
+        693.741563959413,
+        1470.9026065990217
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 12
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 37
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        },
+        {
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "widget": {
+            "name": "frame_rate"
+          },
+          "link": 14
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "title": "Video Output 2 (Output)",
+      "properties": {
+        "cnr_id": "comfyui-videohelpersuite",
+        "ver": "993082e4f2473bf4acaf06f51e33877a7eb38960",
+        "Node name for S&R": "VHS_VideoCombine",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "frame_rate": true
+          },
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        },
+        "aux_id": "kosinkadink/ComfyUI-VideoHelperSuite"
+      },
+      "widgets_values": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "minimax-h3/Upscaled_24_fps_video_",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 12,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": true,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "Upscaled_24_fps_video__00006-audio.mp4",
+            "subfolder": "minimax-h3",
+            "type": "output",
+            "format": "video/h264-mp4",
+            "frame_rate": 48,
+            "workflow": "Upscaled_24_fps_video__00006.png",
+            "fullpath": "/home/bryan/Documents/ComfyUI/ComfyUI/output/minimax-h3/Upscaled_24_fps_video__00006-audio.mp4"
+          },
+          "muted": false
+        }
+      },
+      "widgets_values_named": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "minimax-h3/Upscaled_24_fps_video_",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 12,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": true,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "Upscaled_24_fps_video__00006-audio.mp4",
+            "subfolder": "minimax-h3",
+            "type": "output",
+            "format": "video/h264-mp4",
+            "frame_rate": 48,
+            "workflow": "Upscaled_24_fps_video__00006.png",
+            "fullpath": "/home/bryan/Documents/ComfyUI/ComfyUI/output/minimax-h3/Upscaled_24_fps_video__00006-audio.mp4"
+          },
+          "muted": false
+        }
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 14,
+      "type": "GetNode",
+      "pos": [
+        4024.055823306182,
+        5553.142281680486
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "*",
+          "type": "*",
+          "links": []
+        }
+      ],
+      "title": "Get_src_audio",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "src_audio"
+      ],
+      "widgets_values_named": {
+        "Constant": "src_audio"
+      }
+    },
+    {
+      "id": 15,
+      "type": "LoadH3BundleBatch",
+      "pos": [
+        3663.0697659653974,
+        6211.159206074967
+      ],
+      "size": [
+        329.2798828125,
+        230
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "index",
+          "type": "INT",
+          "widget": {
+            "name": "index"
+          },
+          "link": 38
+        }
+      ],
+      "outputs": [
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "links": [
+            18,
+            29
+          ]
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "links": [
+            19
+          ]
+        },
+        {
+          "name": "filename_prefix",
+          "type": "STRING",
+          "links": null
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            17
+          ]
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            16
+          ]
+        },
+        {
+          "name": "remaining",
+          "type": "INT",
+          "links": [
+            15
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadH3BundleBatch",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "h3_bundles/",
+        "index",
+        0,
+        false
+      ],
+      "widgets_values_named": {
+        "bundles_dir": "h3_bundles/",
+        "mode": "index",
+        "index": 0,
+        "output_subdir": false
+      }
+    },
+    {
+      "id": 17,
+      "type": "easy showAnything",
+      "pos": [
+        4021.6464033959273,
+        6558.944584421644
+      ],
+      "size": [
+        210,
+        88
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "anything",
+          "shape": 7,
+          "type": "*",
+          "link": 15
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-easy-use",
+        "ver": "1.3.6",
+        "Node name for S&R": "easy showAnything",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "0"
+      ],
+      "widgets_values_named": {
+        "text": "0"
+      }
+    },
+    {
+      "id": 18,
+      "type": "easy showAnything",
+      "pos": [
+        4286.225331937098,
+        6495.741734554551
+      ],
+      "size": [
+        210,
+        88
+      ],
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "anything",
+          "shape": 7,
+          "type": "*",
+          "link": 16
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-easy-use",
+        "ver": "1.3.6",
+        "Node name for S&R": "easy showAnything",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "416"
+      ],
+      "widgets_values_named": {
+        "text": "416"
+      }
+    },
+    {
+      "id": 19,
+      "type": "easy showAnything",
+      "pos": [
+        4020.4387216756945,
+        6286.107615783938
+      ],
+      "size": [
+        210,
+        88
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "anything",
+          "shape": 7,
+          "type": "*",
+          "link": 17
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-easy-use",
+        "ver": "1.3.6",
+        "Node name for S&R": "easy showAnything",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "256"
+      ],
+      "widgets_values_named": {
+        "text": "256"
+      }
+    },
+    {
+      "id": 26,
+      "type": "deb3547e-1d90-4a4b-8f05-6e17727281b0",
+      "pos": [
+        3080.3347470774556,
+        5784.654012641178
+      ],
+      "size": [
+        530.5983197868572,
+        237.79108895109584
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            28
+          ]
+        },
+        {
+          "label": "Vae_Audio",
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            32
+          ]
+        },
+        {
+          "label": "VAE_Video",
+          "name": "VAE_1",
+          "type": "VAE",
+          "links": [
+            33
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.34.5",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        },
+        "previewExposures": []
+      }
+    },
+    {
+      "id": 27,
+      "type": "SetNode",
+      "pos": [
+        3863.182966811336,
+        5730.639268000472
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "link": 28
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": []
+        }
+      ],
+      "title": "Set_model_VDN",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "model_VDN",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "model_VDN"
+      ],
+      "widgets_values_named": {
+        "Constant": "model_VDN"
+      },
+      "color": "#1f1f48",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 28,
+      "type": "VAEDecodeAudio",
+      "pos": [
+        5610.404818473734,
+        5931.430221895427
+      ],
+      "size": [
+        164.2388671875,
+        46
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 29
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 34
+        }
+      ],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": [
+            37
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.34.5",
+        "Node name for S&R": "VAEDecodeAudio",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      }
+    },
+    {
+      "id": 32,
+      "type": "SetNode",
+      "pos": [
+        3666.164256167578,
+        5819.700639749696
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "link": 32
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": null
+        }
+      ],
+      "title": "Set_vae_audio",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "vae_audio",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "vae_audio"
+      ],
+      "widgets_values_named": {
+        "Constant": "vae_audio"
+      },
+      "color": "#af3535",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 33,
+      "type": "SetNode",
+      "pos": [
+        3629.1238607063815,
+        5971.820043351726
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "link": 33
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": null
+        }
+      ],
+      "title": "Set_vae_video",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "vae_video",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "vae_video"
+      ],
+      "widgets_values_named": {
+        "Constant": "vae_video"
+      },
+      "color": "#af3535",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 34,
+      "type": "GetNode",
+      "pos": [
+        5349.028602450984,
+        5868.56737955779
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            34
+          ]
+        }
+      ],
+      "title": "Get_vae_audio",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "vae_audio"
+      ],
+      "widgets_values_named": {
+        "Constant": "vae_audio"
+      },
+      "color": "#af3535",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 36,
+      "type": "PrimitiveInt",
+      "pos": [
+        3288.91510592369,
+        6382.083130778668
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            38
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.34.5",
+        "Node name for S&R": "PrimitiveInt",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        2,
+        "increment"
+      ],
+      "widgets_values_named": {
+        "value": 2,
+        "fixed": "increment"
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      2,
+      0,
+      5,
+      0,
+      "MODEL"
+    ],
+    [
+      3,
+      2,
+      0,
+      7,
+      0,
+      "MODEL"
+    ],
+    [
+      4,
+      6,
+      0,
+      8,
+      0,
+      "NOISE"
+    ],
+    [
+      5,
+      5,
+      0,
+      8,
+      1,
+      "GUIDER"
+    ],
+    [
+      6,
+      4,
+      0,
+      8,
+      2,
+      "SAMPLER"
+    ],
+    [
+      7,
+      7,
+      0,
+      8,
+      3,
+      "SIGMAS"
+    ],
+    [
+      9,
+      8,
+      0,
+      10,
+      0,
+      "LATENT"
+    ],
+    [
+      10,
+      9,
+      0,
+      10,
+      1,
+      "VAE"
+    ],
+    [
+      11,
+      10,
+      0,
+      12,
+      0,
+      "IMAGE"
+    ],
+    [
+      12,
+      12,
+      0,
+      13,
+      0,
+      "IMAGE"
+    ],
+    [
+      14,
+      11,
+      1,
+      13,
+      4,
+      "FLOAT"
+    ],
+    [
+      15,
+      15,
+      5,
+      17,
+      0,
+      "INT"
+    ],
+    [
+      16,
+      15,
+      4,
+      18,
+      0,
+      "INT"
+    ],
+    [
+      17,
+      15,
+      3,
+      19,
+      0,
+      "INT"
+    ],
+    [
+      18,
+      15,
+      0,
+      1,
+      0,
+      "LATENT"
+    ],
+    [
+      19,
+      15,
+      1,
+      5,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      28,
+      26,
+      0,
+      27,
+      0,
+      "MODEL"
+    ],
+    [
+      29,
+      15,
+      0,
+      28,
+      0,
+      "LATENT"
+    ],
+    [
+      32,
+      26,
+      1,
+      32,
+      0,
+      "VAE"
+    ],
+    [
+      33,
+      26,
+      2,
+      33,
+      0,
+      "VAE"
+    ],
+    [
+      34,
+      34,
+      0,
+      28,
+      1,
+      "VAE"
+    ],
+    [
+      35,
+      11,
+      1,
+      12,
+      1,
+      "FLOAT"
+    ],
+    [
+      36,
+      1,
+      0,
+      8,
+      4,
+      "LATENT"
+    ],
+    [
+      37,
+      28,
+      0,
+      13,
+      1,
+      "AUDIO"
+    ],
+    [
+      38,
+      36,
+      0,
+      15,
+      0,
+      "INT"
+    ]
+  ],
+  "groups": [],
+  "definitions": {
+    "subgraphs": [
+      {
+        "id": "deb3547e-1d90-4a4b-8f05-6e17727281b0",
+        "version": 1,
+        "state": {
+          "lastGroupId": 0,
+          "lastNodeId": 36,
+          "lastLinkId": 38,
+          "lastRerouteId": 0
+        },
+        "revision": 0,
+        "config": {},
+        "name": "Model_VDN_Loading",
+        "inputNode": {
+          "id": -10,
+          "bounding": [
+            1512.2050049277864,
+            6045.092780484874,
+            128,
+            48
+          ]
+        },
+        "outputNode": {
+          "id": -20,
+          "bounding": [
+            3719.5565366738974,
+            6045.092780484874,
+            128,
+            108
+          ]
+        },
+        "inputs": [],
+        "outputs": [
+          {
+            "id": "d6df7459-c732-4567-9bed-8e37206efabe",
+            "name": "MODEL",
+            "type": "MODEL",
+            "linkIds": [
+              27
+            ],
+            "pos": [
+              3743.5565366738974,
+              6069.092780484874
+            ]
+          },
+          {
+            "id": "0493d6cb-919f-44db-b324-35c212134764",
+            "name": "VAE",
+            "type": "VAE",
+            "linkIds": [
+              30
+            ],
+            "pos": [
+              3743.5565366738974,
+              6089.092780484874
+            ]
+          },
+          {
+            "id": "cb29645c-2136-4a21-9ddd-04a64e2b232c",
+            "name": "VAE_1",
+            "type": "VAE",
+            "linkIds": [
+              31
+            ],
+            "pos": [
+              3743.5565366738974,
+              6109.092780484874
+            ]
+          }
+        ],
+        "widgets": [],
+        "nodes": [
+          {
+            "id": 23,
+            "type": "UNETLoader",
+            "pos": [
+              1700.2050049277864,
+              6377.496467251863
+            ],
+            "size": [
+              648.390625,
+              113.859375
+            ],
+            "flags": {},
+            "order": 0,
+            "mode": 0,
+            "inputs": [],
+            "outputs": [
+              {
+                "localized_name": "MODEL",
+                "name": "MODEL",
+                "type": "MODEL",
+                "links": [
+                  25
+                ]
+              }
+            ],
+            "properties": {
+              "cnr_id": "comfy-core",
+              "ver": "0.29.0",
+              "Node name for S&R": "UNETLoader",
+              "ue_properties": {
+                "widget_ue_connectable": {},
+                "version": "7.5.1",
+                "input_ue_unconnectable": {}
+              },
+              "models": [
+                {
+                  "name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+                  "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+                  "directory": "diffusion_models"
+                }
+              ]
+            },
+            "widgets_values": [
+              "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+              "default"
+            ],
+            "widgets_values_named": {
+              "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+              "weight_dtype": "default"
+            },
+            "ndSuperSelectorEnabled": false,
+            "ndPowerEnabled": false
+          },
+          {
+            "id": 22,
+            "type": "ApplyVDNH3Advanced",
+            "pos": [
+              2431.818086194477,
+              5762.34511632811
+            ],
+            "size": [
+              442.609375,
+              477.453125
+            ],
+            "flags": {},
+            "order": 3,
+            "mode": 0,
+            "inputs": [
+              {
+                "localized_name": "model",
+                "name": "model",
+                "type": "MODEL",
+                "link": 25
+              }
+            ],
+            "outputs": [
+              {
+                "localized_name": "MODEL",
+                "name": "MODEL",
+                "type": "MODEL",
+                "links": [
+                  20
+                ]
+              }
+            ],
+            "properties": {
+              "cnr_id": "comfyui-vdn-h3",
+              "ver": "183f33d8a7b3c6322d83be95ae369251a63b3198",
+              "Node name for S&R": "ApplyVDNH3Advanced",
+              "ue_properties": {
+                "widget_ue_connectable": {},
+                "version": "7.5.1",
+                "input_ue_unconnectable": {}
+              },
+              "aux_id": "Saganaki22/ComfyUI-VDN-H3"
+            },
+            "widgets_values": [
+              "stage-dmd-step-250",
+              true,
+              1,
+              1,
+              "merge",
+              "stream",
+              "off",
+              "grouped",
+              "grouped",
+              1,
+              5,
+              "both",
+              true,
+              true,
+              false
+            ],
+            "widgets_values_named": {
+              "vdn_checkpoint": "stage-dmd-step-250",
+              "apply_turbo_adapter": true,
+              "stage_b_strength": 1,
+              "turbo_strength": 1,
+              "lora_mode": "merge",
+              "branch_weights": "stream",
+              "retain_buffers": "off",
+              "verbose": "grouped",
+              "attention_backend": "grouped",
+              "window_radius": 1,
+              "window_chunk": 5,
+              "anchor_frames": "both",
+              "text_state": true,
+              "linear_branch": true,
+              "fast_kernels": false
+            }
+          },
+          {
+            "id": 20,
+            "type": "MiniMaxChunkFeedForward",
+            "pos": [
+              2980.6390337676967,
+              5875.486515660144
+            ],
+            "size": [
+              324.1875,
+              113.859375
+            ],
+            "flags": {},
+            "order": 4,
+            "mode": 0,
+            "inputs": [
+              {
+                "localized_name": "model",
+                "name": "model",
+                "type": "MODEL",
+                "link": 20
+              }
+            ],
+            "outputs": [
+              {
+                "localized_name": "model",
+                "name": "model",
+                "type": "MODEL",
+                "links": [
+                  21
+                ]
+              }
+            ],
+            "properties": {
+              "cnr_id": "comfyui-kjnodes",
+              "ver": "1.5.0",
+              "Node name for S&R": "MiniMaxChunkFeedForward",
+              "ue_properties": {
+                "widget_ue_connectable": {},
+                "input_ue_unconnectable": {},
+                "version": "7.8"
+              }
+            },
+            "widgets_values": [
+              2,
+              4096
+            ],
+            "widgets_values_named": {
+              "chunks": 2,
+              "seq_threshold": 4096
+            }
+          },
+          {
+            "id": 21,
+            "type": "ModelPatchTorchSettings",
+            "pos": [
+              3343.6918658984664,
+              5891.365402174691
+            ],
+            "size": [
+              312.078125,
+              85.890625
+            ],
+            "flags": {
+              "collapsed": false
+            },
+            "order": 5,
+            "mode": 0,
+            "inputs": [
+              {
+                "localized_name": "model",
+                "name": "model",
+                "type": "MODEL",
+                "link": 21
+              }
+            ],
+            "outputs": [
+              {
+                "localized_name": "MODEL",
+                "name": "MODEL",
+                "type": "MODEL",
+                "links": [
+                  27
+                ]
+              }
+            ],
+            "properties": {
+              "cnr_id": "comfyui-kjnodes",
+              "ver": "e8e88f7c88e3f6205b122f5de87e69a09fbce5ac",
+              "Node name for S&R": "ModelPatchTorchSettings",
+              "ue_properties": {
+                "widget_ue_connectable": {},
+                "version": "7.5.1",
+                "input_ue_unconnectable": {}
+              }
+            },
+            "widgets_values": [
+              true
+            ],
+            "widgets_values_named": {
+              "enable_fp16_accumulation": true
+            }
+          },
+          {
+            "id": 29,
+            "type": "VAELoader",
+            "pos": [
+              3359.1089537220587,
+              6062.769321627355
+            ],
+            "size": [
+              270,
+              58
+            ],
+            "flags": {},
+            "order": 1,
+            "mode": 0,
+            "inputs": [],
+            "outputs": [
+              {
+                "label": "Vae_Audio",
+                "localized_name": "VAE",
+                "name": "VAE",
+                "type": "VAE",
+                "links": [
+                  30
+                ]
+              }
+            ],
+            "properties": {
+              "cnr_id": "comfy-core",
+              "ver": "0.34.5",
+              "Node name for S&R": "VAELoader",
+              "ue_properties": {
+                "widget_ue_connectable": {},
+                "input_ue_unconnectable": {},
+                "version": "7.5.1"
+              }
+            },
+            "widgets_values": [
+              "minimax_h3_audio_vae_fp32.safetensors"
+            ],
+            "widgets_values_named": {
+              "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+            },
+            "ndSuperSelectorEnabled": false,
+            "ndPowerEnabled": false
+          },
+          {
+            "id": 31,
+            "type": "VAELoader",
+            "pos": [
+              3362.8387747424795,
+              6184.03950060693
+            ],
+            "size": [
+              270,
+              58
+            ],
+            "flags": {},
+            "order": 2,
+            "mode": 0,
+            "inputs": [],
+            "outputs": [
+              {
+                "label": "VAE_Video",
+                "localized_name": "VAE",
+                "name": "VAE",
+                "type": "VAE",
+                "links": [
+                  31
+                ]
+              }
+            ],
+            "properties": {
+              "cnr_id": "comfy-core",
+              "ver": "0.34.5",
+              "Node name for S&R": "VAELoader",
+              "ue_properties": {
+                "widget_ue_connectable": {},
+                "input_ue_unconnectable": {},
+                "version": "7.5.1"
+              }
+            },
+            "widgets_values": [
+              "minimax_h3_video_vae_int8_convrot.safetensors"
+            ],
+            "widgets_values_named": {
+              "vae_name": "minimax_h3_video_vae_int8_convrot.safetensors"
+            },
+            "ndSuperSelectorEnabled": false,
+            "ndPowerEnabled": false
+          }
+        ],
+        "groups": [],
+        "links": [
+          {
+            "id": 25,
+            "origin_id": 23,
+            "origin_slot": 0,
+            "target_id": 22,
+            "target_slot": 0,
+            "type": "MODEL"
+          },
+          {
+            "id": 20,
+            "origin_id": 22,
+            "origin_slot": 0,
+            "target_id": 20,
+            "target_slot": 0,
+            "type": "MODEL"
+          },
+          {
+            "id": 21,
+            "origin_id": 20,
+            "origin_slot": 0,
+            "target_id": 21,
+            "target_slot": 0,
+            "type": "MODEL"
+          },
+          {
+            "id": 27,
+            "origin_id": 21,
+            "origin_slot": 0,
+            "target_id": -20,
+            "target_slot": 0,
+            "type": "MODEL"
+          },
+          {
+            "id": 30,
+            "origin_id": 29,
+            "origin_slot": 0,
+            "target_id": -20,
+            "target_slot": 1,
+            "type": "VAE"
+          },
+          {
+            "id": 31,
+            "origin_id": 31,
+            "origin_slot": 0,
+            "target_id": -20,
+            "target_slot": 2,
+            "type": "VAE"
+          }
+        ],
+        "extra": {
+          "ue_links": [],
+          "links_added_by_ue": []
+        }
+      }
+    ]
+  },
+  "config": {},
+  "extra": {
+    "ue_links": [],
+    "ds": {
+      "scale": 0.9277171243279716,
+      "offset": [
+        -2712.6235131313183,
+        -5254.730090894639
+      ]
+    },
+    "links_added_by_ue": [],
+    "frontendVersion": "1.49.6",
+    "VHS_latentpreview": false,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": true,
+    "VHS_KeepIntermediate": true
+  },
+  "version": 0.4
+}

workflow/Minimax_Timeline.json

@@ -0,0 +1,3192 @@
+{
+  "id": "42476cc0-ba47-4042-ad72-3802b573afb3",
+  "revision": 0,
+  "last_node_id": 220,
+  "last_link_id": 393,
+  "nodes": [
+    {
+      "id": 92,
+      "type": "SaveVideo",
+      "pos": [
+        1275.5521965719986,
+        4499.325535955995
+      ],
+      "size": [
+        612.3666583336471,
+        1093.0958197921766
+      ],
+      "flags": {},
+      "order": 43,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 260
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "SaveVideo",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "video/MiniMax_H3",
+        "auto",
+        "auto",
+        "auto"
+      ],
+      "widgets_values_named": {
+        "filename_prefix": "video/MiniMax_H3",
+        "format": "auto",
+        "format.codec": "auto",
+        "codec": "auto"
+      }
+    },
+    {
+      "id": 115,
+      "type": "ResolutionSelector",
+      "pos": [
+        -862.4467856615897,
+        5609.97531007646
+      ],
+      "size": [
+        248.46875,
+        161.828125
+      ],
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "showAdvanced": false,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "width",
+          "type": "INT",
+          "links": [
+            285,
+            349,
+            382
+          ]
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "links": [
+            286,
+            350,
+            383
+          ]
+        }
+      ],
+      "title": "Resolution Selector (Size)",
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "ResolutionSelector",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "9:16 (Portrait Widescreen)",
+        0.1,
+        32
+      ],
+      "widgets_values_named": {
+        "aspect_ratio": "9:16 (Portrait Widescreen)",
+        "megapixels": 0.1,
+        "multiple": 32
+      },
+      "color": "#322",
+      "bgcolor": "#533"
+    },
+    {
+      "id": 116,
+      "type": "MarkdownNote",
+      "pos": [
+        -2033.7082424262605,
+        4829.138252930259
+      ],
+      "size": [
+        450,
+        860.71875
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Note: MiniMax H3",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "## MiniMax H3\n\n[MiniMax H3](https://www.minimax.io/blog/minimax-h3) is MiniMax's general-purpose, omni-modal generation model. It jointly understands text, image, video, and audio, and generates video with **native stereo audio**: voice, sound effects, and music are modeled jointly in a single forward pass, not layered on afterward. Output is up to 2K resolution, 24fps, and up to about 15 seconds.\n\nH3 removes the usual task boundaries between generation modes. Text-to-video, image-to-video, first/last-frame control, and reference-driven generation (character, motion, camera, voice, style) are all handled by one model instead of separate expert pipelines.\n\n## About this workflow\n\nThis template runs the **reference-to-video (ref2va)** task using the `MiniMaxH3ReferenceToVideo` node. It takes any mix of reference images, videos, and standalone audio, and weaves them into the generation to lock in a character's identity, a style, a motion, a camera move, or a voice.\n\n**Key inputs**\n\n- **ref_images / ref_videos / ref_video_audios / ref_audios**: up to 9 reference images, 3 reference videos (each may carry its own paired soundtrack), and 3 standalone reference audio clips\n- **prompt**: reference the inputs by tag, in the exact order they were connected, for example `<Picture 1>`, `<Video 1>`, `<Audio 1>`, then describe the target scene, motion, and audio\n- **ref_image_size**: `match` scales references down to the generation's resolution (faster); `max` keeps up to a 2048px short edge for stronger identity fidelity, at the cost of speed since reference tokens ride along every sampling step\n- **width / height**: set via Resolution Selector. H3's native canvas is a 768px short edge, capped at 768x1344 pixels, rounded to a multiple of 32\n- **duration (seconds)**: converted to a valid frame `length` by the Math Expression node, snapping up to the model's 17-frame-per-block (17k+5) grid at 24fps\n\n**Sampling and decode**\n\n- Sampler: `res_multistep`. `beta` or `normal` scheduler tends to outperform `simple` for reference-heavy prompts like this one\n- The sampler's joint audio+video `LATENT` output feeds directly into both `VAEDecode` (video, `minimax_h3_video_vae_fp16`) and `VAEDecodeAudio` (audio, `minimax_h3_audio_vae_fp32`); each decode node automatically pulls its own half out of the packed latent. `CreateVideo` then muxes the two into a single MP4 with synced sound\n- The diffusion model here is `minimax_h3_ref2va_pruned_int8_convrot.safetensors`, a different set of weights from the `fl2va` model used by the t2v/i2v templates\n\nRef2va's output is very sensitive to prompt wording; matching the reference tags precisely and being explicit about which reference drives which part of the shot tends to work best."
+      ],
+      "widgets_values_named": {
+        "text": "## MiniMax H3\n\n[MiniMax H3](https://www.minimax.io/blog/minimax-h3) is MiniMax's general-purpose, omni-modal generation model. It jointly understands text, image, video, and audio, and generates video with **native stereo audio**: voice, sound effects, and music are modeled jointly in a single forward pass, not layered on afterward. Output is up to 2K resolution, 24fps, and up to about 15 seconds.\n\nH3 removes the usual task boundaries between generation modes. Text-to-video, image-to-video, first/last-frame control, and reference-driven generation (character, motion, camera, voice, style) are all handled by one model instead of separate expert pipelines.\n\n## About this workflow\n\nThis template runs the **reference-to-video (ref2va)** task using the `MiniMaxH3ReferenceToVideo` node. It takes any mix of reference images, videos, and standalone audio, and weaves them into the generation to lock in a character's identity, a style, a motion, a camera move, or a voice.\n\n**Key inputs**\n\n- **ref_images / ref_videos / ref_video_audios / ref_audios**: up to 9 reference images, 3 reference videos (each may carry its own paired soundtrack), and 3 standalone reference audio clips\n- **prompt**: reference the inputs by tag, in the exact order they were connected, for example `<Picture 1>`, `<Video 1>`, `<Audio 1>`, then describe the target scene, motion, and audio\n- **ref_image_size**: `match` scales references down to the generation's resolution (faster); `max` keeps up to a 2048px short edge for stronger identity fidelity, at the cost of speed since reference tokens ride along every sampling step\n- **width / height**: set via Resolution Selector. H3's native canvas is a 768px short edge, capped at 768x1344 pixels, rounded to a multiple of 32\n- **duration (seconds)**: converted to a valid frame `length` by the Math Expression node, snapping up to the model's 17-frame-per-block (17k+5) grid at 24fps\n\n**Sampling and decode**\n\n- Sampler: `res_multistep`. `beta` or `normal` scheduler tends to outperform `simple` for reference-heavy prompts like this one\n- The sampler's joint audio+video `LATENT` output feeds directly into both `VAEDecode` (video, `minimax_h3_video_vae_fp16`) and `VAEDecodeAudio` (audio, `minimax_h3_audio_vae_fp32`); each decode node automatically pulls its own half out of the packed latent. `CreateVideo` then muxes the two into a single MP4 with synced sound\n- The diffusion model here is `minimax_h3_ref2va_pruned_int8_convrot.safetensors`, a different set of weights from the `fl2va` model used by the t2v/i2v templates\n\nRef2va's output is very sensitive to prompt wording; matching the reference tags precisely and being explicit about which reference drives which part of the shot tends to work best."
+      },
+      "color": "#222",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 117,
+      "type": "MarkdownNote",
+      "pos": [
+        -2500,
+        4850
+      ],
+      "size": [
+        440,
+        740
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "title": "Note: Model Links",
+      "properties": {
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "## Model Links\n\n**vae**\n\n- [minimax_h3_video_vae_fp16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors)\n- [minimax_h3_audio_vae_fp32.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors)\n\n**diffusion_models**\n\n- [minimax_h3_ref2va_pruned_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors)\n\n**text_encoders**\n\n- [qwen3vl_32b_minimax_h3_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_int8_convrot.safetensors)\n\n\n## Model Storage Location\n\n```\n📂 ComfyUI/\n├── 📂 models/\n│   ├── 📂 vae/\n│   │   ├── minimax_h3_video_vae_fp16.safetensors\n│   │   └── minimax_h3_audio_vae_fp32.safetensors\n│   ├── 📂 diffusion_models/\n│   │   └── minimax_h3_ref2va_pruned_int8_convrot.safetensors\n│   └── 📂 text_encoders/\n│       └── qwen3vl_32b_minimax_h3_int8_convrot.safetensors\n```\n\n## Report Issue\n\nNote: Please update ComfyUI first ([guide](https://docs.comfy.org/installation/update_comfyui)) and prepare required models. Desktop/Cloud updates follow stable releases, so some nightly-supported models may not be available yet.\n\n- Cannot run / runtime errors: [ComfyUI/issues](https://github.com/comfyanonymous/ComfyUI/issues)\n- UI / frontend issues: [ComfyUI_frontend/issues](https://github.com/Comfy-Org/ComfyUI_frontend/issues)\n- Workflow issues: [workflow_templates/issues](https://github.com/Comfy-Org/workflow_templates/issues)\n"
+      ],
+      "widgets_values_named": {
+        "text": "## Model Links\n\n**vae**\n\n- [minimax_h3_video_vae_fp16.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors)\n- [minimax_h3_audio_vae_fp32.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors)\n\n**diffusion_models**\n\n- [minimax_h3_ref2va_pruned_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors)\n\n**text_encoders**\n\n- [qwen3vl_32b_minimax_h3_int8_convrot.safetensors](https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_int8_convrot.safetensors)\n\n\n## Model Storage Location\n\n```\n📂 ComfyUI/\n├── 📂 models/\n│   ├── 📂 vae/\n│   │   ├── minimax_h3_video_vae_fp16.safetensors\n│   │   └── minimax_h3_audio_vae_fp32.safetensors\n│   ├── 📂 diffusion_models/\n│   │   └── minimax_h3_ref2va_pruned_int8_convrot.safetensors\n│   └── 📂 text_encoders/\n│       └── qwen3vl_32b_minimax_h3_int8_convrot.safetensors\n```\n\n## Report Issue\n\nNote: Please update ComfyUI first ([guide](https://docs.comfy.org/installation/update_comfyui)) and prepare required models. Desktop/Cloud updates follow stable releases, so some nightly-supported models may not be available yet.\n\n- Cannot run / runtime errors: [ComfyUI/issues](https://github.com/comfyanonymous/ComfyUI/issues)\n- UI / frontend issues: [ComfyUI_frontend/issues](https://github.com/Comfy-Org/ComfyUI_frontend/issues)\n- Workflow issues: [workflow_templates/issues](https://github.com/Comfy-Org/workflow_templates/issues)\n"
+      },
+      "color": "#222",
+      "bgcolor": "#000"
+    },
+    {
+      "id": 119,
+      "type": "VAELoader",
+      "pos": [
+        -1494.30411371666,
+        5272.8694091444395
+      ],
+      "size": [
+        640,
+        85.890625
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            251,
+            347
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "VAELoader",
+        "models": [
+          {
+            "name": "minimax_h3_video_vae_fp16.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_video_vae_fp16.safetensors",
+            "directory": "vae"
+          }
+        ],
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "minimax_h3_video_vae_int8_convrot.safetensors"
+      ],
+      "widgets_values_named": {
+        "vae_name": "minimax_h3_video_vae_int8_convrot.safetensors"
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 120,
+      "type": "VAELoader",
+      "pos": [
+        -1502.0675653264077,
+        5390.29777908046
+      ],
+      "size": [
+        650,
+        85.890625
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            250,
+            348
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "VAELoader",
+        "models": [
+          {
+            "name": "minimax_h3_audio_vae_fp32.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/vae/minimax_h3_audio_vae_fp32.safetensors",
+            "directory": "vae"
+          }
+        ],
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "minimax_h3_audio_vae_fp32.safetensors"
+      ],
+      "widgets_values_named": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 121,
+      "type": "VAEDecodeAudio",
+      "pos": [
+        914.7436379821778,
+        5253.488956759807
+      ],
+      "size": [
+        230,
+        77.921875
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 38,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 281
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 250
+        }
+      ],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": [
+            328,
+            373
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "VAEDecodeAudio",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 122,
+      "type": "VAEDecode",
+      "pos": [
+        916.1098723933795,
+        5097.97485199241
+      ],
+      "size": [
+        230,
+        77.921875
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 37,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 280
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 251
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            258
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 124,
+      "type": "BasicScheduler",
+      "pos": [
+        160.77997741238457,
+        5312.837864849799
+      ],
+      "size": [
+        348.90625,
+        149.625
+      ],
+      "flags": {},
+      "order": 34,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 358
+        }
+      ],
+      "outputs": [
+        {
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            256
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "BasicScheduler",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "simple",
+        8,
+        1
+      ],
+      "widgets_values_named": {
+        "scheduler": "simple",
+        "steps": 8,
+        "denoise": 1
+      }
+    },
+    {
+      "id": 125,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        556.8556745238828,
+        4933.173657183853
+      ],
+      "size": [
+        252.546875,
+        389.84375
+      ],
+      "flags": {},
+      "order": 36,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 253
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 254
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 341
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 256
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 345
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": [
+            280,
+            281,
+            378,
+            391
+          ]
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": []
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "SamplerCustomAdvanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 126,
+      "type": "BasicGuider",
+      "pos": [
+        156.29100926618642,
+        5074.271224643126
+      ],
+      "size": [
+        360,
+        77.921875
+      ],
+      "flags": {},
+      "order": 33,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 357
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 344
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            254
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "BasicGuider",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 127,
+      "type": "UNETLoader",
+      "pos": [
+        -1503.0984969025762,
+        4941.480443405995
+      ],
+      "size": [
+        648.390625,
+        113.859375
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            332
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "UNETLoader",
+        "models": [
+          {
+            "name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+            "directory": "diffusion_models"
+          }
+        ],
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "default"
+      ],
+      "widgets_values_named": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 128,
+      "type": "CLIPLoader",
+      "pos": [
+        -1495.9462293764273,
+        5091.377600569795
+      ],
+      "size": [
+        640,
+        141.828125
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            346
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "CLIPLoader",
+        "models": [
+          {
+            "name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/MiniMax-H3/resolve/main/text_encoders/qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+            "directory": "text_encoders"
+          }
+        ],
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "minimax",
+        "default"
+      ],
+      "widgets_values_named": {
+        "clip_name": "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 129,
+      "type": "RandomNoise",
+      "pos": [
+        156.29100926618642,
+        4934.271224643126
+      ],
+      "size": [
+        360,
+        90
+      ],
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise_seed",
+          "type": "INT",
+          "widget": {
+            "name": "noise_seed"
+          },
+          "link": 389
+        }
+      ],
+      "outputs": [
+        {
+          "name": "NOISE",
+          "type": "NOISE",
+          "links": [
+            253
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "RandomNoise",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        4244,
+        "increment"
+      ],
+      "widgets_values_named": {
+        "noise_seed": 4244,
+        "control_after_generate": "increment"
+      }
+    },
+    {
+      "id": 130,
+      "type": "CreateVideo",
+      "pos": [
+        1230.4944002147352,
+        4911.021740537447
+      ],
+      "size": [
+        270,
+        161.828125
+      ],
+      "flags": {},
+      "order": 40,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 258
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 328
+        }
+      ],
+      "outputs": [
+        {
+          "name": "VIDEO",
+          "type": "VIDEO",
+          "links": [
+            260,
+            392
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.29.0",
+        "Node name for S&R": "CreateVideo",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        24,
+        8,
+        "sRGB"
+      ],
+      "widgets_values_named": {
+        "fps": 24,
+        "bit_depth": 8,
+        "color_space": "sRGB"
+      }
+    },
+    {
+      "id": 144,
+      "type": "easy showAnything",
+      "pos": [
+        -1493.8902038554618,
+        5927.232535398474
+      ],
+      "size": [
+        225,
+        125.890625
+      ],
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "anything",
+          "shape": 7,
+          "type": "*",
+          "link": 285
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-easy-use",
+        "ver": "5618a748c14858a6e95a583baa28bb7c8da7976a",
+        "Node name for S&R": "easy showAnything",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "256"
+      ],
+      "widgets_values_named": {
+        "text": "256"
+      }
+    },
+    {
+      "id": 145,
+      "type": "easy showAnything",
+      "pos": [
+        -1245.9659302340724,
+        5936.131811630934
+      ],
+      "size": [
+        225,
+        125.890625
+      ],
+      "flags": {},
+      "order": 25,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "anything",
+          "shape": 7,
+          "type": "*",
+          "link": 286
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-easy-use",
+        "ver": "5618a748c14858a6e95a583baa28bb7c8da7976a",
+        "Node name for S&R": "easy showAnything",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "416"
+      ],
+      "widgets_values_named": {
+        "text": "416"
+      }
+    },
+    {
+      "id": 177,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        -767.5236112457903,
+        4944.179109005764
+      ],
+      "size": [
+        355.203125,
+        113.859375
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 332
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            356
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.0",
+        "Node name for S&R": "LoraLoaderModelOnly",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "minimax_h3_fl2v_lightx2v_turbo_4step_v1.0_768p_resized_avg_rank_31_bf16.safetensors",
+        1
+      ],
+      "widgets_values_named": {
+        "lora_name": "minimax_h3_fl2v_lightx2v_turbo_4step_v1.0_768p_resized_avg_rank_31_bf16.safetensors",
+        "strength_model": 1
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 179,
+      "type": "KSamplerSelect",
+      "pos": [
+        209.49743383365987,
+        5183.705023289966
+      ],
+      "size": [
+        270,
+        85.890625
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "SAMPLER",
+          "type": "SAMPLER",
+          "links": [
+            341
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.33.0",
+        "Node name for S&R": "KSamplerSelect",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "euler"
+      ],
+      "widgets_values_named": {
+        "sampler_name": "euler"
+      }
+    },
+    {
+      "id": 184,
+      "type": "MiniMaxH3TimelinePlanner",
+      "pos": [
+        -527.8950941395228,
+        5708.606113290952
+      ],
+      "size": [
+        1715.078125,
+        804
+      ],
+      "flags": {},
+      "order": 26,
+      "mode": 0,
+      "inputs": [
+        {
+          "label": "Prompt Index",
+          "name": "prompt_index",
+          "shape": 7,
+          "type": "INT",
+          "link": null
+        },
+        {
+          "name": "width",
+          "type": "INT",
+          "widget": {
+            "name": "width"
+          },
+          "link": 349
+        },
+        {
+          "name": "height",
+          "type": "INT",
+          "widget": {
+            "name": "height"
+          },
+          "link": 350
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Material Plan",
+          "type": "MINIMAX_H3_TIMELINE_PLAN",
+          "links": [
+            353
+          ]
+        },
+        {
+          "name": "Omni Media Bundle",
+          "type": "MINIMAX_H3_OMNI_MEDIA_BUNDLE",
+          "links": null
+        }
+      ],
+      "properties": {
+        "aux_id": "Songssx/ComfyUI-MiniMaxH3-TimelineDirector",
+        "ver": "e4d6d5ea44eb00e2414d16dd94883be8e2661213",
+        "Node name for S&R": "MiniMaxH3TimelinePlanner",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "width": true,
+            "height": true
+          },
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        1344,
+        768,
+        10,
+        "{\"version\":4,\"fps\":24,\"selection\":{\"start\":0,\"duration\":10},\"videoAudioEnabled\":true,\"videoClips\":[],\"images\":[{\"id\":\"mtpncdu2-o1oklx\",\"file\":\"minimax_h3_timeline_director/1788689161191_lin01_KreaEdit1__00148_.png\",\"name\":\"KreaEdit1__00148_.png\",\"width\":1088,\"height\":1920},{\"id\":\"mtpncjay-7eso16\",\"file\":\"minimax_h3_timeline_director/1788689168287_mn5mv_KreaEdit1__00147_.png\",\"name\":\"KreaEdit1__00147_.png\",\"width\":1088,\"height\":1920}],\"audios\":[],\"segmentConfig\":{\"count\":2,\"segments\":[{\"images\":[],\"audios\":[]},{\"images\":[],\"audios\":[]}]}}",
+        ""
+      ],
+      "widgets_values_named": {
+        "width": 1344,
+        "height": 768,
+        "generation_seconds": 10,
+        "timeline_data": "{\"version\":4,\"fps\":24,\"selection\":{\"start\":0,\"duration\":10},\"videoAudioEnabled\":true,\"videoClips\":[],\"images\":[{\"id\":\"mtpncdu2-o1oklx\",\"file\":\"minimax_h3_timeline_director/1788689161191_lin01_KreaEdit1__00148_.png\",\"name\":\"KreaEdit1__00148_.png\",\"width\":1088,\"height\":1920},{\"id\":\"mtpncjay-7eso16\",\"file\":\"minimax_h3_timeline_director/1788689168287_mn5mv_KreaEdit1__00147_.png\",\"name\":\"KreaEdit1__00147_.png\",\"width\":1088,\"height\":1920}],\"audios\":[],\"segmentConfig\":{\"count\":2,\"segments\":[{\"images\":[],\"audios\":[]},{\"images\":[],\"audios\":[]}]}}",
+        "minimax_h3_timeline": ""
+      }
+    },
+    {
+      "id": 185,
+      "type": "MiniMaxH3TimelineEncoder",
+      "pos": [
+        1199.243073032633,
+        5684.742013884508
+      ],
+      "size": [
+        620,
+        520
+      ],
+      "flags": {},
+      "order": 29,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 346
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 347
+        },
+        {
+          "name": "audio_vae",
+          "type": "VAE",
+          "link": 348
+        },
+        {
+          "name": "plan",
+          "type": "MINIMAX_H3_TIMELINE_PLAN",
+          "link": 353
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            344,
+            380,
+            381
+          ]
+        },
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            345
+          ]
+        },
+        {
+          "name": "Merged Video Audio",
+          "type": "AUDIO",
+          "links": null
+        },
+        {
+          "name": "Merged Standalone Audio",
+          "type": "AUDIO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "aux_id": "Songssx/ComfyUI-MiniMaxH3-TimelineDirector",
+        "ver": "e4d6d5ea44eb00e2414d16dd94883be8e2661213",
+        "Node name for S&R": "MiniMaxH3TimelineEncoder",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "subject_definitions:\n<Picture 1> and <Picture 2> show the same young woman: long wavy dark brown hair, brown eyes, black lipstick, freckles, black nail polish, large breasts, black triangle bikini top, black string bottoms worn closed, gray sofa, pink-lit wall.\n\nsummary:\nreference generation. Segment 1 of 2, 10 seconds. Live-action cinematic shot of the woman standing in front of the gray sofa, walking toward the lens while stroking her breasts over the bikini. At 00:07.000 a slow dissolve lands on her kneeling. The final 0.917 seconds hold that kneeling pose, both hands on her breasts, string bottoms still closed, for latent handover.\n\nretention_analysis:\nfully_preserved <Picture 1>\nfully_preserved <Picture 2>\n\ndetailed_description:\n[Shot 1] Live-action, cinematic, ultra realistic. The young woman shown in <Picture 1> and <Picture 2> stands in front of the gray sofa against the pink wall, preserving her long wavy dark brown hair, brown eyes, black lipstick, freckles, black nail polish, black triangle bikini top and closed black string bottoms. The camera performs a tracking shot at slow speed at chest level. She walks toward the lens, leans her torso forward, and strokes her breasts over the bikini cups. She blinks once, looks at the camera, then blinks again as her lips part. [Shot 2] At 00:07.000, the shot slow-dissolves to the same woman in the same room now kneeling on the wooden floor facing the lens, knees together, both hands still on her breasts, string bottoms still closed. The camera lowers toward ground level during the dissolve and then holds a slow tracking shot. She blinks slowly, a small smile forms and holds, and her lips stay slightly parted. During 00:09.083-00:10.000 the camera keeps that ground-level tracking shot. She remains kneeling facing the lens, both hands stroking her breasts over the bikini, smile held, one slow blink. No new pose.\n\noverall_soundscape:\nBikini fabric shifts as she walks. Palms rub the cups. Knees meet the floor through the dissolve. Steady breathing and short sighs. During 00:09.083-00:10.000 the same fabric rub, room-floor contact and breathing continue without a new sound event.\n\nnon_diegetic_music:\nN/A\n\n--- SEGMENT ---\n\nsubject_definitions:\nSame woman already established from <Picture 1> and <Picture 2>. No new subject.\n\nsummary:\nvideo continuation + reference generation. Segment 2 of 2, 10 seconds. Opens by repeating the kneeling handover pose for 0.917 seconds, then she places her palms on the floor, goes to all fours, crawls toward the lens at ground level, tilts her head and holds the smile.\n\nretention_analysis:\nfully_preserved <Picture 1>\nfully_preserved <Picture 2>\n\ndetailed_description:\n[Shot 1] Live-action, cinematic, ultra realistic. During 00:00.000-00:00.917 the young woman shown in <Picture 1> and <Picture 2> remains kneeling on the wooden floor in front of the gray sofa against the pink wall, preserving her long wavy dark brown hair, brown eyes, black lipstick, freckles, black nail polish, black triangle bikini top and closed black string bottoms. She faces the lens, both hands on her breasts, smile held, one slow blink. The camera holds the same ground-level tracking shot and the same distance as the end of the previous segment. From 00:00.917, without a cut, she slides her palms down onto the floor, leans her torso forward onto all fours, crawls one slow step toward the lens, blinks, tilts her head a little, and the smile holds. The camera keeps tracking at slow speed at ground level.\n\noverall_soundscape:\nDuring 00:00.000-00:00.917 preceding fabric rub, knee contact and breathing continue. After 00:00.917 palms meet the floor, knees slide, bikini strings shift, steady breathing and short sighs.\n\nnon_diegetic_music:\nN/A",
+        "match"
+      ],
+      "widgets_values_named": {
+        "prompt": "subject_definitions:\n<Picture 1> and <Picture 2> show the same young woman: long wavy dark brown hair, brown eyes, black lipstick, freckles, black nail polish, large breasts, black triangle bikini top, black string bottoms worn closed, gray sofa, pink-lit wall.\n\nsummary:\nreference generation. Segment 1 of 2, 10 seconds. Live-action cinematic shot of the woman standing in front of the gray sofa, walking toward the lens while stroking her breasts over the bikini. At 00:07.000 a slow dissolve lands on her kneeling. The final 0.917 seconds hold that kneeling pose, both hands on her breasts, string bottoms still closed, for latent handover.\n\nretention_analysis:\nfully_preserved <Picture 1>\nfully_preserved <Picture 2>\n\ndetailed_description:\n[Shot 1] Live-action, cinematic, ultra realistic. The young woman shown in <Picture 1> and <Picture 2> stands in front of the gray sofa against the pink wall, preserving her long wavy dark brown hair, brown eyes, black lipstick, freckles, black nail polish, black triangle bikini top and closed black string bottoms. The camera performs a tracking shot at slow speed at chest level. She walks toward the lens, leans her torso forward, and strokes her breasts over the bikini cups. She blinks once, looks at the camera, then blinks again as her lips part. [Shot 2] At 00:07.000, the shot slow-dissolves to the same woman in the same room now kneeling on the wooden floor facing the lens, knees together, both hands still on her breasts, string bottoms still closed. The camera lowers toward ground level during the dissolve and then holds a slow tracking shot. She blinks slowly, a small smile forms and holds, and her lips stay slightly parted. During 00:09.083-00:10.000 the camera keeps that ground-level tracking shot. She remains kneeling facing the lens, both hands stroking her breasts over the bikini, smile held, one slow blink. No new pose.\n\noverall_soundscape:\nBikini fabric shifts as she walks. Palms rub the cups. Knees meet the floor through the dissolve. Steady breathing and short sighs. During 00:09.083-00:10.000 the same fabric rub, room-floor contact and breathing continue without a new sound event.\n\nnon_diegetic_music:\nN/A\n\n--- SEGMENT ---\n\nsubject_definitions:\nSame woman already established from <Picture 1> and <Picture 2>. No new subject.\n\nsummary:\nvideo continuation + reference generation. Segment 2 of 2, 10 seconds. Opens by repeating the kneeling handover pose for 0.917 seconds, then she places her palms on the floor, goes to all fours, crawls toward the lens at ground level, tilts her head and holds the smile.\n\nretention_analysis:\nfully_preserved <Picture 1>\nfully_preserved <Picture 2>\n\ndetailed_description:\n[Shot 1] Live-action, cinematic, ultra realistic. During 00:00.000-00:00.917 the young woman shown in <Picture 1> and <Picture 2> remains kneeling on the wooden floor in front of the gray sofa against the pink wall, preserving her long wavy dark brown hair, brown eyes, black lipstick, freckles, black nail polish, black triangle bikini top and closed black string bottoms. She faces the lens, both hands on her breasts, smile held, one slow blink. The camera holds the same ground-level tracking shot and the same distance as the end of the previous segment. From 00:00.917, without a cut, she slides her palms down onto the floor, leans her torso forward onto all fours, crawls one slow step toward the lens, blinks, tilts her head a little, and the smile holds. The camera keeps tracking at slow speed at ground level.\n\noverall_soundscape:\nDuring 00:00.000-00:00.917 preceding fabric rub, knee contact and breathing continue. After 00:00.917 palms meet the floor, knees slide, bikini strings shift, steady breathing and short sighs.\n\nnon_diegetic_music:\nN/A",
+        "ref_image_size": "match"
+      }
+    },
+    {
+      "id": 186,
+      "type": "ModelPatchTorchSettings",
+      "pos": [
+        144.17490984353213,
+        4440.202848550011
+      ],
+      "size": [
+        312.078125,
+        85.890625
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 32,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 354
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            357,
+            358,
+            379
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "e8e88f7c88e3f6205b122f5de87e69a09fbce5ac",
+        "Node name for S&R": "ModelPatchTorchSettings",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        true
+      ],
+      "widgets_values_named": {
+        "enable_fp16_accumulation": true
+      }
+    },
+    {
+      "id": 187,
+      "type": "MiniMaxChunkFeedForward",
+      "pos": [
+        -222.66446806266873,
+        4439.470491814276
+      ],
+      "size": [
+        324.1875,
+        113.859375
+      ],
+      "flags": {},
+      "order": 30,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 355
+        }
+      ],
+      "outputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "links": [
+            354
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-kjnodes",
+        "ver": "1.5.0",
+        "Node name for S&R": "MiniMaxChunkFeedForward",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.8"
+        }
+      },
+      "widgets_values": [
+        2,
+        4096
+      ],
+      "widgets_values_named": {
+        "chunks": 2,
+        "seq_threshold": 4096
+      }
+    },
+    {
+      "id": 188,
+      "type": "ApplyVDNH3Advanced",
+      "pos": [
+        -771.4854156358887,
+        4326.329092482242
+      ],
+      "size": [
+        442.609375,
+        477.453125
+      ],
+      "flags": {},
+      "order": 28,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 356
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            355
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-vdn-h3",
+        "ver": "183f33d8a7b3c6322d83be95ae369251a63b3198",
+        "Node name for S&R": "ApplyVDNH3Advanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        },
+        "aux_id": "Saganaki22/ComfyUI-VDN-H3"
+      },
+      "widgets_values": [
+        "stage-dmd-step-250",
+        true,
+        1,
+        1,
+        "merge",
+        "stream",
+        "off",
+        "grouped",
+        "grouped",
+        1,
+        5,
+        "both",
+        true,
+        true,
+        false
+      ],
+      "widgets_values_named": {
+        "vdn_checkpoint": "stage-dmd-step-250",
+        "apply_turbo_adapter": true,
+        "stage_b_strength": 1,
+        "turbo_strength": 1,
+        "lora_mode": "merge",
+        "branch_weights": "stream",
+        "retain_buffers": "off",
+        "verbose": "grouped",
+        "attention_backend": "grouped",
+        "window_radius": 1,
+        "window_chunk": 5,
+        "anchor_frames": "both",
+        "text_state": true,
+        "linear_branch": true,
+        "fast_kernels": false
+      }
+    },
+    {
+      "id": 190,
+      "type": "GetNode",
+      "pos": [
+        3019.596094983624,
+        5877.152914338328
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            359,
+            361
+          ]
+        }
+      ],
+      "title": "Get_model_VDN",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "model_VDN"
+      ],
+      "widgets_values_named": {
+        "Constant": "model_VDN"
+      },
+      "color": "#1f1f48",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 191,
+      "type": "GetNode",
+      "pos": [
+        3023.5065112803254,
+        5739.272025023764
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            360
+          ]
+        }
+      ],
+      "title": "Get_conditionning",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "conditionning"
+      ],
+      "widgets_values_named": {
+        "Constant": "conditionning"
+      },
+      "color": "#38291f",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 192,
+      "type": "MinimaxH3LatentUpscaler3D",
+      "pos": [
+        2686.2283581149145,
+        5440.843936505823
+      ],
+      "size": [
+        461.3766842951726,
+        226
+      ],
+      "flags": {},
+      "order": 39,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "link": 378
+        }
+      ],
+      "outputs": [
+        {
+          "name": "latent",
+          "type": "*",
+          "links": [
+            372
+          ]
+        }
+      ],
+      "properties": {
+        "aux_id": "LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler",
+        "ver": "d7c01b9011f2e8439493f6c02c29995a27df276f",
+        "Node name for S&R": "MinimaxH3LatentUpscaler3D",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "minimax_h3_latent_upscaler_3d_bf16.safetensors",
+        "scale by multiplier",
+        1,
+        32,
+        true,
+        true,
+        "cuda",
+        "fp16"
+      ],
+      "widgets_values_named": {
+        "model_name": "minimax_h3_latent_upscaler_3d_bf16.safetensors",
+        "mode": "scale by multiplier",
+        "mode.scale": 1,
+        "align": 32,
+        "enable_temporal_chunking": true,
+        "force_unload": true,
+        "device": "cuda",
+        "precision": "fp16"
+      }
+    },
+    {
+      "id": 193,
+      "type": "GetNode",
+      "pos": [
+        2854.118097030728,
+        5077.572385741342
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": [
+            370
+          ]
+        }
+      ],
+      "title": "Get_src_audio",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "src_audio"
+      ],
+      "widgets_values_named": {
+        "Constant": "src_audio"
+      }
+    },
+    {
+      "id": 194,
+      "type": "KSamplerSelect",
+      "pos": [
+        3370.9292369257732,
+        5730.988525701965
+      ],
+      "size": [
+        361.19999999999993,
+        66.19999999999982
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "SAMPLER",
+          "type": "SAMPLER",
+          "links": [
+            364
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "KSamplerSelect",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "euler"
+      ],
+      "widgets_values_named": {
+        "sampler_name": "euler"
+      }
+    },
+    {
+      "id": 195,
+      "type": "BasicGuider",
+      "pos": [
+        3370.9292369257732,
+        5623.188525701965
+      ],
+      "size": [
+        360,
+        60
+      ],
+      "flags": {},
+      "order": 21,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 359
+        },
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 360
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            363
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "BasicGuider",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 196,
+      "type": "RandomNoise",
+      "pos": [
+        3370.9292369257732,
+        5472.188525701962
+      ],
+      "size": [
+        360,
+        90
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "NOISE",
+          "type": "NOISE",
+          "links": [
+            362
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "RandomNoise",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        42,
+        "fixed"
+      ],
+      "widgets_values_named": {
+        "noise_seed": 42,
+        "control_after_generate": "fixed"
+      }
+    },
+    {
+      "id": 197,
+      "type": "BasicScheduler",
+      "pos": [
+        3370.9292369257732,
+        5853.188525701965
+      ],
+      "size": [
+        370,
+        130
+      ],
+      "flags": {},
+      "order": 20,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 361
+        }
+      ],
+      "outputs": [
+        {
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            365
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "BasicScheduler",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "simple",
+        3,
+        0.2
+      ],
+      "widgets_values_named": {
+        "scheduler": "simple",
+        "steps": 3,
+        "denoise": 0.2
+      }
+    },
+    {
+      "id": 198,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        3932.179236925774,
+        5603.188525701965
+      ],
+      "size": [
+        239.76709241172045,
+        326
+      ],
+      "flags": {},
+      "order": 42,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 362
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 363
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 364
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 365
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 372
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": [
+            367
+          ]
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": []
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "SamplerCustomAdvanced",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 199,
+      "type": "GetNode",
+      "pos": [
+        4284.484259214214,
+        5735.573429982442
+      ],
+      "size": [
+        210,
+        50
+      ],
+      "flags": {
+        "collapsed": true
+      },
+      "order": 13,
+      "mode": 4,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "*",
+          "type": "*",
+          "links": [
+            368
+          ]
+        }
+      ],
+      "title": "Get_VAE",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "VAE"
+      ],
+      "widgets_values_named": {
+        "Constant": "VAE"
+      }
+    },
+    {
+      "id": 200,
+      "type": "VAEDecode",
+      "pos": [
+        4307.784259214213,
+        5796.073429982437
+      ],
+      "size": [
+        230,
+        60
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 45,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 367
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 368
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            376
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.30.0",
+        "Node name for S&R": "VAEDecode",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      }
+    },
+    {
+      "id": 202,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        5567.506210306146,
+        5320.6776134084175
+      ],
+      "size": [
+        693.741563959413,
+        1518.1827163505593
+      ],
+      "flags": {
+        "collapsed": false
+      },
+      "order": 48,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 377
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 370
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        },
+        {
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "widget": {
+            "name": "frame_rate"
+          },
+          "link": 375
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "title": "Video Output 2 (Output)",
+      "properties": {
+        "cnr_id": "comfyui-videohelpersuite",
+        "ver": "993082e4f2473bf4acaf06f51e33877a7eb38960",
+        "Node name for S&R": "VHS_VideoCombine",
+        "ue_properties": {
+          "widget_ue_connectable": {
+            "frame_rate": true
+          },
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        },
+        "aux_id": "kosinkadink/ComfyUI-VideoHelperSuite"
+      },
+      "widgets_values": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "minimax-h3/Upscaled_24_fps_video_",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 12,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": true,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "vid-patch1_00002-audio.mp4",
+            "subfolder": "minimax-h3",
+            "type": "output",
+            "format": "video/h264-mp4",
+            "frame_rate": 24,
+            "workflow": "vid-patch1_00002.png",
+            "fullpath": "/home/bryan/Documents/ComfyUI/ComfyUI/output/minimax-h3/vid-patch1_00002-audio.mp4"
+          },
+          "muted": false
+        }
+      },
+      "widgets_values_named": {
+        "frame_rate": 24,
+        "loop_count": 0,
+        "filename_prefix": "minimax-h3/Upscaled_24_fps_video_",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 12,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": true,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "vid-patch1_00002-audio.mp4",
+            "subfolder": "minimax-h3",
+            "type": "output",
+            "format": "video/h264-mp4",
+            "frame_rate": 24,
+            "workflow": "vid-patch1_00002.png",
+            "fullpath": "/home/bryan/Documents/ComfyUI/ComfyUI/output/minimax-h3/vid-patch1_00002-audio.mp4"
+          },
+          "muted": false
+        }
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 203,
+      "type": "SetNode",
+      "pos": [
+        1286.4724929438958,
+        5255.62196170261
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 41,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "link": 373
+        }
+      ],
+      "outputs": [
+        {
+          "name": "AUDIO",
+          "type": "AUDIO",
+          "links": null
+        }
+      ],
+      "title": "Set_src_audio",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "src_audio",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "src_audio"
+      ],
+      "widgets_values_named": {
+        "Constant": "src_audio"
+      }
+    },
+    {
+      "id": 204,
+      "type": "MathExpression|pysssss",
+      "pos": [
+        4523.449955620569,
+        6055.593667019151
+      ],
+      "size": [
+        400,
+        200
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "a",
+          "shape": 7,
+          "type": "INT,FLOAT,IMAGE,LATENT",
+          "link": null
+        },
+        {
+          "name": "b",
+          "shape": 7,
+          "type": "INT,FLOAT,IMAGE,LATENT",
+          "link": null
+        },
+        {
+          "name": "c",
+          "shape": 7,
+          "type": "INT,FLOAT,IMAGE,LATENT",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null
+        },
+        {
+          "name": "FLOAT",
+          "type": "FLOAT",
+          "links": [
+            375
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-custom-scripts",
+        "ver": "1.2.5",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "24*2"
+      ],
+      "widgets_values_named": {
+        "expression": "24*2"
+      }
+    },
+    {
+      "id": 206,
+      "type": "RIFEInterpolation",
+      "pos": [
+        5119.520312181979,
+        5795.638672522782
+      ],
+      "size": [
+        270,
+        178
+      ],
+      "flags": {},
+      "order": 47,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 376
+        }
+      ],
+      "outputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "links": [
+            377
+          ]
+        }
+      ],
+      "properties": {
+        "aux_id": "GACLove/ComfyUI-VFI",
+        "ver": "6176a430f12cd16003f4664c1e3c6af8e96cc3c6",
+        "Node name for S&R": "RIFEInterpolation",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        24,
+        60,
+        1,
+        "flownet.pkl",
+        8,
+        true
+      ],
+      "widgets_values_named": {
+        "source_fps": 24,
+        "target_fps": 60,
+        "scale": 1,
+        "model_name": "flownet.pkl",
+        "batch_size": 8,
+        "use_fp16": true
+      },
+      "ndSuperSelectorEnabled": false,
+      "ndPowerEnabled": false
+    },
+    {
+      "id": 207,
+      "type": "SetNode",
+      "pos": [
+        596.3791007131739,
+        4439.082344867778
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 35,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "link": 379
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": null
+        }
+      ],
+      "title": "Set_model_VDN",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "model_VDN",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "model_VDN"
+      ],
+      "widgets_values_named": {
+        "Constant": "model_VDN"
+      },
+      "color": "#1f1f48",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 208,
+      "type": "SetNode",
+      "pos": [
+        1308.9444211807354,
+        5370.09917893309
+      ],
+      "size": [
+        223.53515625,
+        60
+      ],
+      "flags": {},
+      "order": 31,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "link": 380
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": null
+        }
+      ],
+      "title": "Set_conditionning",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "conditionning",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "conditionning"
+      ],
+      "widgets_values_named": {
+        "Constant": "conditionning"
+      },
+      "color": "#38291f",
+      "bgcolor": "rgba(24,24,27,.9)"
+    },
+    {
+      "id": 209,
+      "type": "Fast Groups Bypasser (rgthree)",
+      "pos": [
+        2524.1583410749927,
+        5017.789720985363
+      ],
+      "size": [
+        247.2955078125,
+        178
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "OPT_CONNECTION",
+          "type": "*",
+          "links": null
+        }
+      ],
+      "properties": {
+        "matchColors": "",
+        "matchTitle": "",
+        "showNav": true,
+        "showAllGraphs": true,
+        "sort": "position",
+        "customSortAlphabet": "",
+        "toggleRestriction": "default",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      }
+    },
+    {
+      "id": 210,
+      "type": "SaveH3Bundle",
+      "pos": [
+        1961.8501333519866,
+        5241.902352667398
+      ],
+      "size": [
+        400,
+        456
+      ],
+      "flags": {},
+      "order": 44,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "link": 391
+        },
+        {
+          "name": "conditioning",
+          "shape": 7,
+          "type": "CONDITIONING",
+          "link": 381
+        },
+        {
+          "name": "video",
+          "shape": 7,
+          "type": "VIDEO",
+          "link": 392
+        },
+        {
+          "name": "images",
+          "shape": 7,
+          "type": "IMAGE",
+          "link": null
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "width",
+          "shape": 7,
+          "type": "INT",
+          "widget": {
+            "name": "width"
+          },
+          "link": 385
+        },
+        {
+          "name": "height",
+          "shape": 7,
+          "type": "INT",
+          "widget": {
+            "name": "height"
+          },
+          "link": 384
+        },
+        {
+          "name": "seed",
+          "shape": 7,
+          "type": "INT",
+          "widget": {
+            "name": "seed"
+          },
+          "link": 388
+        }
+      ],
+      "outputs": [
+        {
+          "name": "bundle_path",
+          "type": "STRING",
+          "links": [
+            390
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SaveH3Bundle",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "H3/Save_latent_cond/run_",
+        "save",
+        0,
+        0,
+        "randomize",
+        24,
+        5,
+        "",
+        0,
+        "randomize",
+        24,
+        5,
+        ""
+      ],
+      "widgets_values_named": {
+        "bundle_name": "H3/Save_latent_cond/run_",
+        "mode": "save",
+        "video_path": 0,
+        "preview_frames": 0,
+        "preview_mp4": "randomize",
+        "keep_last_n": 24,
+        "width": 5,
+        "height": "",
+        "seed": 0,
+        "control_after_generate": "randomize",
+        "fps": 24,
+        "generation_seconds": 5,
+        "notes": ""
+      }
+    },
+    {
+      "id": 211,
+      "type": "GetNode",
+      "pos": [
+        1620.3068074605058,
+        5455.36235488306
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            384
+          ]
+        }
+      ],
+      "title": "Get_height",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "height"
+      ],
+      "widgets_values_named": {
+        "Constant": "height"
+      },
+      "color": "#1b4669",
+      "bgcolor": "#29699c"
+    },
+    {
+      "id": 212,
+      "type": "GetNode",
+      "pos": [
+        1619.4751745121116,
+        5333.651186770866
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            385
+          ]
+        }
+      ],
+      "title": "Get_width",
+      "properties": {
+        "Node name for S&R": "GetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "width"
+      ],
+      "widgets_values_named": {
+        "Constant": "width"
+      },
+      "color": "#1b4669",
+      "bgcolor": "#29699c"
+    },
+    {
+      "id": 213,
+      "type": "SetNode",
+      "pos": [
+        -738.3667157504831,
+        5830.672682838942
+      ],
+      "size": [
+        210,
+        60
+      ],
+      "flags": {
+        "collapsed": true
+      },
+      "order": 27,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "link": 383
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null
+        }
+      ],
+      "title": "Set_height",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "height",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "height"
+      ],
+      "widgets_values_named": {
+        "Constant": "height"
+      },
+      "color": "#1b4669",
+      "bgcolor": "#29699c"
+    },
+    {
+      "id": 214,
+      "type": "SetNode",
+      "pos": [
+        -542.2339207115867,
+        5608.02949441485
+      ],
+      "size": [
+        210,
+        58
+      ],
+      "flags": {
+        "collapsed": true
+      },
+      "order": 24,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "link": 382
+        }
+      ],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": null
+        }
+      ],
+      "title": "Set_width",
+      "properties": {
+        "Node name for S&R": "SetNode",
+        "aux_id": "kijai/ComfyUI-KJNodes",
+        "previousName": "width",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "version": "7.5.1",
+          "input_ue_unconnectable": {}
+        }
+      },
+      "widgets_values": [
+        "width"
+      ],
+      "widgets_values_named": {
+        "Constant": "width"
+      },
+      "color": "#1b4669",
+      "bgcolor": "#29699c"
+    },
+    {
+      "id": 216,
+      "type": "PrimitiveInt",
+      "pos": [
+        1589.11306583775,
+        5076.806327532248
+      ],
+      "size": [
+        270,
+        82
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            388,
+            389
+          ]
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfy-core",
+        "ver": "0.34.5",
+        "Node name for S&R": "PrimitiveInt",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        4224,
+        "fixed"
+      ],
+      "widgets_values_named": {
+        "value": 4224,
+        "fixed": "fixed"
+      }
+    },
+    {
+      "id": 217,
+      "type": "ShowText|pysssss",
+      "pos": [
+        2379.8169537945423,
+        5268.9087051319975
+      ],
+      "size": [
+        247.7914780029946,
+        162.23318240239496
+      ],
+      "flags": {},
+      "order": 46,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 390
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "shape": 6,
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "cnr_id": "comfyui-custom-scripts",
+        "ver": "1.2.5",
+        "Node name for S&R": "ShowText|pysssss",
+        "ue_properties": {
+          "widget_ue_connectable": {},
+          "input_ue_unconnectable": {},
+          "version": "7.5.1"
+        }
+      },
+      "widgets_values": [
+        "/home/bryan/Documents/ComfyUI/ComfyUI/output/h3_bundles/H3Save_latent_condrun__20260907_152858"
+      ],
+      "widgets_values_named": {
+        "text_0": "/home/bryan/Documents/ComfyUI/ComfyUI/output/h3_bundles/H3Save_latent_condrun__20260907_152858"
+      }
+    }
+  ],
+  "links": [
+    [
+      250,
+      120,
+      0,
+      121,
+      1,
+      "VAE"
+    ],
+    [
+      251,
+      119,
+      0,
+      122,
+      1,
+      "VAE"
+    ],
+    [
+      253,
+      129,
+      0,
+      125,
+      0,
+      "NOISE"
+    ],
+    [
+      254,
+      126,
+      0,
+      125,
+      1,
+      "GUIDER"
+    ],
+    [
+      256,
+      124,
+      0,
+      125,
+      3,
+      "SIGMAS"
+    ],
+    [
+      258,
+      122,
+      0,
+      130,
+      0,
+      "IMAGE"
+    ],
+    [
+      260,
+      130,
+      0,
+      92,
+      0,
+      "VIDEO"
+    ],
+    [
+      280,
+      125,
+      0,
+      122,
+      0,
+      "LATENT"
+    ],
+    [
+      281,
+      125,
+      0,
+      121,
+      0,
+      "LATENT"
+    ],
+    [
+      285,
+      115,
+      0,
+      144,
+      0,
+      "INT"
+    ],
+    [
+      286,
+      115,
+      1,
+      145,
+      0,
+      "INT"
+    ],
+    [
+      328,
+      121,
+      0,
+      130,
+      1,
+      "AUDIO"
+    ],
+    [
+      332,
+      127,
+      0,
+      177,
+      0,
+      "MODEL"
+    ],
+    [
+      341,
+      179,
+      0,
+      125,
+      2,
+      "SAMPLER"
+    ],
+    [
+      344,
+      185,
+      0,
+      126,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      345,
+      185,
+      1,
+      125,
+      4,
+      "LATENT"
+    ],
+    [
+      346,
+      128,
+      0,
+      185,
+      0,
+      "CLIP"
+    ],
+    [
+      347,
+      119,
+      0,
+      185,
+      1,
+      "VAE"
+    ],
+    [
+      348,
+      120,
+      0,
+      185,
+      2,
+      "VAE"
+    ],
+    [
+      349,
+      115,
+      0,
+      184,
+      1,
+      "INT"
+    ],
+    [
+      350,
+      115,
+      1,
+      184,
+      2,
+      "INT"
+    ],
+    [
+      353,
+      184,
+      0,
+      185,
+      3,
+      "MINIMAX_H3_TIMELINE_PLAN"
+    ],
+    [
+      354,
+      187,
+      0,
+      186,
+      0,
+      "MODEL"
+    ],
+    [
+      355,
+      188,
+      0,
+      187,
+      0,
+      "MODEL"
+    ],
+    [
+      356,
+      177,
+      0,
+      188,
+      0,
+      "MODEL"
+    ],
+    [
+      357,
+      186,
+      0,
+      126,
+      0,
+      "MODEL"
+    ],
+    [
+      358,
+      186,
+      0,
+      124,
+      0,
+      "MODEL"
+    ],
+    [
+      359,
+      190,
+      0,
+      195,
+      0,
+      "MODEL"
+    ],
+    [
+      360,
+      191,
+      0,
+      195,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      361,
+      190,
+      0,
+      197,
+      0,
+      "MODEL"
+    ],
+    [
+      362,
+      196,
+      0,
+      198,
+      0,
+      "NOISE"
+    ],
+    [
+      363,
+      195,
+      0,
+      198,
+      1,
+      "GUIDER"
+    ],
+    [
+      364,
+      194,
+      0,
+      198,
+      2,
+      "SAMPLER"
+    ],
+    [
+      365,
+      197,
+      0,
+      198,
+      3,
+      "SIGMAS"
+    ],
+    [
+      367,
+      198,
+      0,
+      200,
+      0,
+      "LATENT"
+    ],
+    [
+      368,
+      199,
+      0,
+      200,
+      1,
+      "VAE"
+    ],
+    [
+      370,
+      193,
+      0,
+      202,
+      1,
+      "AUDIO"
+    ],
+    [
+      372,
+      192,
+      0,
+      198,
+      4,
+      "LATENT"
+    ],
+    [
+      373,
+      121,
+      0,
+      203,
+      0,
+      "AUDIO"
+    ],
+    [
+      375,
+      204,
+      1,
+      202,
+      4,
+      "FLOAT"
+    ],
+    [
+      376,
+      200,
+      0,
+      206,
+      0,
+      "IMAGE"
+    ],
+    [
+      377,
+      206,
+      0,
+      202,
+      0,
+      "IMAGE"
+    ],
+    [
+      378,
+      125,
+      0,
+      192,
+      0,
+      "LATENT"
+    ],
+    [
+      379,
+      186,
+      0,
+      207,
+      0,
+      "MODEL"
+    ],
+    [
+      380,
+      185,
+      0,
+      208,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      381,
+      185,
+      0,
+      210,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      382,
+      115,
+      0,
+      214,
+      0,
+      "INT"
+    ],
+    [
+      383,
+      115,
+      1,
+      213,
+      0,
+      "INT"
+    ],
+    [
+      384,
+      211,
+      0,
+      210,
+      6,
+      "INT"
+    ],
+    [
+      385,
+      212,
+      0,
+      210,
+      5,
+      "INT"
+    ],
+    [
+      388,
+      216,
+      0,
+      210,
+      7,
+      "INT"
+    ],
+    [
+      389,
+      216,
+      0,
+      129,
+      0,
+      "INT"
+    ],
+    [
+      390,
+      210,
+      0,
+      217,
+      0,
+      "STRING"
+    ],
+    [
+      391,
+      125,
+      0,
+      210,
+      0,
+      "LATENT"
+    ],
+    [
+      392,
+      130,
+      0,
+      210,
+      2,
+      "VIDEO"
+    ]
+  ],
+  "groups": [
+    {
+      "id": 1,
+      "title": "Models",
+      "bounding": [
+        -1520,
+        4840,
+        700,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 2,
+      "title": "Sampling",
+      "bounding": [
+        136.29100926618636,
+        4834.271224643126,
+        690,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 3,
+      "title": "Conditioning",
+      "bounding": [
+        -790,
+        4840,
+        480,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 4,
+      "title": "Decoding and create video",
+      "bounding": [
+        888.501561617095,
+        4839.100440233215,
+        670,
+        670
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 5,
+      "title": "User Inputs",
+      "bounding": [
+        -1520,
+        5540,
+        1210,
+        880
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    },
+    {
+      "id": 6,
+      "title": "Upscaling",
+      "bounding": [
+        2558.029612735003,
+        5351.991034540429,
+        2454.80502,
+        1275.2606874999992
+      ],
+      "color": "#3f789e",
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.9277171243279717,
+      "offset": [
+        1500.7939306240755,
+        -3948.661739430455
+      ]
+    },
+    "frontendVersion": "1.49.6",
+    "VHS_latentpreview": false,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": true,
+    "VHS_KeepIntermediate": true,
+    "anomalous_hashes": {
+      "127_minimax_h3_ref2va_int8_convrot.safetensors": {
+        "hash": "",
+        "size": 34038894550
+      },
+      "119_minimax_h3_video_vae_fp16.safetensors": {
+        "hash": "",
+        "size": 5207808496
+      },
+      "120_minimax_h3_audio_vae_fp32.safetensors": {
+        "hash": "",
+        "size": 605254808
+      },
+      "177_minimax_h3_fl2v_lightx2v_turbo_4step_v1.0_768p_resized_avg_rank_31_bf16.safetensors": {
+        "hash": "",
+        "size": 440873704
+      }
+    },
+    "ue_links": [],
+    "links_added_by_ue": []
+  },
+  "version": 0.4
+}