@koda-sl/baker-cli 0.129.1-dev.972f3c9aa → 0.131.0-dev.cad5e0bc7

package/README.md

@@ -2754,6 +2754,16 @@ baker canvas run my-canvas.json --regenerate gen_4x5,gen_9x16
 #         (e.g. "regenerate": 2) and re-run; the fresh render is reproducible in any
 #         later session. Bump it again (3, 4, …) for each additional draw.
 
+# 2e. Push a creative's current node-graph + wired input thumbnails to the
+#     dashboard WITHOUT rendering — so its workflow view reflects an edit (a
+#     swapped logo/hero, a rewired ref, a prompt tweak) the moment you save,
+#     with no credits spent. Runs automatically on every canvas.json/prompt.json
+#     edit (a file watcher), but you can invoke it directly. Accepts the
+#     .canvas.json, its prompt.json, or the creative folder. The rendered image
+#     still only changes on a real `run`, so the dashboard shows an "edited since
+#     last render" badge in the meantime.
+baker canvas sync-definition src/creatives/<slug>/
+
 # 3. Inspect a finished run (per-node timing, file list, optional video thumbs)
 baker canvas inspect <run_id>
 
@@ -4078,9 +4088,9 @@ It then scaffolds the full pipeline like an **editing timeline**: each clip gets
 
 **True output aspect, even when the video model can't generate it.** The scaffold resolves TWO ratios: the ad's **output** ratio (the source video's detected `aspect_ratio`, or **`--aspect`**, e.g. `4:5` → a 1080×1350 canvas) and the **generation** ratio — the nearest ratio the video model supports (Seedance has no 4:5, so clips + conditioning keyframes generate at `3:4`). When they differ the scaffold warns loudly, records `metadata.todo.aspect_remap`, normalizes **every clip** onto the output canvas (scale-to-fill, center-crop — keep subjects centered), sizes every ffmpeg plate/still/composite to the output dims, and stamps the copied overlay/caption compositions' `meta.json` to match. Nothing is silently dropped: an unknown ratio snaps to the nearest known one and stays explicit on every node.
 
-**Montage flashes held as stills — unless the picture really moves.** A rapid-cut beat shorter than ~2s with no spoken line is a **flash** — Seedance's shortest clip is 4s, so generating one (then trimming away most of it) burns credits for motion no viewer perceives. The scaffold instead **holds one keyframe as a still** for the scene length (a cheap ffmpeg loop, no billed `video_generate`), same look at a fraction of the cost. The deconstruct now stamps each scene's **`motion_level`** (`static` / `subtle` / `dynamic`): a **dynamic** flash (pouring chocolate, hands working, walking) keeps a **real trimmed clip** — freezing a moving montage turns it into a slideshow — while genuinely static beats (a logo card, a pinned photo, a product still) keep the cheap hold. Talking/ambient beats always keep a real clip (they need motion + native audio). The deconstruct also stamps each dialogue line's **`on_camera`** flag — a voice playing over b-roll, a graphic, or a mere *photo* of the speaker stays voiceover, so the scaffold never lip-syncs a scene with no speaking face (the polaroid close-up failure).
+**Montage flashes held as stills — unless the picture really moves.** A rapid-cut beat shorter than ~2s with no spoken line is a **flash** — Seedance's shortest clip is 4s, so generating one (then trimming away most of it) burns credits for motion no viewer perceives. The scaffold instead **holds one keyframe as a still** for the scene length (looped directly on the spine's input — no billed `video_generate`, no extra node), same look at a fraction of the cost. A beat the deconstruct **explicitly** stamps `static`/`subtle` holds a still up to **~3.5s** (just under the Seedance 4s floor); an unstamped beat keeps the conservative 2s ceiling. The deconstruct now stamps each scene's **`motion_level`** (`static` / `subtle` / `dynamic`): a **dynamic** flash (pouring chocolate, hands working, walking) keeps a **real trimmed clip** — freezing a moving montage turns it into a slideshow — while genuinely static beats (a logo card, a pinned photo, a product still) keep the cheap hold. Talking/ambient beats always keep a real clip (they need motion + native audio). The deconstruct also stamps each dialogue line's **`on_camera`** flag — a voice playing over b-roll, a graphic, or a mere *photo* of the speaker stays voiceover, so the scaffold never lip-syncs a scene with no speaking face (the polaroid close-up failure).
 
