H3 Progressive · Boundary to External Lift Input (T8 EXP)

Between the LOW pass and the HIGH pass sits a gap: something has to take a small-canvas latent and make it a big-canvas latent, and that something is a learned 3D latent upscaler the pack doesn't ship and doesn't load. Which means the pack has to do something slightly awkward - it has to hand you a latent in the format that upscaler expects, without running it.

That's this node. It's an adapter, and it's honest about being one.

What it does

In: low_boundary, a model and a sampler. Out: lift_input, target_width, target_height, plan, report_json.

Three things are happening, all mechanical:

1. It verifies the boundary's receipt - this is a typed artifact, so a corrupted or mismatched one gets rejected rather than half-used.
2. It converts the boundary's clean video back into the original VAE coordinates, so an external learned 3D latent upscaler sees what it's built to see.
3. It returns the target width and height as integers, so you can wire the geometry into whatever your upscaler node expects instead of computing it yourself and getting the 32-pixel grid subtly wrong.

And the detail that makes people do a double-take: zero audio is a lifter placeholder. The lifter only touches video. The original evolving audio stays inside low_boundary, untouched, for the HIGH side to pick up later. So the latent you're feeding a video upscaler is video-only, and that's correct - an upscaler that also upscales the audio stream is not a thing you want.

No sampling, no learned network, no model call. The report says so explicitly: sampling_calls: 0, learned_lift_executed: false.

Wiring

low_boundary ─→ Boundary to External Lift Input ─→ [your learned 3D latent upscaler]
model, sampler ─↗                                        │
target_width / target_height ────────────────────────────┘  (whatever geometry input your upscaler needs)
                                                         ↓
                                                    HIGH Handoff (lifted_av)

The plan output is a convenience: if you've been passing the plan around by hand, this gives you the authoritative version that came back out of the boundary's own receipt, not a copy you kept in the graph.

Install

Manager, search MiniMax H3 Audio T8. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/T8mars/comfyui-minimax-h3-audio-T8.git minimax-h3-audio-T8

Full restart of ComfyUI, then refresh the page in the browser. The pack installs no Python packages - the requirements.txt explicitly avoids that so installation can't replace your Torch/CUDA stack - so there's no dependency step to get wrong here.

The upscaler weights are separate: drop the H3 latent upscaler into ComfyUI/models/latent_upscale_models/ and select it in your upscaler node. The pack's docs note it's the same model the two-pass workflows already use, so if you've done a 4+4 run before, you have it.

Where people get burned

Using an RGB upscaler. The lift_input is a latent in the model's own VAE space - an image or video upscaler expecting pixels will not accept it, and bending the graph to make it fit defeats the point. This has to be the matching learned 3D latent upscaler.

Assuming this node upscales. It doesn't; it converts. If nothing between this node and the HIGH handoff actually performs the lift, HIGH will happily build a full-resolution video from the wrong latent and you'll get a soft, structurally wrong result that looks like a sampler bug rather than a wiring bug. The report is the fastest way to tell the difference.

Skipping the boundary verification path. Don't hand-roll a latent that "looks right." The typed boundary carries the plan, the geometry and the masks that HIGH needs; a lookalike latent gets you an error at best and a subtly wrong run at worst.

One last thing, since this is the node where the upscaler's quality enters your pipeline: the pack describes progressive sampling as "not a super-resolution of the finished video, and not the existing 8+4 second pass." It's finishing a trajectory at a bigger size. If you're hoping to rescue a bad LOW pass by blowing it up harder, the right fix is upstream - in the model, the prompt, or the low_scale you chose in the plan.