@koda-sl/baker-cli 0.131.0-dev.cad5e0bc7 → 0.132.0-dev.cad5e0bc7

package/dist/cli.js

@@ -4926,11 +4926,11 @@ function rawTextEntries(value) {
   const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
   return values.filter((v) => typeof v === "string").flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path21) {
-  if (typeof path21 !== "string" || path21.length === 0) {
+function rawFileEntries(path23) {
+  if (typeof path23 !== "string" || path23.length === 0) {
     return [];
   }
-  return readFileSync2(path21, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync2(path23, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args) {
   const defaultMatch = typeof args["match-type"] === "string" ? args["match-type"].toUpperCase() : void 0;
@@ -4953,19 +4953,19 @@ function keywordEntries(args) {
   }
   return entries;
 }
-function loadJsonFileArg(path21) {
-  if (typeof path21 !== "string" || path21.length === 0) {
+function loadJsonFileArg(path23) {
+  if (typeof path23 !== "string" || path23.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync2(path21, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path23, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation(`${path21} must contain a JSON object`);
+      failWriteValidation(`${path23} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation(`${path21} is not valid JSON: ${err.message}`);
+      failWriteValidation(`${path23} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -5076,10 +5076,10 @@ async function stageUpdate(kind, customerId, target, payload) {
 async function stageTarget(kind, customerId, target) {
   await stageGoogleOp({ kind, customerId, target });
 }
-async function draftAction(path21, body) {
+async function draftAction(path23, body) {
   try {
     const chatId = requireChatId();
-    const response = await apiPost(path21, { chatId, ...body });
+    const response = await apiPost(path23, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -8834,19 +8834,19 @@ function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path21) {
-  if (typeof path21 !== "string" || path21.length === 0) {
+function loadJsonFileArg2(path23) {
+  if (typeof path23 !== "string" || path23.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path21, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path23, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation2(`${path21} must contain a JSON object`);
+      failWriteValidation2(`${path23} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation2(`${path21} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path23} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -8931,15 +8931,15 @@ function parseLocaleFlag(value) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path21) {
-  if (typeof path21 !== "string" || path21.length === 0) {
+function loadTargetingFileArg(path23) {
+  if (typeof path23 !== "string" || path23.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path21);
+  const parsed = loadJsonFileArg2(path23);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation2(
-      `${path21} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path23} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -8974,14 +8974,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell) => cell.trim());
 }
-function parseListFileArg(path21, maxRows) {
-  if (typeof path21 !== "string" || path21.length === 0) {
+function parseListFileArg(path23, maxRows) {
+  if (typeof path23 !== "string" || path23.length === 0) {
     return void 0;
   }
-  const raw = readFileSync6(path21, "utf8");
+  const raw = readFileSync6(path23, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation2(`${path21} needs a header row and at least one data row`);
+    failWriteValidation2(`${path23} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -9000,7 +9000,7 @@ function parseListFileArg(path21, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation2(`${path21} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path23} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -11083,11 +11083,11 @@ var updateStatusSchema = z11.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path21) {
+function validateDailyBudgetFloor(money, ctx, path23) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path21, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path23, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -11575,19 +11575,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg3(path21) {
-  if (typeof path21 !== "string" || path21.length === 0) {
+function loadJsonFileArg3(path23) {
+  if (typeof path23 !== "string" || path23.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path21, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path23, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path21} must contain a JSON object`);
+      failWriteValidation3(`${path23} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path21} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path23} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -14809,12 +14809,12 @@ async function probeDuration(filePath) {
 }
 
 // src/commands/canvas/rerun.ts
-import path11 from "path";
+import path13 from "path";
 import { defineCommand as defineCommand90 } from "citty";
 
 // src/commands/canvas/run.ts
-import { readFile as readFile7 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile9 } from "fs/promises";
+import path12 from "path";
 import { defineCommand as defineCommand89 } from "citty";
 
 // src/commands/canvas/placeholders.ts
@@ -14859,34 +14859,110 @@ function isResolvableRelative(value) {
 }
 
 // src/commands/canvas/source-version.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
+import path5 from "path";
+
+// src/commands/canvas/scene-files.ts
+import { mkdir, readFile as readFile3, readdir as readdir2, rm, writeFile } from "fs/promises";
 import path4 from "path";
+var SCENES_DIR = "scenes";
+var GLOBAL_PROMPT_FILE = "prompt.json";
+var REBUILD_FILE = "prompt.rebuild.json";
+function sceneFileName(index, total) {
+  const width = Math.max(2, String(Math.max(0, total - 1)).length);
+  return `s${String(index).padStart(width, "0")}.json`;
+}
+function splitBlueprint(blueprint) {
+  if (!blueprint || typeof blueprint !== "object") {
+    return { global: {}, scenes: [] };
+  }
+  const { scenes, ...global } = blueprint;
+  return { global, scenes: Array.isArray(scenes) ? scenes : [] };
+}
+async function writeSceneFiles(outDir, blueprint) {
+  const { global, scenes } = splitBlueprint(blueprint);
+  await writeFile(path4.join(outDir, GLOBAL_PROMPT_FILE), `${JSON.stringify(global, null, 2)}
+`, "utf8");
+  const scenesDir = path4.join(outDir, SCENES_DIR);
+  await mkdir(scenesDir, { recursive: true });
+  const written = /* @__PURE__ */ new Set();
+  for (let i = 0; i < scenes.length; i++) {
+    const name = sceneFileName(i, scenes.length);
+    written.add(name);
+    await writeFile(path4.join(scenesDir, name), `${JSON.stringify(scenes[i], null, 2)}
+`, "utf8");
+  }
+  for (const name of await listSceneFileNames(scenesDir)) {
+    if (!written.has(name)) await rm(path4.join(scenesDir, name), { force: true });
+  }
+}
+async function listSceneFileNames(scenesDir) {
+  let entries;
+  try {
+    entries = await readdir2(scenesDir);
+  } catch {
+    return [];
+  }
+  return entries.filter((n) => /^s\d+\.json$/.test(n)).sort(bySceneIndex);
+}
+async function listSceneFiles(creativeDir) {
+  const scenesDir = path4.join(creativeDir, SCENES_DIR);
+  return (await listSceneFileNames(scenesDir)).map((n) => path4.join(scenesDir, n));
+}
+async function reassembleBlueprint(creativeDir) {
+  const files = await listSceneFiles(creativeDir);
+  if (files.length === 0) return null;
+  const globalRaw = await readFile3(path4.join(creativeDir, GLOBAL_PROMPT_FILE), "utf8");
+  const global = JSON.parse(globalRaw);
+  const scenes = [];
+  for (const file of files) {
+    scenes.push(JSON.parse(await readFile3(file, "utf8")));
+  }
+  return { ...global, scenes };
+}
+function bySceneIndex(a, b) {
+  const ai = Number(a.match(/^s(\d+)\.json$/)?.[1] ?? 0);
+  const bi = Number(b.match(/^s(\d+)\.json$/)?.[1] ?? 0);
+  return ai - bi;
+}
+
+// src/commands/canvas/source-version.ts
 async function computeSourceSha(canvasPath) {
   let canvasBytes;
   try {
-    canvasBytes = await readFile3(canvasPath);
+    canvasBytes = await readFile4(canvasPath);
   } catch {
     return void 0;
   }
-  const promptPath = path4.join(path4.dirname(canvasPath), "prompt.json");
+  const canvasDir = path5.dirname(canvasPath);
+  const promptPath = path5.join(canvasDir, "prompt.json");
   let promptBytes;
   try {
-    promptBytes = await readFile3(promptPath);
+    promptBytes = await readFile4(promptPath);
   } catch {
     promptBytes = Buffer.alloc(0);
   }
-  return sha256Hex(
-    Buffer.concat([
-      Buffer.from(`${canvasBytes.length}\0`),
-      canvasBytes,
-      Buffer.from(`${promptBytes.length}\0`),
-      promptBytes
-    ])
-  );
+  const parts = [
+    Buffer.from(`${canvasBytes.length}\0`),
+    canvasBytes,
+    Buffer.from(`${promptBytes.length}\0`),
+    promptBytes
+  ];
+  for (const sceneFile of await listSceneFiles(canvasDir)) {
+    let sceneBytes;
+    try {
+      sceneBytes = await readFile4(sceneFile);
+    } catch {
+      sceneBytes = Buffer.alloc(0);
+    }
+    parts.push(Buffer.from(`${sceneBytes.length}\0`), sceneBytes);
+  }
+  return sha256Hex(Buffer.concat(parts));
 }
 
-// src/commands/canvas/style-projection.ts
-import { readFile as readFile4, writeFile } from "fs/promises";
+// src/commands/canvas/scene-projection.ts
+import { readFile as readFile5 } from "fs/promises";
+import path6 from "path";
 
 // src/engine/scaffold/video.ts
 import { toCardinal as nwAr } from "n2words/ar-SA";
@@ -16902,6 +16978,14 @@ function emitPhraseClip(phrase, voiceNode, env, nodes, out) {
   });
   registerMergedPhraseSlices(phrase, clipRef, clipStart, genDur, Boolean(chained), env, out);
 }
+function sumSceneDurations(env, first, last) {
+  let total = 0;
+  for (let s = first; s <= last; s++) {
+    const sc = env.blueprint.scenes[s];
+    if (sc) total += sceneDurationS(sc);
+  }
+  return total;
+}
 function registerMergedPhraseSlices(phrase, clipRef, clipStart, genDur, chained, env, out) {
   const shown = [...phrase.shownScenes].sort((a, b) => a - b);
   let r = 0;
@@ -16915,13 +16999,12 @@ function registerMergedPhraseSlices(phrase, clipRef, clipStart, genDur, chained,
     if (!firstSc) continue;
     const firstStart = firstSc.start_s ?? clipStart;
     const rawOffset = firstStart - clipStart;
-    const runEnd = env.blueprint.scenes[last]?.end_s ?? firstStart + sceneDurationS(firstSc);
     out.sceneSlice.set(first, {
       clipRef,
       // Snap a sub-frame offset (line-start vs scene-start drift) to 0 so a run that tiles
       // the clip hits the whole-clip fast path instead of a needless re-encode + tiny shift.
       offset: rawOffset < 0.05 ? 0 : rawOffset,
-      len: Math.max(0.5, runEnd - firstStart),
+      len: Math.max(0.5, sumSceneDurations(env, first, last)),
       clipDur: genDur,
       ...firstRegistered && chained ? { continuesFrame: true } : {}
     });
@@ -18114,7 +18197,75 @@ function videoReport(input, elementsInput) {
   };
 }
 
+// src/commands/canvas/scene-projection.ts
+var PROMPT_NODE_TYPES = /* @__PURE__ */ new Set(["image_generate", "video_generate"]);
+function promptNodes(canvas) {
+  const out = /* @__PURE__ */ new Map();
+  const nodes = canvas?.nodes;
+  if (!Array.isArray(nodes)) return out;
+  for (const n of nodes) {
+    if (typeof n?.id === "string" && typeof n?.type === "string" && PROMPT_NODE_TYPES.has(n.type)) {
+      out.set(n.id, n);
+    }
+  }
+  return out;
+}
+function nonPromptParamsDiverge(live = {}, rebuilt = {}) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(live), ...Object.keys(rebuilt)]);
+  keys.delete("prompt");
+  for (const k of keys) {
+    if (JSON.stringify(live[k]) !== JSON.stringify(rebuilt[k])) return true;
+  }
+  return false;
+}
+async function syncSceneNodeParams(canvas, canvasPath, log) {
+  const creativeDir = path6.dirname(canvasPath);
+  const blueprint = await reassembleBlueprint(creativeDir);
+  if (!blueprint) return "not_applicable";
+  let rebuildRaw;
+  try {
+    rebuildRaw = await readFile5(path6.join(creativeDir, REBUILD_FILE), "utf8");
+  } catch {
+    return "not_applicable";
+  }
+  const { elements, opts } = JSON.parse(rebuildRaw);
+  const rebuilt = scaffoldVideoCanvas(blueprint, elements, opts);
+  const rebuiltNodes = promptNodes(rebuilt);
+  const liveNodes = promptNodes(canvas);
+  const missingInLive = [...rebuiltNodes.keys()].filter((id) => !liveNodes.has(id));
+  const missingInRebuilt = [...liveNodes.keys()].filter((id) => !rebuiltNodes.has(id));
+  if (missingInLive.length > 0 || missingInRebuilt.length > 0) {
+    log(
+      "[scenes] scene structure changed since scaffold (a scene's route, timing, or count differs) \u2014 re-run `baker canvas scaffold-video` to rebuild the graph. Prompt-only edits were still applied where the nodes still match."
+    );
+  }
+  let changed = 0;
+  let structural = false;
+  for (const [id, rebuiltNode] of rebuiltNodes) {
+    const live = liveNodes.get(id);
+    if (!live) continue;
+    const liveParams = live.params ??= {};
+    const rebuiltParams = rebuiltNode.params ?? {};
+    if (nonPromptParamsDiverge(liveParams, rebuiltParams)) structural = true;
+    if (typeof rebuiltParams.prompt === "string" && liveParams.prompt !== rebuiltParams.prompt) {
+      liveParams.prompt = rebuiltParams.prompt;
+      changed++;
+    }
+  }
+  if (structural) {
+    log(
+      "[scenes] a scene edit changed clip timing or audio (not just prompt text) \u2014 the graph's timing nodes were NOT updated; re-run `baker canvas scaffold-video` so the spine and voice tracks match."
+    );
+  }
+  if (changed === 0) return "up_to_date";
+  log(
+    `[scenes] re-flowed ${changed} scene prompt(s) from scenes/*.json into the graph \u2014 the affected frames/clips will re-bill on the next run`
+  );
+  return "regenerated";
+}
+
 // src/commands/canvas/style-projection.ts
+import { readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
 function findBlueprintProjection(canvas) {
   if (!canvas || typeof canvas !== "object") return null;
   const nodes = canvas.nodes;
@@ -18142,10 +18293,10 @@ function renderStyleProjectionFromValue(blueprint) {
 async function syncStyleProjection(canvas, log) {
   const pair = findBlueprintProjection(canvas);
   if (!pair) return "not_applicable";
-  const rendered = renderStyleProjection(await readFile4(pair.promptPath, "utf8"));
-  const current = await readFile4(pair.stylePath, "utf8").catch(() => null);
+  const rendered = renderStyleProjection(await readFile6(pair.promptPath, "utf8"));
+  const current = await readFile6(pair.stylePath, "utf8").catch(() => null);
   if (current === rendered) return "up_to_date";
-  await writeFile(pair.stylePath, rendered, "utf8");
+  await writeFile2(pair.stylePath, rendered, "utf8");
   log(
     "[style] prompt.style.json regenerated from prompt.json \u2014 every frame's shared ad spec changed; affected image frames will re-bill on the next run"
   );
@@ -18205,13 +18356,13 @@ ${body}` : header || body || compactJson(record);
 }
 
 // src/commands/canvas/run-record.ts
-import path5 from "path";
+import path7 from "path";
 var MAX_RUN_NODES = 200;
 var MAX_OUTPUTS_PER_NODE = 10;
 var MAX_FINAL_OUTPUTS = 10;
 var MAX_CREATIVE_SLUG_LENGTH = 100;
 function creativeSlugFromCanvasPath(filePath) {
-  const normalized = filePath.split(path5.sep).join("/");
+  const normalized = filePath.split(path7.sep).join("/");
   const match = normalized.match(/(?:^|\/)src\/creatives\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\//);
   const slug = match?.[1] ?? null;
   return slug && slug.length <= MAX_CREATIVE_SLUG_LENGTH ? slug : null;
@@ -18495,25 +18646,25 @@ var RunRecordPoster = class {
 };
 
 // src/commands/canvas/run-retention.ts
-import { rm } from "fs/promises";
-import path6 from "path";
+import { rm as rm2 } from "fs/promises";
+import path8 from "path";
 function runDirsToPrune(entries, keep, currentRunId) {
   const runs = entries.filter((e) => /^r_[0-9A-Za-z]+$/.test(e) && e !== currentRunId).sort();
   if (keep <= 0) return runs;
   return runs.slice(0, Math.max(0, runs.length - keep));
 }
 async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
-  const { readdir: readdir6 } = await import("fs/promises");
+  const { readdir: readdir7 } = await import("fs/promises");
   let entries;
   try {
-    entries = await readdir6(outputsDir);
+    entries = await readdir7(outputsDir);
   } catch {
     return;
   }
   const toPrune = runDirsToPrune(entries, keep, currentRunId);
   if (toPrune.length === 0) return;
   for (const dir of toPrune) {
-    await rm(path6.join(outputsDir, dir), { recursive: true, force: true }).catch(
+    await rm2(path8.join(outputsDir, dir), { recursive: true, force: true }).catch(
       (e) => log(`[prune   ] could not remove ${dir}: ${e.message}`)
     );
   }
@@ -18521,34 +18672,34 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
 }
 
 // src/commands/canvas/dirty-marker.ts
-import { mkdir, readdir as readdir2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
+import { mkdir as mkdir2, readdir as readdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import path9 from "path";
 function creativeDirtyDir(base) {
-  return base ?? path7.resolve("canvas", ".dirty");
+  return base ?? path9.resolve("canvas", ".dirty");
 }
 function dirtyMarkerFile(slug, base) {
-  return path7.join(creativeDirtyDir(base), `${slug}.json`);
+  return path9.join(creativeDirtyDir(base), `${slug}.json`);
 }
 async function clearCreativeDirty(slug, base) {
   try {
-    await rm2(dirtyMarkerFile(slug, base), { force: true });
+    await rm3(dirtyMarkerFile(slug, base), { force: true });
   } catch {
   }
 }
 
 // src/commands/canvas/run-resume.ts
-import { mkdir as mkdir2, readFile as readFile5, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import path8 from "path";
+import { mkdir as mkdir3, readFile as readFile7, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import path10 from "path";
 function markerKey(canvasPath) {
   const slug = creativeSlugFromCanvasPath(canvasPath);
-  const identity2 = slug ?? path8.relative(process.cwd(), path8.resolve(canvasPath));
+  const identity2 = slug ?? path10.relative(process.cwd(), path10.resolve(canvasPath));
   return sha256Hex(Buffer.from(identity2)).slice(0, 32);
 }
 function legacyMarkerKey(canvasPath) {
-  return sha256Hex(Buffer.from(path8.resolve(canvasPath))).slice(0, 32);
+  return sha256Hex(Buffer.from(path10.resolve(canvasPath))).slice(0, 32);
 }
 function markerFile(outputsDir, key) {
-  return path8.join(outputsDir, ".inflight", `${key}.json`);
+  return path10.join(outputsDir, ".inflight", `${key}.json`);
 }
 var REMOTE_ADOPT_STALE_MS = 12e4;
 function classifyRemoteRun(run, now) {
@@ -18584,7 +18735,7 @@ async function resolveRunId(opts) {
 async function readMarkerRunId(outputsDir, canvasPath) {
   for (const key of [markerKey(canvasPath), legacyMarkerKey(canvasPath)]) {
     try {
-      const raw = await readFile5(markerFile(outputsDir, key), "utf8");
+      const raw = await readFile7(markerFile(outputsDir, key), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.runId === "string" && parsed.runId.length > 0) return parsed.runId;
     } catch {
@@ -18595,23 +18746,23 @@ async function readMarkerRunId(outputsDir, canvasPath) {
 async function markRunInFlight(outputsDir, canvasPath, runId) {
   try {
     const file = markerFile(outputsDir, markerKey(canvasPath));
-    await mkdir2(path8.dirname(file), { recursive: true });
-    await writeFile3(file, JSON.stringify({ runId, canvasPath: path8.resolve(canvasPath), startedAt: Date.now() }));
+    await mkdir3(path10.dirname(file), { recursive: true });
+    await writeFile4(file, JSON.stringify({ runId, canvasPath: path10.resolve(canvasPath), startedAt: Date.now() }));
   } catch {
   }
 }
 async function clearRunMarker(outputsDir, canvasPath) {
   for (const key of [markerKey(canvasPath), legacyMarkerKey(canvasPath)]) {
     try {
-      await rm3(markerFile(outputsDir, key), { force: true });
+      await rm4(markerFile(outputsDir, key), { force: true });
     } catch {
     }
   }
 }
 
 // src/commands/canvas/run-snapshot.ts
-import { mkdir as mkdir3, readdir as readdir3, readFile as readFile6, stat as stat2, writeFile as writeFile4 } from "fs/promises";
-import path9 from "path";
+import { mkdir as mkdir4, readdir as readdir4, readFile as readFile8, stat as stat2, writeFile as writeFile5 } from "fs/promises";
+import path11 from "path";
 var SNAPSHOT_SCHEMA = "baker-canvas-snapshot/1";
 var MAX_SNAPSHOT_FILE_BYTES = 32 * 1024 * 1024;
 var EXT_TO_MIME = {
@@ -18638,11 +18789,11 @@ var EXT_TO_MIME = {
   woff2: "font/woff2"
 };
 function mimeForFile(filePath) {
-  const ext = path9.extname(filePath).slice(1).toLowerCase();
+  const ext = path11.extname(filePath).slice(1).toLowerCase();
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
 function toPosix(p) {
-  return p.split(path9.sep).join("/");
+  return p.split(path11.sep).join("/");
 }
 function localPathRefsFromCanvas(parsed) {
   const nodes = parsed?.nodes;
@@ -18664,32 +18815,40 @@ function localPathRefsFromCanvas(parsed) {
 function isSnapshotablePath(value) {
   return typeof value === "string" && value.length > 0 && !value.includes("[TODO");
 }
+async function sourceRefsToSnapshot(canvasDir, parsed) {
+  const refs = new Set(localPathRefsFromCanvas(parsed));
+  for (const sceneFile of await listSceneFiles(canvasDir)) {
+    refs.add(toPosix(path11.relative(canvasDir, sceneFile)));
+  }
+  refs.add(REBUILD_FILE);
+  return [...refs];
+}
 async function uploadRunSnapshot(client, opts) {
   try {
-    const canvasDir = path9.dirname(opts.canvasPath);
+    const canvasDir = path11.dirname(opts.canvasPath);
     const put = (bytes, mime) => putContentAddressed(client, bytes, mime, opts.signal);
     const canvasBytes = Buffer.from(opts.raw);
     const canvasUpload = await put(canvasBytes, "application/json");
     const files = [];
     const skipped = [];
-    for (const refPath of localPathRefsFromCanvas(opts.parsed)) {
-      const abs = path9.isAbsolute(refPath) ? refPath : path9.resolve(canvasDir, refPath);
+    for (const refPath of await sourceRefsToSnapshot(canvasDir, opts.parsed)) {
+      const abs = path11.isAbsolute(refPath) ? refPath : path11.resolve(canvasDir, refPath);
       let st;
       try {
         st = await stat2(abs);
       } catch {
-        skipped.push({ path: toPosix(path9.relative(canvasDir, abs)), reason: "missing" });
+        skipped.push({ path: toPosix(path11.relative(canvasDir, abs)), reason: "missing" });
         continue;
       }
       const fileList = st.isDirectory() ? await listFilesRecursive(abs) : [abs];
       for (const file of fileList) {
-        const rel = toPosix(path9.relative(canvasDir, file));
+        const rel = toPosix(path11.relative(canvasDir, file));
         const size = (await stat2(file)).size;
         if (size > MAX_SNAPSHOT_FILE_BYTES) {
           skipped.push({ path: rel, reason: `too large (${size} bytes)` });
           continue;
         }
-        const bytes = await readFile6(file);
+        const bytes = await readFile8(file);
         const upload = await put(bytes, mimeForFile(file));
         files.push({ path: rel, sha256: upload.sha256, url: upload.url });
       }
@@ -18698,7 +18857,7 @@ async function uploadRunSnapshot(client, opts) {
       schema: SNAPSHOT_SCHEMA,
       creativeSlug: opts.creativeSlug,
       canvasSha: canvasUpload.sha256,
-      canvas: { path: path9.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
+      canvas: { path: path11.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
       files,
       skipped: skipped.length > 0 ? skipped : void 0
     };
@@ -18724,8 +18883,8 @@ async function putContentAddressed(client, bytes, mime, signal) {
   return { sha256, url: publicUrl };
 }
 async function listFilesRecursive(dir) {
-  const entries = await readdir3(dir, { recursive: true, withFileTypes: true });
-  return entries.filter((d) => d.isFile()).map((d) => path9.join(d.parentPath, d.name));
+  const entries = await readdir4(dir, { recursive: true, withFileTypes: true });
+  return entries.filter((d) => d.isFile()).map((d) => path11.join(d.parentPath, d.name));
 }
 var SnapshotConflictError = class extends Error {
   conflicts;
@@ -18737,19 +18896,19 @@ var SnapshotConflictError = class extends Error {
 };
 async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
   const entries = [manifest.canvas, ...manifest.files];
-  const resolvedTarget = path9.resolve(targetDir);
+  const resolvedTarget = path11.resolve(targetDir);
   const planned = [];
   const conflicts = [];
   const upToDate = [];
   for (const entry of entries) {
-    if (path9.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
+    if (path11.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const target = path9.resolve(resolvedTarget, entry.path);
-    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path9.sep)) {
+    const target = path11.resolve(resolvedTarget, entry.path);
+    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path11.sep)) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const existing = await readFile6(target).catch(() => null);
+    const existing = await readFile8(target).catch(() => null);
     if (existing) {
       if (sha256Hex(existing) === entry.sha256) {
         upToDate.push(entry.path);
@@ -18771,11 +18930,11 @@ async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
     if (sha256Hex(bytes) !== entry.sha256) {
       throw new Error(`snapshot download for ${entry.path} does not match its recorded sha256`);
     }
-    await mkdir3(path9.dirname(target), { recursive: true });
-    await writeFile4(target, bytes);
+    await mkdir4(path11.dirname(target), { recursive: true });
+    await writeFile5(target, bytes);
     restored.push(entry.path);
   }
-  return { canvasPath: path9.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
+  return { canvasPath: path11.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
 }
 
 // src/commands/canvas/run.ts
@@ -18855,8 +19014,8 @@ function resolveMaxCredits(...candidates) {
   return void 0;
 }
 async function executeCanvasRun(opts) {
-  const filePath = path10.resolve(opts.file);
-  const raw = await readFile7(filePath, "utf8");
+  const filePath = path12.resolve(opts.file);
+  const raw = await readFile9(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -18868,7 +19027,7 @@ async function executeCanvasRun(opts) {
   }
   const attemptedSlug = creativeSlugFromCanvasPath(filePath);
   if (attemptedSlug) await clearCreativeDirty(attemptedSlug);
-  parsed = resolveRelativeCanvasPaths(parsed, path10.dirname(filePath));
+  parsed = resolveRelativeCanvasPaths(parsed, path12.dirname(filePath));
   try {
     await syncStyleProjection(parsed, (line) => process.stderr.write(`${line}
 `));
@@ -18883,6 +19042,24 @@ async function executeCanvasRun(opts) {
         null,
         2
       )}
+`
+    );
+    process.exit(2);
+  }
+  try {
+    await syncSceneNodeParams(parsed, filePath, (line) => process.stderr.write(`${line}
+`));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(
+      `${JSON.stringify(
+        {
+          ok: false,
+          error: { code: "scene_projection", message: `a scenes/*.json file is not readable/valid or its rebuild failed: ${msg}` }
+        },
+        null,
+        2
+      )}
 `
     );
     process.exit(2);
@@ -18952,7 +19129,7 @@ async function executeCanvasRun(opts) {
   const canvasSha = sha256Hex(Buffer.from(raw));
   const creativeSlug = creativeSlugFromCanvasPath(filePath) ?? void 0;
   const client = opts.record === false ? null : buildBackendClient();
-  const outputsDir = opts.outputsDir ? path10.resolve(opts.outputsDir) : path10.resolve("canvas");
+  const outputsDir = opts.outputsDir ? path12.resolve(opts.outputsDir) : path12.resolve("canvas");
   const { runId, resumed, source, concurrentRunId } = await resolveRunId({
     explicitRunId: opts.runId,
     fresh: opts.fresh === true,
@@ -18986,7 +19163,7 @@ async function executeCanvasRun(opts) {
   const canvasSnapshotUrl = client && creativeSlug ? await uploadRunSnapshot(client, { canvasPath: filePath, raw, creativeSlug, parsed }) ?? void 0 : void 0;
   const recordMeta = {
     creativeSlug,
-    canvasPath: path10.relative(process.cwd(), filePath) || void 0,
+    canvasPath: path12.relative(process.cwd(), filePath) || void 0,
     canvasSha,
     // The fingerprint the dashboard compares against the current source to flag
     // "edited since last render". Computed from the on-disk canvas.json +
@@ -19173,7 +19350,7 @@ var rerunCommand = defineCommand90({
     if (latest.canvasSha && manifest.canvasSha !== latest.canvasSha) {
       fail("snapshot_mismatch", `snapshot manifest for run ${latest.runId} does not match its recorded canvas sha`);
     }
-    const targetDir = path11.resolve("src", "creatives", slug);
+    const targetDir = path13.resolve("src", "creatives", slug);
     let restoredCanvasPath;
     try {
       const restore = await restoreRunSnapshot(manifest, targetDir, { force: args["force-remote"] === true });
@@ -19222,8 +19399,8 @@ async function fetchManifest(url) {
 }
 
 // src/commands/canvas/scaffold-static-ad.ts
-import { access, mkdir as mkdir4, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
-import path15 from "path";
+import { access, mkdir as mkdir5, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import path17 from "path";
 import { defineCommand as defineCommand92 } from "citty";
 
 // src/engine/scaffold/staticAd.ts
@@ -19467,7 +19644,7 @@ function staticAdReport(input, elementsInput, opts) {
 }
 
 // src/commands/canvas/creative-definition.ts
-import path12 from "path";
+import path14 from "path";
 var PLATFORM_VALUES = ["meta", "google", "linkedin", "tiktok", "youtube", "x", "other"];
 var FORMAT_VALUES = ["1:1", "4:5", "9:16", "16:9", "1.91:1"];
 function titleFromSlug(slug) {
@@ -19509,16 +19686,16 @@ function buildCreativeDefinition(input) {
 }
 
 // src/commands/canvas/scaffold-static-ad-paths.ts
-import path13 from "path";
+import path15 from "path";
 function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
   const file = rawFile.trim();
   const imageIsUrl = /^https?:\/\//i.test(file);
-  const imageSource = imageIsUrl ? file : path13.resolve(cwd, file);
-  const outPath = out ? path13.resolve(cwd, out) : slug ? path13.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path13.join(cwd, "static-ad.canvas.json") : path13.join(path13.dirname(imageSource), "static-ad.canvas.json");
-  const blueprintPath = path13.join(path13.dirname(outPath), "prompt.json");
-  const creativeDir = slug ? path13.dirname(outPath) : null;
-  const definitionPath = creativeDir ? path13.join(creativeDir, "_definition.md") : null;
-  const referencesDir = creativeDir ? path13.join(creativeDir, "references") : null;
+  const imageSource = imageIsUrl ? file : path15.resolve(cwd, file);
+  const outPath = out ? path15.resolve(cwd, out) : slug ? path15.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path15.join(cwd, "static-ad.canvas.json") : path15.join(path15.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath = path15.join(path15.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path15.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path15.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path15.join(creativeDir, "references") : null;
   return { imageIsUrl, imageSource, outPath, blueprintPath, creativeDir, definitionPath, referencesDir };
 }
 var SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
@@ -19528,8 +19705,8 @@ function isValidScaffoldSlug(slug) {
 }
 
 // src/commands/canvas/sync-definition.ts
-import { readdir as readdir4, readFile as readFile8, stat as stat3 } from "fs/promises";
-import path14 from "path";
+import { readdir as readdir5, readFile as readFile10, stat as stat3 } from "fs/promises";
+import path16 from "path";
 import { defineCommand as defineCommand91 } from "citty";
 
 // src/commands/canvas/definition-graph.ts
@@ -19622,26 +19799,26 @@ async function syncCreativeDefinitionBestEffort(input) {
   }
 }
 async function resolveCanvasPath(inputPath) {
-  const resolved = path14.resolve(inputPath);
+  const resolved = path16.resolve(inputPath);
   let dir = resolved;
   try {
     if ((await stat3(resolved)).isFile()) {
       if (resolved.endsWith(".canvas.json")) return resolved;
-      dir = path14.dirname(resolved);
+      dir = path16.dirname(resolved);
     }
   } catch {
-    dir = resolved.endsWith(".canvas.json") ? path14.dirname(resolved) : resolved;
+    dir = resolved.endsWith(".canvas.json") ? path16.dirname(resolved) : resolved;
   }
   let entries;
   try {
-    entries = await readdir4(dir);
+    entries = await readdir5(dir);
   } catch {
     return null;
   }
   const canvases = entries.filter((name) => name.endsWith(".canvas.json"));
   const slug = creativeSlugFromCanvasPath(`${dir}/x/`);
   const chosen = (slug ? canvases.find((name) => name === `${slug}.canvas.json`) : void 0) ?? canvases[0];
-  return chosen ? path14.join(dir, chosen) : null;
+  return chosen ? path16.join(dir, chosen) : null;
 }
 var syncDefinitionCommand = defineCommand91({
   meta: {
@@ -19664,7 +19841,7 @@ var syncDefinitionCommand = defineCommand91({
     if (!slug) return;
     let canvas;
     try {
-      canvas = JSON.parse(await readFile8(canvasPath, "utf8"));
+      canvas = JSON.parse(await readFile10(canvasPath, "utf8"));
     } catch {
       return;
     }
@@ -19689,7 +19866,7 @@ async function uploadSourceAsReference(source, isUrl, client) {
     if (!res.ok) throw new Error(`failed to download source image (${res.status})`);
     bytes = Buffer.from(await res.arrayBuffer());
   } else {
-    bytes = await readFile9(source);
+    bytes = await readFile11(source);
   }
   const safe = await toModelSafeImage(bytes);
   const sha256 = sha256Hex(safe.bytes);
@@ -19744,7 +19921,7 @@ DROP background extras, decorative props, generic scenery, and anything small or
 For each kept element return: { "type": one of logo|product|person|animal|badge, "label": a short UPPER_SNAKE_CASE name (e.g. LOGO, PRODUCT, HERO_DOG, TRUSTPILOT), "description": a concrete reusable description to source/shoot the real asset (include the exact expression for a living subject, and its castable attributes \u2014 breed/species for an animal, apparent age band, apparent origin/ethnicity, and wardrobe/setting for a person \u2014 so it can be recast to fit OUR audience/market), "expression": the facial expression for a living subject or null, "reason": why it is identity-critical, "locator": the blueprint entry this element came from as { "collection": one of "subjects" | "people" | "brands_logos", "index": its 0-based position in that array } (people -> people; logos/badges -> brands_logos; products/animals/objects -> subjects). Output ONLY the JSON object.`;
 async function loadAssetText(ref, label) {
   const r = ref;
-  if (typeof r?.path === "string") return readFile9(r.path, "utf8");
+  if (typeof r?.path === "string") return readFile11(r.path, "utf8");
   if (typeof r?.url === "string") {
     const res = await fetch(r.url);
     if (!res.ok) throw new Error(`failed to fetch ${label} (${res.status})`);
@@ -19897,7 +20074,7 @@ var scaffoldStaticAdCommand = defineCommand92({
       process.cwd(),
       slug
     );
-    await mkdir4(path15.dirname(outPath), { recursive: true });
+    await mkdir5(path17.dirname(outPath), { recursive: true });
     const { describeModel, selectModel, layoutModel, genModel } = resolveModels(args);
     let durableSourceUrl;
     if (referencesDir) {
@@ -19923,7 +20100,7 @@ var scaffoldStaticAdCommand = defineCommand92({
     if (layout && annotated && typeof annotated === "object") {
       annotated.layout = layout;
     }
-    await writeFile5(blueprintPath, `${JSON.stringify(annotated, null, 2)}
+    await writeFile6(blueprintPath, `${JSON.stringify(annotated, null, 2)}
 `, "utf8");
     let canvasImagePath = imageSource;
     let canvasImageIsUrl = imageIsUrl;
@@ -19960,10 +20137,10 @@ var scaffoldStaticAdCommand = defineCommand92({
       );
       process.exit(2);
     }
-    await writeFile5(outPath, `${JSON.stringify(canvas, null, 2)}
+    await writeFile6(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
     if (definitionPath && !await fileExists(definitionPath)) {
-      await writeFile5(
+      await writeFile6(
         definitionPath,
         buildCreativeDefinition({
           title: args.title ? String(args.title) : titleFromSlug(slug ?? ""),
@@ -20007,7 +20184,7 @@ var scaffoldStaticAdCommand = defineCommand92({
             run_estimated_credits: validation.estimatedCredits
           },
           checklist: {
-            edit_prompt: `Edit ${path15.basename(blueprintPath)} \u2014 it is the blueprint generated from your image; rewrite it into the ad you want (palette, copy, claims, subjects). It feeds the generator directly.`,
+            edit_prompt: `Edit ${path17.basename(blueprintPath)} \u2014 it is the blueprint generated from your image; rewrite it into the ad you want (palette, copy, claims, subjects). It feeds the generator directly.`,
             assets_to_supply: report.elements,
             font_slot: report.includes_font ? "Drop a brand font at the [TODO] brandfont path (the describe pass recorded the ad's typefaces under `fonts` in prompt.json \u2014 match those). The font is wired into the render as a TYPE SPECIMEN reference so generated text takes the brand letterforms. Delete the brandfont + type_ref nodes to skip it." : "skipped (--skip-font)",
             actor_sheets: report.actor_sheets.length > 0 ? `Each living hero (${report.actor_sheets.join(", ")}) is fused into a generated multi-view reference sheet (image_reference_sheet) that the render grounds on \u2014 so drop ONE clean photo at that hero's ingest and the sheet builds the consistent turnaround. Pass --skip-actor-sheets to ground on the lone photo instead.` : "none (no person/animal heroes detected, or --skip-actor-sheets)",
@@ -20023,9 +20200,9 @@ var scaffoldStaticAdCommand = defineCommand92({
 });
 
 // src/commands/canvas/scaffold-video.ts
-import { access as access2, cp, mkdir as mkdir5, readFile as readFile12, rm as rm5, writeFile as writeFile6 } from "fs/promises";
+import { access as access2, cp, mkdir as mkdir6, readFile as readFile14, rm as rm6, writeFile as writeFile7 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path18 from "path";
+import path20 from "path";
 import { defineCommand as defineCommand93 } from "citty";
 
 // src/engine/scaffold/lib/model-router.ts
@@ -20064,7 +20241,7 @@ function routeVideoModel(input) {
 
 // src/engine/nodes/local/lib/sceneDetect.ts
 import { execFile as execFile2 } from "child_process";
-import { mkdtemp, readdir as readdir5, readFile as readFile10, rm as rm4 } from "fs/promises";
+import { mkdtemp, readdir as readdir6, readFile as readFile12, rm as rm5 } from "fs/promises";
 import { tmpdir } from "os";
 import { join as join2 } from "path";
 import { promisify as promisify2 } from "util";
@@ -20138,11 +20315,11 @@ async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs)
       ],
       { encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, timeout: timeoutMs }
     );
-    const csvName = (await readdir5(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
+    const csvName = (await readdir6(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
     if (!csvName) return [];
-    return parsePySceneDetectCsvCuts(await readFile10(join2(outDir, csvName), "utf-8"));
+    return parsePySceneDetectCsvCuts(await readFile12(join2(outDir, csvName), "utf-8"));
   } finally {
-    await rm4(outDir, { recursive: true, force: true });
+    await rm5(outDir, { recursive: true, force: true });
   }
 }
 async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
@@ -20165,23 +20342,23 @@ async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
 
 // src/commands/canvas/composition-path.ts
 import { existsSync as existsSync3 } from "fs";
-import path16 from "path";
+import path18 from "path";
 function resolveShippedCanvasDir(name, startDir, exists = existsSync3, maxDepth = 8) {
-  const rel = path16.join("canvas", name);
+  const rel = path18.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
-    const candidate = path16.join(dir, rel);
-    if (exists(path16.join(candidate, "meta.json"))) return candidate;
-    const parent = path16.dirname(dir);
+    const candidate = path18.join(dir, rel);
+    if (exists(path18.join(candidate, "meta.json"))) return candidate;
+    const parent = path18.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path16.resolve(startDir, "../../../", rel);
+  return path18.resolve(startDir, "../../../", rel);
 }
 
 // src/commands/canvas/gitignore.ts
-import { appendFile, readFile as readFile11 } from "fs/promises";
-import path17 from "path";
+import { appendFile, readFile as readFile13 } from "fs/promises";
+import path19 from "path";
 function missingGitignoreEntries(existing, entries) {
   const present = new Set(
     existing.split("\n").map((l) => l.trim().replace(/\/+$/, "")).filter((l) => l.length > 0 && !l.startsWith("#"))
@@ -20189,10 +20366,10 @@ function missingGitignoreEntries(existing, entries) {
   return entries.filter((e) => !present.has(e.trim().replace(/\/+$/, "")));
 }
 async function ensureGitignore(dir, entries) {
-  const file = path17.join(dir, ".gitignore");
+  const file = path19.join(dir, ".gitignore");
   let existing;
   try {
-    existing = await readFile11(file, "utf8");
+    existing = await readFile13(file, "utf8");
   } catch {
     return;
   }
@@ -20231,7 +20408,7 @@ ONE PERSON, MULTIPLE LOOKS: if a single individual plays MULTIPLE personas or wa
 For each kept element return: { "type": one of person|animal|product|logo|badge|location, "label": a short UPPER_SNAKE_CASE name (e.g. HERO, CREATOR_SKEPTIC, INSURANCE_CARD, LOGO), "description": a concrete reusable description to source/shoot the real asset \u2014 for a person/animal give a NEUTRAL castable role (e.g. "hero pet-owner, woman in her 30s" or "a small beagle"), NOT the original individual's literal face/identity: we RECAST with a FRESH person/animal, so never tell the agent to reuse the original. "expression": a living subject's typical expression or null, "cast_id": the global.cast id if it maps to one else null, "same_as": the label of another element this is the SAME individual as (different wardrobe/persona) else null, "scenes": the 0-based indices of ONLY the scenes where the element is ACTUALLY VISIBLE ON SCREEN \u2014 judged from that scene's start_frame_prompt / end_frame_prompt subjects and its action_detail, NOT from who is merely speaking. A narrator heard over b-roll is NOT present in that b-roll scene; a dog-running cutaway does NOT contain the couch creator just because she talks across it. Do NOT pad the list \u2014 an element wrongly listed in a scene makes the reproduction render the wrong subject there (e.g. the creator appearing in a pure-dog b-roll). When in doubt, leave a scene OUT. Output ONLY the JSON object.`;
 async function loadAssetText2(ref, label) {
   const r = ref;
-  if (typeof r?.path === "string") return readFile12(r.path, "utf8");
+  if (typeof r?.path === "string") return readFile14(r.path, "utf8");
   if (typeof r?.url === "string") {
     const res = await fetch(r.url);
     if (!res.ok) throw new Error(`failed to fetch ${label} (${res.status})`);
@@ -20250,7 +20427,7 @@ async function loadTranscriptBestEffort(ref) {
 async function stageCaptions(outDir, transcript) {
   const text = transcript?.trim();
   if (!text || text === "[]") return {};
-  const compositionPath = path18.join(outDir, "tiktok-captions-composition");
+  const compositionPath = path20.join(outDir, "tiktok-captions-composition");
   await cp(SHIPPED_CAPTIONS_DIR, compositionPath, { recursive: true });
   return { compositionPath };
 }
@@ -20268,12 +20445,12 @@ function patchCompositionHtml(html, dims) {
   return html.replace(/(<meta\s+name="viewport"\s+content="width=)\d+(,\s*height=)\d+(")/i, `$1${dims.w}$2${dims.h}$3`).replace(/(width:\s*)\d+(px;\s*height:\s*)\d+(px;)/i, `$1${dims.w}$2${dims.h}$3`).replace(/(data-width=")\d+(")/i, `$1${dims.w}$2`).replace(/(data-height=")\d+(")/i, `$1${dims.h}$2`);
 }
 async function stampCompositionDims(compositionDir, dims) {
-  const metaPath = path18.join(compositionDir, "meta.json");
-  const rawMeta = await readFile12(metaPath, "utf8");
-  await writeFile6(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
-  const htmlPath = path18.join(compositionDir, "index.html");
-  const rawHtml = await readFile12(htmlPath, "utf8");
-  await writeFile6(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
+  const metaPath = path20.join(compositionDir, "meta.json");
+  const rawMeta = await readFile14(metaPath, "utf8");
+  await writeFile7(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
+  const htmlPath = path20.join(compositionDir, "index.html");
+  const rawHtml = await readFile14(htmlPath, "utf8");
+  await writeFile7(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
 }
 function parseElements2(raw) {
   const parsed = JSON.parse(raw);
@@ -20320,7 +20497,7 @@ var VIDEO_EXT_BY_MIME = {
   "video/x-matroska": ".mkv"
 };
 function referenceVideoExt(url, contentType) {
-  const fromPath = path18.extname(new URL(url).pathname).toLowerCase();
+  const fromPath = path20.extname(new URL(url).pathname).toLowerCase();
   if (fromPath && fromPath.length <= 5) return fromPath;
   const mime = (contentType ?? "").split(";")[0]?.trim().toLowerCase();
   return mime && VIDEO_EXT_BY_MIME[mime] || ".mp4";
@@ -20346,7 +20523,7 @@ function videoDefinitionDescription(blueprint) {
   return typeof product === "string" && product.trim() ? product.trim() : void 0;
 }
 async function materializeReferenceVideo(fileArg2) {
-  if (!/^https?:\/\//i.test(fileArg2)) return path18.resolve(fileArg2);
+  if (!/^https?:\/\//i.test(fileArg2)) return path20.resolve(fileArg2);
   let res;
   try {
     res = await fetch(fileArg2);
@@ -20356,11 +20533,11 @@ async function materializeReferenceVideo(fileArg2) {
   if (!res.ok) throw new Error(`failed to download reference video (${res.status} ${res.statusText})`);
   const bytes = Buffer.from(await res.arrayBuffer());
   if (bytes.length === 0) throw new Error("reference video download was empty");
-  const dest = path18.join(
+  const dest = path20.join(
     tmpdir2(),
     `baker-ref-${sha256Hex(bytes).slice(0, 16)}${referenceVideoExt(fileArg2, res.headers.get("content-type"))}`
   );
-  await writeFile6(dest, bytes);
+  await writeFile7(dest, bytes);
   return dest;
 }
 function resolveSeamDedup(raw) {
@@ -20483,7 +20660,7 @@ async function runAnalysisPasses(deconstructCanvas, selectModel) {
 var scaffoldVideoCommand = defineCommand93({
   meta: {
     name: "scaffold-video",
-    description: "Turn a reference video into a runnable reproduction canvas in one command. Runs billed passes \u2014 video_deconstruct (the full scene-by-scene blueprint + transcript, baked to prompt.json as the editable 'prompt') and an AI selection of the video's RECURRING identity elements (person/animal/product/logo) \u2014 then scaffolds a pipeline where every scene boundary is a static-ad-grade frame (the blueprint as target_blueprint, a reference legend, the real frame as anchor) and each recurring element gets ONE shared [TODO] ingest slot wired into every frame it appears in. The clips feed Seedance an ultra-detailed motion brief (action, camera, dialogue, transcript). Edit prompt.json, drop the real source images, then `baker canvas run`."
+    description: "Turn a reference video into a runnable reproduction canvas in one command. Runs billed passes \u2014 video_deconstruct (the full scene-by-scene blueprint + transcript, baked to a split, editable blueprint: a global prompt.json plus one small scenes/sNN.json per scene) and an AI selection of the video's RECURRING identity elements (person/animal/product/logo) \u2014 then scaffolds a pipeline where every scene boundary is a static-ad-grade frame (the blueprint as target_blueprint, a reference legend, the real frame as anchor) and each recurring element gets ONE shared [TODO] ingest slot wired into every frame it appears in. The clips feed Seedance an ultra-detailed motion brief (action, camera, dialogue, transcript). Edit a scene's scenes/sNN.json (or prompt.json for global cast/palette/brand), drop the real source images, then `baker canvas run`."
   },
   args: {
     file: {
@@ -20572,11 +20749,11 @@ var scaffoldVideoCommand = defineCommand93({
     } catch (e) {
       return fail3("download", e instanceof Error ? e.message : String(e));
     }
-    const base = path18.basename(videoPath, path18.extname(videoPath));
-    const outPath = args.out ? path18.resolve(String(args.out)) : slug ? path18.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path18.join(path18.dirname(videoPath), `${base}.video.canvas.json`);
-    const outDir = path18.dirname(outPath);
-    const blueprintPath = path18.join(outDir, "prompt.json");
-    const blueprintStylePath = path18.join(outDir, "prompt.style.json");
+    const base = path20.basename(videoPath, path20.extname(videoPath));
+    const outPath = args.out ? path20.resolve(String(args.out)) : slug ? path20.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path20.join(path20.dirname(videoPath), `${base}.video.canvas.json`);
+    const outDir = path20.dirname(outPath);
+    const blueprintPath = path20.join(outDir, "prompt.json");
+    const blueprintStylePath = path20.join(outDir, "prompt.style.json");
     const frames = args.frames === "reuse" ? "reuse" : "generate";
     const maxScenes = args["max-scenes"] ? Number(args["max-scenes"]) : void 0;
     if (Number.isFinite(maxScenes)) {
@@ -20595,11 +20772,10 @@ var scaffoldVideoCommand = defineCommand93({
       shotCuts
     });
     const { blueprint, elements, transcript, creditsSpent } = await runAnalysisPasses(deconstructCanvas, selectModel);
-    await mkdir5(outDir, { recursive: true });
+    await mkdir6(outDir, { recursive: true });
     const annotated = annotateBlueprintWithElements(blueprint, elements);
-    await writeFile6(blueprintPath, `${JSON.stringify(annotated, null, 2)}
-`, "utf8");
-    await writeFile6(blueprintStylePath, renderStyleProjectionFromValue(annotated), "utf8");
+    await writeSceneFiles(outDir, annotated);
+    await writeFile7(blueprintStylePath, renderStyleProjectionFromValue(annotated), "utf8");
     let aspect;
     try {
       aspect = resolveAspect(
@@ -20617,12 +20793,12 @@ var scaffoldVideoCommand = defineCommand93({
 `
       );
     }
-    const compositionDest = path18.join(outDir, "video-overlay-composition");
+    const compositionDest = path20.join(outDir, "video-overlay-composition");
     await cp(SHIPPED_COMPOSITION_DIR, compositionDest, { recursive: true });
     await stampCompositionDims(compositionDest, outDims);
-    const indexPath = path18.join(compositionDest, "index.html");
+    const indexPath = path20.join(compositionDest, "index.html");
     const overlayHtml = buildOverlayHtml(blueprint, { captionsActive: Boolean(transcript) });
-    const indexHtml = await readFile12(indexPath, "utf8");
+    const indexHtml = await readFile14(indexPath, "utf8");
     const injected = indexHtml.replace("<!--OVERLAYS-->", () => overlayHtml);
     if (injected === indexHtml && overlayHtml.trim()) {
       fail3(
@@ -20630,16 +20806,16 @@ var scaffoldVideoCommand = defineCommand93({
         `video-overlay-composition/index.html is missing the <!--OVERLAYS--> marker \u2014 cannot inject the overlay layer`
       );
     }
-    await writeFile6(indexPath, injected, "utf8");
+    await writeFile7(indexPath, injected, "utf8");
     const captions = await stageCaptions(outDir, transcript);
     if (captions.compositionPath) await stampCompositionDims(captions.compositionPath, outDims);
     const opts = {
       imageModel,
       videoModel,
-      overlayCompositionPath: path18.relative(outDir, compositionDest),
-      captionsCompositionPath: captions.compositionPath ? path18.relative(outDir, captions.compositionPath) : void 0,
-      blueprintPath: path18.relative(outDir, blueprintPath),
-      blueprintStylePath: path18.relative(outDir, blueprintStylePath),
+      overlayCompositionPath: path20.relative(outDir, compositionDest),
+      captionsCompositionPath: captions.compositionPath ? path20.relative(outDir, captions.compositionPath) : void 0,
+      blueprintPath: path20.relative(outDir, blueprintPath),
+      blueprintStylePath: path20.relative(outDir, blueprintStylePath),
       frames,
       ambient: Boolean(args.ambient),
       seamDedup: resolveSeamDedup(args["seam-dedup"]),
@@ -20655,7 +20831,7 @@ var scaffoldVideoCommand = defineCommand93({
       return fail3("scaffold", e instanceof Error ? e.message : String(e));
     }
     if (captions.compositionPath && !canvas.nodes.some((n) => n.id === "captions")) {
-      await rm5(captions.compositionPath, { recursive: true, force: true });
+      await rm6(captions.compositionPath, { recursive: true, force: true });
     }
     const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(canvas, outDir), defaultRegistry());
     if (!validation.ok) {
@@ -20664,8 +20840,14 @@ var scaffoldVideoCommand = defineCommand93({
       todo.blocking_validation_issues = validation.issues;
       meta.todo = todo;
     }
-    await writeFile6(outPath, `${JSON.stringify(canvas, null, 2)}
+    await writeFile7(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
+    await writeFile7(
+      path20.join(outDir, REBUILD_FILE),
+      `${JSON.stringify({ elements, opts }, null, 2)}
+`,
+      "utf8"
+    );
     if (!validation.ok) {
       process.stderr.write(
         `${JSON.stringify(
@@ -20686,9 +20868,9 @@ var scaffoldVideoCommand = defineCommand93({
     await ensureGitignore(process.cwd(), ["canvas/", ".context/"]);
     const sourceRef = videoSourceReference(blueprint, fileArg2);
     if (slug) {
-      const definitionPath = path18.join(outDir, "_definition.md");
+      const definitionPath = path20.join(outDir, "_definition.md");
       if (!await fileExists2(definitionPath)) {
-        await writeFile6(
+        await writeFile7(
           definitionPath,
           buildCreativeDefinition({
             title: titleFromSlug(slug),
@@ -20741,7 +20923,7 @@ var scaffoldVideoCommand = defineCommand93({
             graph: canvas.metadata?.video?.graph_stats
           },
           checklist: {
-            edit_prompt: `Edit ${path18.basename(blueprintPath)} \u2014 the blueprint deconstructed from your video; rewrite it into the ad you want (cast, palette, copy, claims). Global cast/palette/brand edits flow into every frame automatically: \`baker canvas validate\`/\`run\` regenerate ${path18.basename(blueprintStylePath)} (the projection each frame's target_blueprint reads) from it \u2014 never edit that derived file by hand. Per-scene content is edited on each frame node's own prompt.`,
+            edit_prompt: `The blueprint is split so you edit ONE small file at a time \u2014 never a giant one. Per-scene content (a scene's dialogue, action, frame prompts, overlays) lives in \`scenes/sNN.json\` \u2014 edit the single scene you want to change. Global cast/palette/brand/copy lives in \`${path20.basename(blueprintPath)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path20.basename(blueprintStylePath)}, the projection each frame's target_blueprint reads) \u2014 so your scene edits reach the render automatically. Never hand-edit the inlined node prompts in the canvas or the derived ${path20.basename(blueprintStylePath)}; both are regenerated.`,
             recurring_elements_to_supply: report.elements,
             voices_to_confirm: report.dialogue.map((d) => ({
               scene: d.scene,
@@ -20778,8 +20960,8 @@ var scaffoldVideoCommand = defineCommand93({
 });
 
 // src/commands/canvas/set-prompt.ts
-import { readFile as readFile13, writeFile as writeFile7 } from "fs/promises";
-import path19 from "path";
+import { readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
+import path21 from "path";
 import { defineCommand as defineCommand94 } from "citty";
 function setNodePrompt(canvas, nodeId, text) {
   const nodes = canvas?.nodes;
@@ -20807,17 +20989,17 @@ var setPromptCommand = defineCommand94({
     "text-file": { type: "string", description: "Read the new prompt from a UTF-8 file (preserves accents/newlines)" }
   },
   async run({ args }) {
-    const filePath = path19.resolve(String(args.file));
+    const filePath = path21.resolve(String(args.file));
     let canvas;
     try {
-      canvas = JSON.parse(await readFile13(filePath, "utf8"));
+      canvas = JSON.parse(await readFile15(filePath, "utf8"));
     } catch (e) {
       process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "parse", message: String(e) } }, null, 2)}
 `);
       process.exit(2);
     }
     let text;
-    if (args["text-file"]) text = await readFile13(path19.resolve(String(args["text-file"])), "utf8");
+    if (args["text-file"]) text = await readFile15(path21.resolve(String(args["text-file"])), "utf8");
     else if (args.text !== void 0) text = String(args.text);
     else {
       process.stderr.write(
@@ -20838,14 +21020,14 @@ var setPromptCommand = defineCommand94({
       process.exit(2);
       return;
     }
-    const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(updated, path19.dirname(filePath)), defaultRegistry());
+    const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(updated, path21.dirname(filePath)), defaultRegistry());
     if (!validation.ok) {
       process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "validation", issues: validation.issues } }, null, 2)}
 `);
       process.exit(2);
       return;
     }
-    await writeFile7(filePath, `${JSON.stringify(updated, null, 2)}
+    await writeFile8(filePath, `${JSON.stringify(updated, null, 2)}
 `, "utf8");
     process.stdout.write(`${JSON.stringify({ ok: true, node: String(args.node), bytes: text.length }, null, 2)}
 `);
@@ -20853,8 +21035,8 @@ var setPromptCommand = defineCommand94({
 });
 
 // src/commands/canvas/validate.ts
-import { readFile as readFile14 } from "fs/promises";
-import path20 from "path";
+import { readFile as readFile16 } from "fs/promises";
+import path22 from "path";
 import { defineCommand as defineCommand95 } from "citty";
 var validateCommand = defineCommand95({
   meta: {
@@ -20863,8 +21045,8 @@ var validateCommand = defineCommand95({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args }) {
-    const filePath = path20.resolve(String(args.file));
-    const raw = await readFile14(filePath, "utf8");
+    const filePath = path22.resolve(String(args.file));
+    const raw = await readFile16(filePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -20874,7 +21056,7 @@ var validateCommand = defineCommand95({
 `);
       process.exit(2);
     }
-    parsed = resolveRelativeCanvasPaths(parsed, path20.dirname(filePath));
+    parsed = resolveRelativeCanvasPaths(parsed, path22.dirname(filePath));
     let styleProjection = "not_applicable";
     try {
       styleProjection = await syncStyleProjection(parsed, (line) => process.stderr.write(`${line}
@@ -20883,6 +21065,18 @@ var validateCommand = defineCommand95({
       const msg = e instanceof Error ? e.message : String(e);
       process.stderr.write(
         `${JSON.stringify({ ok: false, error: { code: "style_projection", message: `prompt.json is not readable/valid JSON: ${msg}` } }, null, 2)}
+`
+      );
+      process.exit(2);
+    }
+    let sceneProjection = "not_applicable";
+    try {
+      sceneProjection = await syncSceneNodeParams(parsed, filePath, (line) => process.stderr.write(`${line}
+`));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(
+        `${JSON.stringify({ ok: false, error: { code: "scene_projection", message: `a scenes/*.json file is not readable/valid or its rebuild failed: ${msg}` } }, null, 2)}
 `
       );
       process.exit(2);
@@ -20902,6 +21096,7 @@ var validateCommand = defineCommand95({
           estimated_credits: result.estimatedCredits,
           cost_preview: result.perNodeCredits ?? [],
           style_projection: styleProjection,
+          scene_projection: sceneProjection,
           warnings: result.warnings ?? []
         },
         null,
@@ -20952,7 +21147,7 @@ import { defineCommand as defineCommand98 } from "citty";
 import { defineCommand as defineCommand97 } from "citty";
 
 // src/commands/images/api.ts
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 import { extname } from "path";
 var imageProcessingTimeoutMs = 18e4;
 var imageReadyPollIntervalMs = 2e3;
@@ -20966,7 +21161,7 @@ var mimeMap = {
   ".avif": "image/avif"
 };
 var defaultImageApiDeps = {
-  readFile: readFile15,
+  readFile: readFile17,
   post: apiPost,
   get: apiGet,
   sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms))
@@ -21200,12 +21395,12 @@ function listFlowSlugs() {
   return readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
 }
 function readFlowTree(slug) {
-  const path21 = join3(flowsDir(), slug, "_data.json");
-  if (!existsSync4(path21)) {
+  const path23 = join3(flowsDir(), slug, "_data.json");
+  if (!existsSync4(path23)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync9(path21, "utf-8"));
+    return JSON.parse(readFileSync9(path23, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -22213,7 +22408,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile16, rename, stat as stat4, writeFile as writeFile8 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile18, rename, stat as stat4, writeFile as writeFile9 } from "fs/promises";
 import { dirname as dirname2, extname as extname2, join as join4, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
@@ -22249,11 +22444,11 @@ async function readImageBuffer(pathOrUrl) {
     }
     return Buffer.from(await response.arrayBuffer());
   }
-  return readFile16(pathOrUrl);
+  return readFile18(pathOrUrl);
 }
-async function isDirectory(path21) {
+async function isDirectory(path23) {
   try {
-    const s = await stat4(path21);
+    const s = await stat4(path23);
     return s.isDirectory();
   } catch {
     return false;
@@ -22272,7 +22467,7 @@ async function atomicWrite(targetPath, data) {
   const absolute = resolve4(targetPath);
   const dir = dirname2(absolute);
   const tmp = join4(dir, `.baker-image-${randomBytes(8).toString("hex")}.tmp`);
-  await writeFile8(tmp, data);
+  await writeFile9(tmp, data);
   await rename(tmp, absolute);
 }
 
@@ -22615,7 +22810,7 @@ var findCommand = defineCommand112({
 });
 
 // src/commands/images/generate.ts
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile19 } from "fs/promises";
 import { defineCommand as defineCommand113 } from "citty";
 import sharp2 from "sharp";
 var GENERATE_TIMEOUT_MS = 18e4;
@@ -22705,7 +22900,7 @@ async function resolveReferences(spec) {
     }
     let raw;
     try {
-      raw = await readFile17(entry);
+      raw = await readFile19(entry);
     } catch {
       throw new ApiError("VALIDATION_ERROR", `Reference file not found: ${entry}`);
     }
@@ -26864,7 +27059,7 @@ var searchCommand3 = defineCommand159({
 var tagsCommand5 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
-import { readFile as readFile18, stat as stat5 } from "fs/promises";
+import { readFile as readFile20, stat as stat5 } from "fs/promises";
 import { extname as extname3 } from "path";
 import { defineCommand as defineCommand160 } from "citty";
 var MIME_MAP = {
@@ -26929,7 +27124,7 @@ var uploadCommand2 = defineCommand160({
         return;
       }
       const { uploadUrl, videoId } = await apiPost("/api/videos/upload", {});
-      const fileBuffer = await readFile18(filePath);
+      const fileBuffer = await readFile20(filePath);
       const uploadResponse = await fetch(uploadUrl, {
         method: "PUT",
         headers: { "Content-Type": contentType },