-**One clip per shot — separated at complete breaks.** A video is a sequence of clear **shots** with **complete breaks** (hard cuts) between them, and that is what the scaffold separates by: **two adjacent presenter shots at a hard cut become TWO clips**, never glued into one invented take just because the speech runs continuously across the cut. Each presenter shot is one Seedance clip (`s<anchor>_clip`, native lip-sync + audio) re-voiced to the brand voice. What is **NOT** split: a **voiceover** narration stays ONE ElevenLabs `tts` read across the b-roll it plays over, and a **b-roll cutaway** between two on-camera moments leaves the presenter shot continuous — the shown scenes aren't adjacent (the insert sits between them), so the clip covers both on-camera windows (sliced as `s<i>_seg`, an ffmpeg `-ss`/`-t` cut — video+audio from the *same* clip so lip-sync holds) while the cutaway plays its own silent clip over the continuing voice. "Shown" is decided by the **presenter element's per-scene presence**, not just who's speaking — a scene where a cast member narrates over b-roll (their element absent) is a cutaway, so the talking head never appears where the original cut away. A single shot longer than the **gateway-safe ~10s clip ceiling** (Seedance's *API* max is 15s, but the gateway often times out — **HTTP 524** — past ~10s) **splits into contiguous takes joined by a shared boundary frame**; the spine then **seam-dedups** that duplicated frame so the concat doesn't freeze on it (`--seam-dedup head|tail|off`, default `head` = drop the second clip's first frame), and clone-pads one frame back so the drop never shortens the picture against the absolute-timed audio. Timbre stays consistent across all the separate shot clips because every clip's native audio is re-voiced in **one merged per-speaker pass** (not per clip). A b-roll cutaway *inside* a phrase lands at an **approximate** time (Seedance exposes no word timing) — nudge the scene boundary if it's off its beat.
+**One clip per shot — separated at complete breaks.** A video is a sequence of clear **shots** with **complete breaks** (hard cuts) between them, and that is what the scaffold separates by: **two adjacent presenter shots at a hard cut become TWO clips**, never glued into one invented take just because the speech runs continuously across the cut. Each presenter shot is one Seedance clip (`s<anchor>_clip`, native lip-sync + audio) re-voiced to the brand voice. What is **NOT** split: a **voiceover** narration stays ONE ElevenLabs `tts` read across the b-roll it plays over, and a **b-roll cutaway** between two on-camera moments leaves the presenter shot continuous — the shown scenes aren't adjacent (the insert sits between them), so the clip covers both on-camera windows (each on-camera window cut out of the clip inside the spine's per-input `trim=` chain — video+audio from the *same* clip so lip-sync holds, no extra nodes) while the cutaway plays its own silent clip over the continuing voice. "Shown" is decided by the **presenter element's per-scene presence**, not just who's speaking — a scene where a cast member narrates over b-roll (their element absent) is a cutaway, so the talking head never appears where the original cut away. A single shot longer than the **gateway-safe ~10s clip ceiling** (Seedance's *API* max is 15s, but the gateway often times out — **HTTP 524** — past ~10s) **splits into contiguous takes joined by a shared boundary frame**; the spine then **seam-dedups** that duplicated frame so the concat doesn't freeze on it (`--seam-dedup head|tail|off`, default `head` = drop the second clip's first frame), and clone-pads one frame back so the drop never shortens the picture against the absolute-timed audio. Timbre stays consistent across all the separate shot clips because every clip's native audio is re-voiced in **one merged per-speaker pass** (not per clip). A b-roll cutaway *inside* a phrase lands at an **approximate** time (Seedance exposes no word timing) — nudge the scene boundary if it's off its beat.
 
 **A starting point, not a locked render.** The canvas mirrors the reference's structure to give you a faithful scaffold, but `metadata.todo.full_flexibility` makes explicit that the agent has **full editing freedom**: add / delete / reorder / split / merge scenes, re-prompt any frame or motion brief, change a scene's layout (full-frame ↔ composite), or rewrite any line — the content-addressed cache re-bills only what changes, and `baker canvas validate` re-checks timing/lip-sync after any edit.
 
@@ -4092,7 +4102,7 @@ It then scaffolds the full pipeline like an **editing timeline**: each clip gets
 
 **Timing-faithful clip + extract (no overlap).** Each phrase clip is generated to its **coverage window** (the deconstruct's real scene/line timing, capped at the gateway-safe ~10s ceiling) and its converted voice is extracted to the **spoken window** (pause to pause) — *not* padded to a word-count estimate. Padding past the window was what ran the voice the clip's whole length and overlapped the next phrase; trusting the deconstruct's timing keeps consecutive phrases back-to-back and lets Seedance pace the quoted text to fit. `metadata.video.talking_scenes` records each phrase's `scene_s` vs `est_speech_s`; on top of that the scaffold flags any scene whose estimated speech overruns its window by more than ~1.3× as **`metadata.todo.overstuffed_scenes`** (also in the stdout checklist) — a loud advisory to shorten the copy or lengthen the scene before rendering, since an over-stuffed line pushes the picture off the audio timeline. It similarly flags **`oversize_scenes`** — a single scene whose own footage exceeds the gateway-safe ~10s clip ceiling (a b-roll shot or one-shot monologue). The phrase splitter only breaks at scene boundaries, so it can't shrink a single over-long scene; its clip would 524 at the gateway, so the advisory tells you to split that scene into two before rendering.
 
-**Timeline-accurate picture — ONE clock.** Seedance can't render under 4s, so each clip is generated at the smallest allowed duration ≥ the scene length and then **trimmed back to the exact scene duration** before concat. The spine is the ONE clock: every voice, SFX, music, and overlay placement is mapped onto where each scene's picture actually sits in the butted concat (not the reference video's own timestamps, which can carry dead air the picture doesn't reproduce), the audio mix's `total_ms` is pinned to the spine length, and every concat input is normalized to one raster clock (`yuv420p`, 30fps, square pixels, shared timebase) so a generated clip's unadvertised frame rate can never stretch the picture off the audio. The contract is stamped as `metadata.video.timeline` and `baker canvas validate` re-proves it from the live node params after any hand edit. Frames are also prompted as **clean text-free plates** (no baked captions/lower-thirds/tickers/logos-as-text) so the overlay layer is the single source of on-screen text.
+**Timeline-accurate picture — ONE clock.** Seedance can't render under 4s, so each clip is generated at the smallest allowed duration ≥ the scene length and **cut back to the exact scene duration inside the spine's own per-input filter chain** (no standalone trim nodes — one fewer re-encode per scene, and the graph stays a third smaller). Real screenshots/graphics loop fit-padded, generated stills loop fill-cropped, on the same chains. The spine is the ONE clock: every voice, SFX, music, and overlay placement is mapped onto where each scene's picture actually sits in the butted concat (not the reference video's own timestamps, which can carry dead air the picture doesn't reproduce), the audio mix's `total_ms` is pinned to the spine length, and every concat input is normalized to one raster clock (`yuv420p`, 30fps, square pixels, shared timebase) so a generated clip's unadvertised frame rate can never stretch the picture off the audio. The contract is stamped as `metadata.video.timeline` and `baker canvas validate` re-proves it from the live node params after any hand edit. Frames are also prompted as **clean text-free plates** (no baked captions/lower-thirds/tickers/logos-as-text) so the overlay layer is the single source of on-screen text.
 
 **Scene transitions.** When the deconstruct flags a boundary as `fade`/`whip`/`zoom`/`dissolve`/`swipe` (`scene.transition_out`), the spine reproduces it as an ffmpeg **`xfade`** instead of a hard cut; plain `cut`/`match_cut` stay hard cuts. The overlap is consumed from **extra generated footage** (each transitioning clip is trimmed to `scene_s + transition` and the xfade `offset` lands on the cumulative scene start), so the total length still equals the sum of the scene lengths — the picture stays exactly on the audio timeline.
 
@@ -4104,7 +4114,7 @@ It then scaffolds the full pipeline like an **editing timeline**: each clip gets
 
 **The inspiration video is preserved.** Like `scaffold-static-ad` keeps its reference image, the video command now auto-writes a **`_definition.md`** (so the creative joins the `creatives` collection) recording the source it was built from: `sourceKind: video`, `sourceAdvertiser` (the brand the deconstruct identified, or `--advertiser`), `platform` (`--platform`, default `meta`), and **`sourceReferenceUrl`** — the **durable, content-addressed R2 URL** the deconstruct already uploaded the source to (`prompt.json`'s `source.url`), which the dashboard's Inspiration card plays inline. Unlike the static flow it does **not** commit the video into `references/`: a reference clip can be up to 2 GiB and the video canvas never re-ingests the source at run time (it uses the extracted frame URLs), so a git copy would be pure bloat — the durable R2 URL is the reference. The `_definition.md` is preserved on re-scaffold, and the same `sourceReferenceUrl` is synced to the backend so the creative shows "built from this ad."
 
-The emitted canvas is validated (`validateCanvasDeep`) before it's written, so it always runs. It also carries a **`metadata.video`** timing plan that `baker canvas validate` proves **statically, before any billed render**: no two voiceover turns overlap, the audio length ≈ the video length, every single-on-camera-speaker scene is a native talking head (its clip carries `generate_audio` and is wired to an `audio_voice_convert` node), **no re-crafted line physically overruns its clip** (`VIDEO_SPEECH_OVERRUN`) **or its extract window** (`VIDEO_SPEECH_EXCEEDS_EXTRACT` — the spoken window is the real audio budget; a 3s line in a 1.2s window passes the clip check and then gets cut on the spine), and **every clip agrees on one aspect ratio** (`VIDEO_ASPECT_MISMATCH`). The one-clock contract is proven from the LIVE graph after any hand edit: `VIDEO_TIMELINE_TOTAL_MISMATCH` (picture vs pinned audio length — what `-shortest` would silently truncate), `VIDEO_NATIVE_SEG_OVERLAP` (two same-speaker voice windows playing at once — echo), plus advisories `VIDEO_SPINE_UNNORMALIZED` (bare concat inputs), `VIDEO_ODD_DIMENSIONS` (libx264-fatal odd sizes), `VIDEO_REGION_DROPPED` (billed region clips a composite never consumes), `VIDEO_OVERLAY_OUT_OF_BOUNDS` (an overlay window past the video end), and `VIDEO_PROMPT_PROFILE_MISSING` (a video model with no clip-prompt profile — prompts are authored per model family now: Seedance's [brackets] delivery cues vs Veo's prose + no-subtitles rule). When a **photoreal on-camera cast** generates on **Seedance**, the checklist carries a **`content_policy_risk`** note: ByteDance's real-person-likeness filter can reject a photoreal AI face with a **non-retryable 422** (`content_policy_blocked`) that **no prompt reframe clears** — the escapes are regenerating on Veo (`--video-model google/veo-3.1-fast`) or a less-photoreal frame. Surfaced before the billed run so a face-heavy ad isn't discovered broken mid-render. The full editable checklist is embedded as **`metadata.todo`** (with a step-by-step guide in `metadata.description`). The checklist also carries a **`prompt_discipline`** note steering the edit toward the six-decision prompt structure (Route / Spec / Beats / Copy / Technique / Negatives) and on-brand **motion** — easing, transition (cut vs fade), pacing, and accent pulled from `BRAND.md` § Brand in Motion so the overlays move like the client's brand, not the reference's. stdout returns `{ ok, canvas_path, prompt_path, models, stats, checklist }`.
+The emitted canvas is validated (`validateCanvasDeep`) before it's written, so it always runs. It also carries a **`metadata.video`** timing plan that `baker canvas validate` proves **statically, before any billed render**: no two voiceover turns overlap, the audio length ≈ the video length, every single-on-camera-speaker scene is a native talking head (its clip carries `generate_audio` and is wired to an `audio_voice_convert` node), **no re-crafted line physically overruns its clip** (`VIDEO_SPEECH_OVERRUN`) **or its extract window** (`VIDEO_SPEECH_EXCEEDS_EXTRACT` — the spoken window is the real audio budget; a 3s line in a 1.2s window passes the clip check and then gets cut on the spine), and **every clip agrees on one aspect ratio** (`VIDEO_ASPECT_MISMATCH`). The one-clock contract is proven from the LIVE graph after any hand edit: `VIDEO_TIMELINE_TOTAL_MISMATCH` (picture vs pinned audio length — what `-shortest` would silently truncate), `VIDEO_NATIVE_SEG_OVERLAP` (two same-speaker voice windows playing at once — echo), plus advisories `VIDEO_SPINE_UNNORMALIZED` (bare concat inputs), `VIDEO_ODD_DIMENSIONS` (libx264-fatal odd sizes), `VIDEO_REGION_DROPPED` (billed region clips a composite never consumes), `VIDEO_OVERLAY_OUT_OF_BOUNDS` (an overlay window past the video end), and `VIDEO_PROMPT_PROFILE_MISSING` (a video model with no clip-prompt profile — prompts are authored per model family now: Seedance's [brackets] delivery cues vs Veo's prose + no-subtitles rule). When a **photoreal on-camera cast** generates on **Seedance**, the checklist carries a **`content_policy_risk`** note: ByteDance's real-person-likeness filter can reject a photoreal AI face with a **non-retryable 422** (`content_policy_blocked`) that **no prompt reframe clears** — the escapes are regenerating on Veo (`--video-model google/veo-3.1-fast`) or a less-photoreal frame. Surfaced before the billed run so a face-heavy ad isn't discovered broken mid-render. The full editable checklist is embedded as **`metadata.todo`** (with a step-by-step guide in `metadata.description`). The checklist also carries a **`prompt_discipline`** note steering the edit toward the six-decision prompt structure (Route / Spec / Beats / Copy / Technique / Negatives) and on-brand **motion** — easing, transition (cut vs fade), pacing, and accent pulled from `BRAND.md` § Brand in Motion so the overlays move like the client's brand, not the reference's. A short (≤4s) b-roll take also skips its **end keyframe** (one billed image instead of two — over so short a span the second keyframe adds no motion guidance), unless the next scene continues the take and needs the shared splice frame. The canvas stamps **`metadata.video.graph_stats`** (node totals + histogram + one route per scene: `clip` / `still_hold` / `screen_still` / `graphic_plate` / `brand_card` / `phrase_slice` / `phrase_run` / `composite`) — the first thing to read when you wonder why the graph has a node — mirrored in stdout under `stats.graph`. `baker canvas validate` additionally warns `ORPHAN_NODE` on any non-ingest node unreachable from the output (it would execute — and bill — for nothing). stdout returns `{ ok, canvas_path, prompt_path, models, stats, checklist }`.
 
 ```bash
 baker canvas scaffold-video ./reference-ad.mp4 --focus "competitor UGC ad for <brand>"

package/dist/{chunk-J2LYFDVC.js → chunk-5LCTMZJ5.js}

@@ -1995,7 +1995,17 @@ var VideoMeta = z.object({
   // Per video_generate node: the scene's natural visual span. The validator warns
   // when a clip's span exceeds the assigned model's max clip duration (e.g. a 9.2s
   // scene on Veo, which caps at 8s) — the clip would truncate.
-  clip_spans: z.array(z.object({ node: z.string(), span_s: z.number() })).optional()
+  clip_spans: z.array(z.object({ node: z.string(), span_s: z.number() })).optional(),
+  // WHY the graph has the nodes it has: one route per scene (clip / still_hold /
+  // screen_still / graphic_plate / brand_card / phrase_slice / phrase_run /
+  // composite) + a node-type histogram, stamped by scaffold-video. Read this first
+  // when a canvas looks big.
+  graph_stats: z.object({
+    nodes_total: z.number(),
+    nodes_billable: z.number(),
+    node_types: z.record(z.string(), z.number()),
+    scene_routes: z.array(z.object({ scene: z.number(), route: z.string(), window_s: z.number() }))
+  }).strict().optional()
 }).strict().optional();
 var CanvasMetadata = z.object({
   name: z.string().optional(),
@@ -2519,6 +2529,41 @@ function imageProfileFor(modelId) {
   return void 0;
 }
 
+// src/engine/scaffold/spine-input.ts
+function spineInputFlags(work, lenS) {
+  return work.still ? ["-loop", "1", "-t", lenS.toFixed(3)] : [];
+}
+function spineInputOps(work, lenS, dims) {
+  const fit = work.still?.fit ?? "fill";
+  const scale = fit === "pad" ? `scale=${dims.w}:${dims.h}:force_original_aspect_ratio=decrease,pad=${dims.w}:${dims.h}:(ow-iw)/2:(oh-ih)/2:color=black` : `scale=${dims.w}:${dims.h}:force_original_aspect_ratio=increase,crop=${dims.w}:${dims.h}`;
+  const normalize = `${scale},format=yuv420p,fps=30,setsar=1,settb=AVTB`;
+  if (work.trim) {
+    const start = work.trim.offset_s > 0 ? `start=${work.trim.offset_s.toFixed(3)}:` : "";
+    return `${normalize},trim=${start}duration=${lenS.toFixed(3)},setpts=PTS-STARTPTS`;
+  }
+  if (work.still) return `${normalize},trim=duration=${lenS.toFixed(3)}`;
+  return normalize;
+}
+function parseSpineInputLens(args) {
+  const lens = /* @__PURE__ */ new Map();
+  let inputIndex = 0;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] !== "-i") continue;
+    if (args[i - 2] === "-t") {
+      const v = Number(args[i - 1]);
+      if (Number.isFinite(v)) lens.set(inputIndex, v);
+    }
+    inputIndex++;
+  }
+  const graph = args.join(" ");
+  for (const m of graph.matchAll(/\[(\d+):v\][^;[]*?trim=(?:start=[\d.]+:)?duration=([\d.]+)/g)) {
+    const idx = Number(m[1]);
+    const v = Number(m[2]);
+    if (Number.isFinite(idx) && Number.isFinite(v)) lens.set(idx, v);
+  }
+  return lens;
+}
+
 // src/engine/engine/define.ts
 function resolveOutputKinds(spec, params) {
   if (!spec) return {};
@@ -2614,7 +2659,8 @@ var STAGE_CODES = {
   SPINE_UNNORMALIZED: "VIDEO_SPINE_UNNORMALIZED",
   ODD_DIMENSIONS: "VIDEO_ODD_DIMENSIONS",
   REGION_DROPPED: "VIDEO_REGION_DROPPED",
-  OVERLAY_OUT_OF_BOUNDS: "VIDEO_OVERLAY_OUT_OF_BOUNDS"
+  OVERLAY_OUT_OF_BOUNDS: "VIDEO_OVERLAY_OUT_OF_BOUNDS",
+  ORPHAN_NODE: "ORPHAN_NODE"
 };
 var SPAN_MODEL_SLACK_S = 0.25;
 var VIDEO_TIME_SLACK_S = 0.75;
@@ -2678,6 +2724,7 @@ function validateCanvas(input, registry) {
   checkAllSlots(ctx);
   const estimatedCredits = estimateCredits(ctx);
   checkOutputRef(ctx);
+  checkOrphanNodes(ctx);
   checkVideoInvariants(ctx);
   const hasBlocking = issues.some(isBlocking);
   if (hasBlocking) return { ok: false, issues };
@@ -3207,8 +3254,11 @@ function spineTotalS(ctx, spine) {
   let total = 0;
   const inputs = Object.entries(spine.inputs ?? {}).filter(([k]) => /^c\d+$/.test(k));
   if (inputs.length === 0) return null;
-  for (const [, v] of inputs) {
-    const d = liveNodeDurationS(ctx, refNodeOf(ctx, v));
+  const rawArgs = spine.params.args;
+  const absorbed = Array.isArray(rawArgs) ? parseSpineInputLens(rawArgs.map(String)) : /* @__PURE__ */ new Map();
+  for (const [k, v] of inputs) {
+    const inputIdx = Number(k.slice(1));
+    const d = absorbed.get(inputIdx) ?? liveNodeDurationS(ctx, refNodeOf(ctx, v));
     if (d === null) return null;
     total += d;
   }
@@ -3550,6 +3600,28 @@ function checkAspectConsistency(ctx) {
     message: `video_generate nodes disagree on aspect_ratio (${[...ratios].sort().join(", ")}) \u2014 the spine's segments would render at different shapes and the composite silently crops. Pin every clip to the same aspect_ratio`
   });
 }
+function checkOrphanNodes(ctx) {
+  const out = ctx.canvas.output;
+  if (!out || !ctx.idToIndex.has(out.node)) return;
+  const graph = buildDepGraph(ctx.canvas);
+  const reachable = /* @__PURE__ */ new Set();
+  const stack = [out.node];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (id === void 0 || reachable.has(id)) continue;
+    reachable.add(id);
+    for (const dep of graph.get(id) ?? []) stack.push(dep);
+  }
+  for (const n of ctx.canvas.nodes) {
+    if (reachable.has(n.id) || n.type === "ingest") continue;
+    ctx.issues.push({
+      path: `nodes[${ctx.idToIndex.get(n.id)}]`,
+      code: STAGE_CODES.ORPHAN_NODE,
+      severity: "warning",
+      message: `node "${n.id}" (${n.type}) is not reachable from output "${out.node}" \u2014 it will still execute (and bill, if billable) but nothing consumes its result; wire it in or remove it`
+    });
+  }
+}
 function checkOutputRef(ctx) {
   const out = ctx.canvas.output;
   if (!out) return;
@@ -7610,6 +7682,8 @@ export {
   clipProfileFor,
   clipParamRecipe,
   imageProfileFor,
+  spineInputFlags,
+  spineInputOps,
   elementMentionKeywords,
   toModelSafeImage,
   BackendClient2,
@@ -7622,4 +7696,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-J2LYFDVC.js.map
+//# sourceMappingURL=chunk-5LCTMZJ5.js.map