IAMCCS NextFrame CineLinX Bridge

The NextFrame storyboard flow makes still frames: scene 1, scene 2, scene 3, each committed as a reusable image. Eventually you'll want to turn those approved frames into actual video, and that's where IAMCCS_NextFrameCineLinxBridge comes in. Its job is translation - it takes your storyboard JSON, loads the selected frame images, and packages them into a cine_linx contract that the IAMCCS video side (the MiniMax H3 Shotboard, Shotboard Planner V3, and their delivery nodes) can consume as a timeline.

Think of it as the handoff between two halves of the IAMCCS framework. The storyboard half is about what happens next, shot by shot, driven by Qwen Image Edit. The video half is about turning a plan into motion, driven by the H3 Shotboard. This node is the adapter that lets the stills you approved become the shot list the video pipeline injects. The payload it builds carries the exact identity contract the downstream needs: which images, in which order, starting at which timeline slot, at what duration per shot, with the global prompt and negative prompt attached.

Mechanically it does three things. It reads the storyboard and picks the frames that are actually selected for injection (or starts from the "anchor" frame if the board says so - that's how you say "insert the next shots after this existing beat"). It loads those images into a tensor batch at your chosen width/height. And it builds a per-shot timeline - each frame becomes a segment of inject_slot_seconds duration at 24 fps, with labels, prompts and guide flags - wrapped into the CineLinX payload with a mode of iamccs_next_frame_injection and a policy of "explicit replace selected slots." Missing image files are skipped with a warning rather than crashing the whole handoff.

Inputs and outputs

Inputs: storyboard_json (the board from the builder/commit nodes), width and height (delivery frame size, 1920×1088 defaults), inject_slot_seconds (per-shot duration, default 5s), prompt_text and negative_prompt (carried through as the timeline's global prompts). Outputs: cine_linx (the contract object the Shotboard side reads) and report (how many frames were selected and over which timeline slots).

The honest take

This node is where the storyboard's "stillness" ends. Two things to watch: it only injects frames that physically exist - a filename in the board that isn't in your input folder gets skipped, so commit your frames before bridging. And the slot math matters: inject_slot_seconds sets both the on-screen duration and the timeline stride, so a 5-second value gives a 5-second shot per card. If your downstream video comes out paced wrong, this is the knob, not the video nodes.

It's a bridge, so it's only useful if you're working both sides of the IAMCCS ecosystem. On its own it produces a JSON blob you can't do much with; wired between NextFrameBuilder and a Shotboard planner, it's the glue that makes "storyboard to video" one continuous pipeline.

Install

Part of IAMCCS-nodes:

cd ComfyUI/custom_nodes
git clone https://github.com/IAMCCS/IAMCCS-nodes

or via ComfyUI Manager (search "IAMCCS"), then restart. The node itself needs nothing beyond the pack, but to use its output you need the downstream Shotboard side - which means MiniMax H3 and its VAEs on a current ComfyUI (≥ 3.x). If you're only doing still storyboards, you can stop at the builder and never touch this one.