🐧 WanSCAILToVideo (Latent Masked)

If you've run SCAIL-2 in ComfyUI, you know the annoyance: the model is great at moving a character, but it also re-draws everything - including the background and the parts of the frame you wanted kept exactly as filmed. 🐧 WanSCAILToVideo (Latent Masked) is a modified copy of ComfyUI's core WanSCAILToVideo that fixes that specific problem. Give it the original video plus a mask, and the masked regions are hard-preserved: encoded into the latent and locked there so the sampler physically cannot change them, instead of being trusted to recreate them and getting them subtly wrong.

The context matters here. SCAIL-2 is Z.ai's Apache 2.0 motion-transfer model on a Wan 2.1 base - the one that dropped the stick-figure skeleton entirely and took reference image + driving video + masks directly, which is what unlocked cross-identity replacement and animal driving. It shipped into ComfyUI core (no separate model pack needed), and its defining costs are compute (plan on minutes per clip, fp8 on 16GB, Q4 GGUF on 8GB) and its 81-frame chunking. This node sits on top of all of that, adding one feature: don't let the model touch what you say not to touch.

How it works

The preservation works at the latent level. original_frames (your video at output resolution) are VAE-encoded and written into the latent wherever original_frame_masks are white (1.0). The matching noise_mask is set to zero there, which is the sampler's signal to keep those latent values exactly as they are - preservation, not recreation. Black mask areas (0.0) generate normally.

The subtleties are where this node earns its keep:

• Token-grid snapping. Wan's VAE is 8× and the transformer patches 2×2, so one latent token is 16×16 pixels. Your mask is snapped outward onto that grid, so the boundary lands on token edges instead of cutting through them.
• frame_mask_grow shifts that boundary afterwards, in 8-px latent-cell units. Positive = dilate into generated territory (your masked area stays untouched, but the transition boundary moves). Negative = erode into preserved territory (the model recreates a boundary strip, sacrificing some original pixels for a more seamless blend).
• Chunking is built in. video_frame_offset tracks where in the longer video each chunk begins - wire the previous chunk's video_frame_offset output into the next chunk's input, SCAIL-2's standard 81-frame window with the 76-frame step. previous_frames anchors each new chunk, and those anchor frames override preservation on the leading frames.
• enable_latent_mask (default on) toggles the whole feature - turn it off and the node behaves exactly like stock WanSCAILToVideo.

The inputs that matter for the core model are the usual suspects (positive, negative, vae, width, height, length, batch_size, pose_strength, plus the optional pose_video, reference_image, and their masks - see the SCAIL-2 docs for what those mean). The four that matter for this node's feature are enable_latent_mask, original_frames, original_frame_masks, and frame_mask_grow. Outputs are positive, negative, latent (the generation-size latent with preserved regions encoded in), and video_frame_offset for chaining.

Installing it

Part of ComfyUI-SuperNodes (GitHub: sonnybox/ComfyUI-SuperNodes) by SuperCC - ComfyUI Manager → search SuperNodes → install → restart, or:

cd ComfyUI/custom_nodes
git clone https://github.com/sonnybox/ComfyUI-SuperNodes
# restart ComfyUI

This one has real prerequisites beyond matplotlib: it imports from comfy_extras.nodes_scail, so you need a ComfyUI build that already ships SCAIL support, plus the SCAIL-2 weights (Comfy-Org's scaled/fp8 versions are the sane download). The node is flagged experimental - expect rough edges.

Where people get burned

The node checks its own inputs and errors loudly if original_frame_masks don't match original_frames dimensions - resize them together so they can't drift. A single mask broadcasts to all frames; otherwise it's one mask per frame. And the "locked" promise is only as good as the mask: after token snapping and any frame_mask_grow, what's preserved is the quantized region, so a mask that hugs a boundary tightly will preserve a few more pixels than you drew. If a background you meant to keep gets re-rendered anyway, check that the mask covers it at output resolution - a mask made at half resolution silently shifts on you.