Z-FUSE: LoRA Bus (Stacker)

You know the failure mode: you chain three LoRAs into LoraLoaderModelOnly on Z-Image, crank them past 0.8 because that's what likeness demands on this architecture, and the render comes back as an over-bright, muddy version of everything at once. The Z-FUSE pack exists because sequential patching - a patch applied on top of a patch, on top of a patch - saturates the weights until nothing survives cleanly. This node, the LoRA Bus (Stacker), is the compact way to feed that pack's fusion engine.

Call it a staging node and you've got it. ZFuseLoRAStack doesn't patch your model, doesn't touch VRAM, doesn't fuse anything. It takes one LoRA plus a description of where it should act and hands a LORA_STACK to the next node in the chain. The heavy lifting - the TIES merging that makes several LoRAs play nice - happens later in ZFuseOrchestrator. If you're looking at this node alone and wondering why the image didn't change, that's the answer: it only stages data.

The inputs that actually matter:

• lora_name - pick your LoRA from the dropdown, same models/loras folder the standard loader reads.
• block_start / block_end - a 0–29 range of Z-Image's 30 transformer blocks this LoRA may touch. The README's mental map: 0–8 is composition and framing, 9–20 is anatomy and spatial structure, 21–29 is texture, skin, lighting. Set a tight range to keep a style LoRA off the anatomy blocks entirely.
• strength - the base multiplier for that whole range. Z-Image LoRAs run hot; people routinely sit at 1.0 and above, so don't be scared of a number the SDXL days would have called dangerous.
• layer_weights - the surgical escape hatch. A multiline override like 12:1.5, 14:0.5 pins specific blocks at specific multipliers, overriding strength for just those. Note these are absolute values, not offsets.
• lora_stack (optional) - chain one Bus into another to keep building the stack.

Mechanically, each node appends one entry (name, strength, block range, overrides) to a list. Blocks outside the range simply never get a delta. Then you wire the final LORA_STACK into the Orchestrator's lora_stack input, and it decides what the stack actually does to the model.

Install

Two routes, both trivial - there's no requirements.txt and no model download:

cd ComfyUI/custom_nodes
git clone https://github.com/destinyfaux/Z-Fuse.git

then restart ComfyUI. Or use ComfyUI Manager → "Install Custom Nodes" → search Z-Fuse. That's it; the pack only needs safetensors and torch, which ComfyUI already ships.

Gotchas

• It does nothing alone. If your Bus isn't followed by a ZFuseOrchestrator, your stack is a list that's never read. Build the chain first, debug later.
• Range masking is a filter, not a boost. Setting 0–29 is fine; setting a range that misses the blocks a LoRA actually trained on just wastes the node.
• Z-Image LoRAs only. LoRAs are architecture-bound - an SDXL or Flux LoRA will mostly fail to match keys and quietly do nothing (check the Orchestrator's status log). This pack is tuned for the S3-DiT family, Base and Turbo alike.
• The fuse is where the RAM goes. The Orchestrator offloads aggressively to system RAM during fusion, so a big stack on a small machine is a system-RAM problem, not a VRAM one.

One more thing: this is the compact sibling. If you want per-block sliders and an impact report, that's ZFuseVisualLayerTuner - a better first stop when you don't yet know which blocks a LoRA actually cares about. Once you've learned its hot blocks, the Bus is how you encode that knowledge in a node that doesn't eat half the canvas.