Pipe Passer

What it is

Pipe Passer takes a pipe in one side and hands you the exact same pipe out the other. Nothing changes, nothing is inspected, nothing is merged. It is a node whose only job is to sit in the middle of a wire - and once you've built a workflow large enough to need one, you'll wonder why it isn't stock.

ComfyUI has a reroute node for ordinary values, but there's a class of problem it can't solve: the wire that needs to duck under a node, the connection that makes the graph unreadable, or the line you want to split so two downstream branches each get their own copy of the pipe. A passer gives you a physical break in the wire without touching the data. Think of it as a street corner the pipe takes a turn at.

How it works

The implementation is the whole story: execute receives pipe and returns pipe. One input, one output, both typed to the Eclipse pipe type. Because it's a typed node (not the * any-type kind), the type checker stays honest - whatever type your pipe is, that's what comes out, and ComfyUI knows it before the graph even runs. It's the "pass through with fixed type" pattern that the whole Router/Typed category in this pack is built on, applied to PIPE.

The reason this pattern exists at all is graph hygiene. ComfyUI caches aggressively and only re-runs what changed, so a passer costs you basically nothing at execution time. The real cost it saves is legibility: a pipe that must cross half the canvas to reach a sampler is a pipe that's easy to misread, and a misread pipe means a workflow that silently runs stale data.

The one input and one output

• pipe in → pipe out. Same object, unchanged.

That's it. There's no optional second input, no mode switch, nothing to configure. If you find yourself wanting options on a passer, you're actually looking for a switch or a Pipe Out node, not this.

When you'd use it

Three situations, in rough order of how often they come up:

1. Untangling a graph. A pipe that threads through the middle of a crowded region becomes two short wires with a passer between them, and suddenly the layout works.
2. Splitting a line. You can branch a wire in ComfyUI by pulling multiple connections off one socket, but putting a passer on the branch keeps the source clean and gives you a named place to grab the split.
3. Segmenting for debugging. Drop a passer every so often along a long pipe run; if something downstream is getting wrong data, you have checkpoints to poke at.

It's the pipe-world equivalent of the reroute node from packs like rgthree - invisible in every workflow screenshot, load-bearing in the ones that work.

Installing it

Ships with ComfyUI_Eclipse. Install the pack via Manager (search "Eclipse") or:

cd ComfyUI/custom_nodes
git clone https://github.com/r-vage/ComfyUI_Eclipse
pip install -r ComfyUI_Eclipse/requirements.txt

then restart. Heads up for anyone pulling this from an old workflow: the pack was previously RvTools_v2 and v4.0.0 removed legacy nodes, so older graphs may need the bundled migration tool to load at all.

Common issues

Honestly, this node barely has failure modes - it passes a pipe through. The one thing to keep in mind is that it's typed to the Eclipse pipe convention, so if you're expecting it to carry a bare IMAGE or LATENT, it won't. Those have their own passers in the same category (Image Passer, Latent Passer, and so on). Grab the right one and you're done.