Trajectory Capture Model (Internal)

Noise reuse needs something that most ComfyUI plumbing quietly assumes away: the actual noisy states your source sampler passed through, at the actual moment it passed through them. Not a re-simulation, not a recomputation from the seed - the real tensors. This node is where that recording happens.

What it does

It takes the source MODEL, clones it, and installs a capture observer on the clone, then hands you that instrumented model plus a capture handle for the lifecycle of the recording. The clone is the important detail: your original model object is untouched, so nothing else in the graph changes behavior because you asked for noise reuse somewhere downstream. Attach the returned model to the sampler you want observed, and that run reports its states back.

The pack injects this automatically when you enable Noise Reuse Options upstream of a receiving sampler - it finds the source sampler by tracing the receiver's latent backward, then slots this node into the source's model chain. So in normal use you'll never see it. But it is a real node with real sockets, and you can place it by hand if you're building something off the pack's curve.

Inputs and outputs

• model - the source model to clone and observe.
• sampler_name - the source solver's identifier. If you're driving a custom sampler and leave it blank while connecting sampler, the name is derived from the sampler function instead.
• sampler (optional) - the source algorithm when a custom sampler node is involved, so the observer knows what it's looking at.
• graph_context (optional) - free text naming the source and receiving nodes. It's what makes the eventual error messages say "'hires pass' (SimpleSyrup.KSampler, node 12)" instead of "node 12".
• requests (optional) - the coordinates to actually record. Leave it unwired and the capture records format provenance only.
• model - the instrumented clone, to feed your source sampler.
• capture - the capture handle, which Attach Sampling Provenance consumes to stamp the source latent.

That last distinction is worth internalizing: with no requests, the observer is cheap - it exists so downstream nodes can learn which latent format the source model uses, which is all Simple Upscale Latent needs in Auto mode to pick the right learned checkpoint. With requests wired in, it saves full noisy states and their separated residuals at specific noise levels, which is the expensive, noise-reuse path.

Install

Nothing extra to install - it ships with the pack.

cd ComfyUI/custom_nodes
git clone https://github.com/Artificial-Sweetener/SimpleSyrup.git
cd SimpleSyrup
../../venv/bin/python -m pip install -r requirements.txt

ComfyUI Manager users: search the Node Pack list for SimpleSyrup and install from there. Restart ComfyUI afterward, and note the pack wants a current ComfyUI, since these internal nodes come from the v3 node API.

Things worth knowing

It only observes one kind of thing well. A custom sampler whose algorithm doesn't expose its model through a guider can't be observed at all, and the pack says so rather than recording garbage. Named samplers (the standard model + sampler_name + sigmas shape) are the supported path.

The capture is scoped, not global. It belongs to one source run. Hand-wiring a capture from run A onto a latent from run B is exactly the kind of mistake Attach Sampling Provenance is built to catch, so it'll refuse instead of quietly stamping the wrong identity onto your latent.

Don't stack it on a shared model by hand and expect a speedup elsewhere. Cloning means the observed copy is used by the sampler you attach it to; other branches keep the plain model. If you want that, wire it that way deliberately.