Continuum Timeline Save Take

The single most useful idea in Continuum's timeline stack is that a generation is a take, not a result. You sample three versions, watch them in a review panel, keep the one where the hand didn't melt, and the file you rejected stays on disk. That's how editing actually works, and it's why this node exists at all.

Continuum Timeline Save Take is the commit step. Three inputs, two outputs, no widgets. It takes the assembled images, the assembled audio, and the typed take from the sampler, muxes them into a real file, registers that file as a project asset, and hands back a take record with a rendition attached.

How it works

The commit is honest and direct about frames. It reads output_range out of the take record - the sampler's absolute frame span for this job - and takes n = end - start. If your images don't have at least n frames, it stops with: "Save Take requires the natural retained timeline from the assembler; select Natural retained timeline before saving." No silent padding, no guessing which frames were meant.

Then it writes exactly n frames through PyAV into a temporary MKV, dumps the audio waveform as raw little-endian float32 PCM, and shells out to ffmpeg to mux them with -c:v copy -c:a pcm_f32le -t n/24. Video is copied, not re-encoded; the audio is a float PCM track. It hashes the result into the project store's asset registry as Take <id-prefix>.mkv and writes a small render-<take_id>.json rendition pointer atomically.

One guard worth knowing: if a different rendition already exists for that same take id, it refuses - "This take already has a different rendered output; create a new take." Takes are content-addressed history, not a mutable slot.

Outputs are take (now carrying the rendition, so downstream and the review panel know what got written) and status, which is just the string Take saved. It's also an output node with a UI text line - "Take <id> ready for review in Timeline Studio" - so it runs on Queue and tells you about it.

Wiring it without pain

The pipeline the user guide spells out:

1. Timeline Studio → timeline into Continuum Timeline Sampler.
2. video_latents and audio_latents through Core VAE Decode and Decode Audio.
3. Those into H3 Continuum Assemble + Seam V3.4, with assembly_plan.
4. Assemble's images and audio plus the sampler's take into Continuum Timeline Save Take.
5. Set Timeline Output = Natural retained timeline (Refinement) on the assembler. This is the step people skip, and then Save Take complains.

The important mental model: the assembler is where you choose natural versus exact; Save Take requires natural. If you already finalized the duration with the Finalize Duration node, save the take before that, from the natural output. Same rule as the finalizer - natural, every frame, then decide.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/xmarre/ComfyUI-H3-Continuum-Plus.git ComfyUI-H3-Continuum

Restart ComfyUI. Manager: search H3 Continuum. Two dependencies actually bite here:

• ffmpeg must be on the server's PATH. This node calls it directly to mux. requirements.txt covers PyAV (av>=17.0.0) but pip can't install an ffmpeg binary for you in a way the shell will find. If Save Take errors on the subprocess, this is why.
• PyAV ≥ 17. Older bundled versions fail in the media layer; install the pack's requirements into ComfyUI's Python.

And don't run the Plus fork alongside upstream ukr8b3g-cmyk/ComfyUI-H3-Continuum - overlapping identifiers.

Troubleshooting

"Save Take requires the natural retained timeline." You're feeding exact-duration frames, or something downstream changed the frame count. Switch the assembler, reconnect the take from the matching sampler execution.

The take saves but the review panel won't show it / footage looks stale. Stale-take checks are deliberate. If you changed a chunk's references or prompt, the dependent suffix is invalidated and composition rejects the old footage rather than presenting it as current. Rerender the suffix, or remove the stale generated region so retained original footage shows through again.

Two takeaways from the design, if you're comparing with other packs. First, this is a filesystem-backed take store tied to a project directory - great for iteration, and something you should back up like any editing project rather than treat as disposable cache. Second, the natural-timeline requirement means frame count is a contract all the way down the chain. Fix counts upstream; don't try to outsmart Save Take with a trim node.