Zura · Apply H3 Continuation

MiniMax H3's headline is up to 15 seconds at 2K - through the API. The local ComfyUI graph everyone actually runs is built around a 124-frame context, which at 24 fps is about five seconds. So anything longer than a five-second take means chaining windows, and chaining windows by hand is where mouths start flapping twice at the join. This node is the "second half" of that chain.

What it's for

Three nodes in this pack do the window dance: Zura · Save H3 Continuation writes the tail of window N to disk, Zura · Load H3 Continuation validates and reads it back, and Zura · Apply H3 Continuation is what actually welds it into window N+1's latent right before you sample. If you're building a longer H3 shot in graph view rather than through Zura Studio, this is the node that makes the seam exist at all.

How it works

H3's latent is a 24-channel video tensor of shape [1, 24, tokens, H/16, W/16], and the trick is that the first two video tokens of a window can be handed over as frozen context. The saved state carries exactly that - a two-token prefix plus the five real decoded frames it corresponds to.

ZuraApplyH3Continuation calls the pack's apply_video_prefix, which writes those two tokens into the latent you hand it, then hands back both the patched latent and the five guide frames as an IMAGE. You wire the guide into H3's native guide node at frame index 0 so the sampler starts from pixels the previous window actually produced. The code is fussy about the state being a real H3ContinuationState - pass a raw latent in that slot and it refuses rather than silently sampling an unconditioned take.

One ordering detail that bites: the docstring is explicit that this runs after the background and audio masking nodes. The prefix is the previous window's sampled latent, so if you let ZuraH3PreserveBackground stamp the source-video noise mask on top of it, you've just overwritten the thing you came for. Continuation last, masking before it.

Inputs and outputs

• latent - the H3 audio-video latent you're continuing, straight from the H3 reference-to-video conditioning node.
• continuation_state - the H3_CONTINUATION wire from Load H3 Continuation.
• latent (output) - patched, goes into your guider/sampler chain.
• guide_frames (output) - the five IMAGE frames of the previous window's tail, into the native H3 add-guide node at frame 0.

That's it. No strength, no blend slider - the hard part already happened when the state was saved.

Install

The whole pack installs at once, so you don't install anything per node. Search Zura Nodes in ComfyUI Manager, or:

cd ComfyUI/custom_nodes
git clone https://github.com/ZURAVFX/ComfyUI_zura_nodes
pip install -r ComfyUI_zura_nodes/requirements.txt

Then restart ComfyUI. The heavy lift isn't the pack - it's H3 itself: the Comfy-Org weights (minimax_h3_ref2va_pruned_int8_convrot.safetensors, the qwen3vl_32b text encoder, the video and audio VAEs) are separate multi-gigabyte downloads and the H3 community licence is territorial, so check you're actually allowed to run it where you live.

Common issues

"Load a verified H3 continuation state first." You wired something other than the load node's output, or the load node failed last run and passed nothing through.

"The H3 continuation belongs to a different generation, raster, window or shot." This is the good error, and it's usually you. Changing the seed, swapping the model, or nudging resolution between windows invalidates the state by design - the digests it checks are the generation digest, model digest and raster, and they all have to match the save. Restart the sequence from window 1.

Segments that don't line up with your cut list. Continuation only ever reaches back inside the same shot. At a detected or manual cut the new window starts unconditioned, which is correct - hard cuts should stay hard. If you're seeing a soft ghost at a cut, your cut boundaries are wrong, not the node.

Cache weirdness. Load H3 Continuation deliberately returns NaN from IS_CHANGED so it re-validates the on-disk file every run. That's the standard ComfyUI cache-bypass idiom and it's intentional here - but it does mean one always-dirty node in the chain, so expect that branch to re-execute each time you hit Run.