MiniMax H3 Initialize Temporary Segment Video

What it is

MiniMax H3 Initialize Temporary Segment Video is the first of three split nodes that the pack's low-memory long-video sampler expands into behind the scenes. If you've read the node description on the sampler - "decode and encode one segment at a time in ComfyUI's temporary folder, then join the encoded segments" - this node is the "temporary folder" half of that sentence.

In normal use you never touch it. You drop MiniMax H3 有限分段采样(低内存版本), wire a Material Planner's Segment Plan into it, and ComfyUI's graph expansion creates an Initialize → Archive (×N segments) → Output chain for you. What this node exists for is the other path: hand-wiring the spill pipeline yourself, most likely inside a native ComfyUI Start Loop / End Loop, so you can slot your own processing between the sampler and the archive step.

A note on where it lives: it's in the MiniMax H3/Internal category and is flagged is_dev_only in the pack's node schema. If you don't see it next to the other MiniMax H3 nodes, that's why - it's deliberately kept out of the ordinary node list.

How it works

Under the hood it does two small things and one useful one.

It asks folder_paths.get_temp_directory() for ComfyUI's temporary directory, creates (or reuses) minimax_h3_segment_spill inside it, and makes a fresh UUID-named subfolder for this run. That folder is where every segment's MP4 will land.

Then it returns one node output: a MINIMAX_H3_FINITE_LOOP_STATE. That state isn't just a pointer - it's the run's ledger. It starts with the iteration counter at zero, no previous latent, no frames written, no video files, and no merged audio. Each pass through the archive node hands an updated copy of that ledger forward, carrying the carried-over AV latent tail, the list of MP4s already written, the concatenated audio, and a running frame count. The final node reads it to decide whether the job is complete and what to join.

The third thing is quiet housekeeping: creating the spill root also sweeps any spill folder from a previous run that's more than 24 hours old. So simply running this node cleans up after older crashed jobs.

Inputs and outputs

• finite_plan - the MINIMAX_H3_FINITE_SEGMENT_PLAN from the Material Planner's Segment Plan output. The state stores a reference to it, and both the archive and final nodes re-validate it, so you cannot swap plans mid-chain.
• continue_audio_latent (default true) - recorded into the state, not applied here. It decides downstream whether the overlapping audio is blended on the Soft AV mask or hard-trimmed to avoid duplication. Turn it off for a hard cut; leave it on for continuous speech or singing.
• MINIMAX_H3_FINITE_LOOP_STATE output - wire this into MiniMax H3 Archive Temporary Segment Video, and after the last segment, into MiniMax H3 Finish Temporary Segment Video.

Installing it

Same pack, same one-liner. Manager → search MiniMax H3, or:

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

Restart, then search for MiniMax H3. There's no separate install for these internal nodes and no extra pip requirement - the pack declares no dependencies, and the requirements you need (a recent ComfyUI with native H3 nodes, the Ref2VA model, CLIP, video VAE, audio VAE, Python 3.10+) are already the price of running H3 at all.

What goes wrong

Out-of-sequence state. The archive node refuses to run unless state.next_iteration matches the iteration_index you feed it. If you build the loop by hand, wire one counter into both the archive's iteration_index and whatever selects your segment, and make sure the loop starts at 0.

Leftover spill folders. If a run dies hard, the UUID folder stays on disk. Empty ones cost nothing and get swept after 24 hours, but if you're tight on space you can safely delete anything under ComfyUI/temp/minimax_h3_segment_spill/ between runs - nothing in the graph reads back old spills.

Path validation. The pack resolves every spill path against the spill root and throws Segment spill path is outside ComfyUI's temporary directory if it isn't there. Fine in practice, unless you're hand-crafting state or moving files around mid-run.

Don't reach for this when you want the simple thing. If you just want a long video out of H3, use the low-memory sampler - it wires this node, the archive, and the final assembly for you, and you'll get the same files in the same folder without the graph bookkeeping.