Frame Timeline Loop Gate

Extension loops - the Wan lip-sync and MiniMax H3 segmented pipelines, forLoopEnd-style bodies, SVI-flavoured long takes - all have a version of the same bug waiting for them. You ask for three extensions, the body runs three times and everything is fine. You ask for zero, and the body still has something plugged into it, so the graph tries to execute an extension task against a plan that contains no extensions. Sometimes it errors. Sometimes it quietly generates a phantom scene. Either way you wanted the base clip exported and instead you got a fight.

Frame Timeline Loop Gate is the two-socket fix. It answers the only question that matters at that point in the graph - are there extensions left? - and it physically refuses to hand anything downstream while the answer is no.

What it actually does

This is a small node with one move in it, and the move is worth understanding because it's a ComfyUI engine feature rather than anything Eclipse invented.

Given the timeline and an extension count, it returns timeline when the count is greater than zero, and ExecutionBlocker(None) when it's zero. An execution blocker is the engine's way of saying "this output has no value, don't run the nodes that depend on it" - the branch goes dormant instead of failing. Its second output, has_extensions, is the plain boolean: count greater than zero, true or false.

That boolean is the other half of the trick, and the author's own framing is explicit: use has_extensions with a lazy If/Else to choose the loop output or the base timeline. Lazy matters. A non-lazy conditional evaluates both sides, which is exactly what you're trying to avoid when one side is an extension body with nothing to chew on. With a lazy If the false branch never executes, and it doesn't matter that its inputs are blocked.

So the wiring is: base timeline into the gate, loop_timeline into the loop body's carried value, has_extensions into the If. True → the accumulated loop result goes to preview and export. False → the original base timeline goes straight there. A three-extension plan and a zero-extension plan then take the same path, which is the point.

The inputs and outputs that matter

• timeline - an ECLIPSE_FRAME_TIMELINE. In practice this is the base timeline coming out of Decode and Append Timeline, before any extension has appended anything to it.
• extensions (int, default 0, min 0) - how many extensions are left to run. Wire it from wherever your planner computes its segment count; this is the one field you actually think about.

And two outputs:

• loop_timeline - the same timeline when extensions > 0, an execution blocker when it's 0. It goes to the loop's carried value / the extension body. It creates nothing; it's a guarded pass-through.
• has_extensions - BOOLEAN, for the lazy If/Else.

Note what default 0 means: drop the node in and leave it alone and you've just told the graph there are no extensions. That's the conservative direction, at least - you'll get a base export instead of a broken loop.

Install

The gate has no dependencies of its own; it comes with the pack. In ComfyUI Manager search the pack title ComfyUI_Eclipse, or:

cd ComfyUI/custom_nodes
git clone https://github.com/r-vage/ComfyUI_Eclipse

Restart ComfyUI afterwards - new Eclipse nodes register on startup, and this one only exists from 4.4.10 (2026-09-26) onward. The pack's requirements.txt includes stable-ts and faster-whisper for the transcription nodes; the gate needs none of that, so only install it if something else errors. One lineage note: Eclipse 4.0.0 deleted all legacy node IDs, so older saved workflows need the pack's Workflow Migration Tool first, and the author's previous ComfyUI-RvTools repo is gone - install this pack, not that one.

Where people get burned

Wiring loop_timeline and ignoring has_extensions. The most common misread. On its own, the gate only blocks the extension chain; it does not decide anything about the export path. If nothing consumes the boolean, a zero-extension plan has a blocked body and a base timeline that never explicitly went anywhere, and you're back to staring at a graph that seems to do nothing. The If node is not optional.

Assuming the gate counts anything. It doesn't inspect the timeline, doesn't know how many scenes are stored, and won't infer anything from len(timeline). Whatever number you feed extensions is the answer it acts on - if your planner passes a stale or zeroed count, you get a silent base-only export with no error anywhere. When a long run ends suspiciously short, check this input first.

Using it as a general-purpose loop counter. It is not one. The output is a timeline and a boolean; there's no index, no state, no incrementing. It exists so that the "zero extensions" case takes the boring path, and that's the whole job.