MiniMax H3 Archive Temporary Segment Video

What it is

MiniMax H3 Archive Temporary Segment Video is the middle node of the pack's low-memory segment chain: the one that actually makes the memory saving happen. Sampler nodes in this pipeline work on AV latents, and the expensive part of a long MiniMax H3 timeline was always decoding all of it to RGB frames at the end. This node refuses to do that. It decodes exactly one segment, writes it to a temporary H.264 file, drops the frames, and hands the ledger onward.

You only meet it directly if you're building the spill chain by hand - otherwise MiniMax H3 有限分段采样(低内存版本) expands into it once per segment and you never see it. It's in the MiniMax H3/Internal category and flagged is_dev_only in the schema, so it's hidden from the normal node list unless dev node visibility is on.

How it works

Each call handles one segment, strictly in order. First it checks that state.next_iteration matches the iteration_index you passed, and raises Temporary segment-video state is out of sequence if it doesn't - the chain is sequential by design. Then it splits the sampled AV latent: the video half goes through the vae you wired in, the audio half through audio_vae (skipped entirely when the plan has locked or muted audio). The first frames get dropped, too, because each segment deliberately reopens on the previous one's tail so continuation has something to hold onto. The requested overlap is snapped to H3's legal temporal grid before trimming - 24 frames becomes 22, 48 becomes 39 - so the latent carry, this trim and the final assembly all agree on one number. If the running frame count plus this segment would overshoot the plan's target output length, the tail is cut so the join lands exactly on the requested duration.

Then the segment becomes segment_001.mp4, segment_002.mp4, and so on - H.264, CRF 18 - inside the run's UUID folder under ComfyUI/temp/minimax_h3_segment_spill/. Audio overlaps get blended rather than duplicated when continue_audio_latent is on: the accumulated tail is trimmed and the new segment's audio appended. Finally the decoded tensors are deleted, gc and torch.cuda.empty_cache() run, and the updated state - previous latent, file list, merged audio, written frame count - leaves through the single output.

That per-segment release is the whole point. Peak VRAM here is one segment's frames, not the whole timeline's.

Inputs and outputs

• finite_plan - come from the same Material Planner output as the rest of the chain. It's re-validated here, so a mismatched plan fails loudly instead of producing garbage.
• state - the MINIMAX_H3_FINITE_LOOP_STATE from MiniMax H3 Initialize Temporary Segment Video or from the previous archive pass.
• sampled_latent - the AV latent your sampler produced for this segment. This node does not sample; pair it with a normal SamplerCustomAdvanced output (or the pack's bundled two-stage sampler).
• vae / audio_vae - the video VAE decodes frames, the audio VAE decodes sound. Both are required inputs even if the plan locks or mutes audio.
• iteration_index - a forced input, meaning it must be wired, not typed. Feed it the same counter that drives your segment selection, starting at 0.
• MINIMAX_H3_FINITE_LOOP_STATE output - into the next archive pass, or into MiniMax H3 Finish Temporary Segment Video once you've done every segment.

Installing it

Part of Songssx/ComfyUI-MiniMaxH3-TimelineDirector. Manager → search MiniMax H3, or:

cd ComfyUI/custom_nodes
git clone https://github.com/Songssx/ComfyUI-MiniMaxH3-TimelineDirector

Restart ComfyUI and search MiniMax H3. No pip dependencies are declared; you need a recent ComfyUI with native H3 nodes plus the Ref2VA model, CLIP, video VAE and audio VAE. Keep comfyui-SelfLift uninstalled - the two-stage runtime ships with this pack.

What goes wrong

Index desync. Almost every failure here is the sequence check. Wire one iteration counter into both the segment selector and iteration_index, and remember the first pass is 0, not 1.

Segment N is shorter than its opening overlap. You gave the archive fewer decoded frames than the aligned overlap needs to trim. In practice this means your timeline overlap is too big for the segment length next to it - shorten the overlap on the Material Planner or lengthen the segment.

Decoded segment audio is shorter than its overlap. Same class of problem on the audio side, and it also fires if audio_vae is the wrong one or the waveform comes back empty. Check the audio VAE before you start re-cutting timings.

Disk, not VRAM. The frames are cheap now; the files aren't free. One MP4 per segment sits in your temp directory until the final node joins and deletes them, so on a 20-segment HD run make sure ComfyUI's temp volume has room. If you're here because a long run was eating your RAM, this is the trade you made - and it's usually the right one.