@koda-sl/baker-cli 0.199.0 → 0.200.0

package/dist/cli.js

@@ -8746,11 +8746,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(path35) {
-  if (typeof path35 !== "string" || path35.length === 0) {
+function rawFileEntries(path36) {
+  if (typeof path36 !== "string" || path36.length === 0) {
     return [];
   }
-  return readFileSync2(path35, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync2(path36, "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;
@@ -8773,19 +8773,19 @@ function keywordEntries(args) {
   }
   return entries;
 }
-function loadJsonFileArg(path35) {
-  if (typeof path35 !== "string" || path35.length === 0) {
+function loadJsonFileArg(path36) {
+  if (typeof path36 !== "string" || path36.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync2(path35, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path36, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation(`${path35} must contain a JSON object`);
+      failWriteValidation(`${path36} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation(`${path35} is not valid JSON: ${err.message}`);
+      failWriteValidation(`${path36} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -8915,10 +8915,10 @@ async function stageUpdate(kind, customerId, target, payload, hints) {
 async function stageTarget(kind, customerId, target, hints) {
   await stageGoogleOp({ kind, customerId, target }, hints);
 }
-async function draftAction(path35, body, chat) {
+async function draftAction(path36, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path35, { chatId, ...body });
+    const response = await apiPost(path36, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -11776,19 +11776,19 @@ function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path35) {
-  if (typeof path35 !== "string" || path35.length === 0) {
+function loadJsonFileArg2(path36) {
+  if (typeof path36 !== "string" || path36.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync4(path35, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path36, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation2(`${path35} must contain a JSON object`);
+      failWriteValidation2(`${path36} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation2(`${path35} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path36} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -11873,15 +11873,15 @@ function parseLocaleFlag(value) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path35) {
-  if (typeof path35 !== "string" || path35.length === 0) {
+function loadTargetingFileArg(path36) {
+  if (typeof path36 !== "string" || path36.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path35);
+  const parsed = loadJsonFileArg2(path36);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation2(
-      `${path35} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path36} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -11916,14 +11916,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell) => cell.trim());
 }
-function parseListFileArg(path35, maxRows) {
-  if (typeof path35 !== "string" || path35.length === 0) {
+function parseListFileArg(path36, maxRows) {
+  if (typeof path36 !== "string" || path36.length === 0) {
     return void 0;
   }
-  const raw = readFileSync4(path35, "utf8");
+  const raw = readFileSync4(path36, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation2(`${path35} needs a header row and at least one data row`);
+    failWriteValidation2(`${path36} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -11942,7 +11942,7 @@ function parseListFileArg(path35, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation2(`${path35} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path36} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -12038,11 +12038,11 @@ function readPositionals(args) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path35) {
-  if (typeof path35 !== "string" || path35.length === 0) {
+function idsFileEntries(path36) {
+  if (typeof path36 !== "string" || path36.length === 0) {
     return [];
   }
-  return readFileSync4(path35, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync4(path36, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
 }
 function requireTargets(args, entity) {
   const positionals = readPositionals(args);
@@ -14665,9 +14665,9 @@ function compactRow(row) {
     ...destination.postUrn ? { postUrn: destination.postUrn } : {}
   };
 }
-function readPath(row, path35) {
+function readPath(row, path36) {
   let current = row;
-  for (const segment of path35.split(".")) {
+  for (const segment of path36.split(".")) {
     const record = asRecord2(current);
     if (!record) return void 0;
     current = record[segment];
@@ -14677,10 +14677,10 @@ function readPath(row, path35) {
 function projectFields(rows, paths) {
   return rows.map((row) => {
     const projected = {};
-    for (const path35 of paths) {
-      const value = readPath(row, path35);
+    for (const path36 of paths) {
+      const value = readPath(row, path36);
       if (value !== void 0) {
-        projected[path35] = value;
+        projected[path36] = value;
       }
     }
     return projected;
@@ -15974,11 +15974,11 @@ var updateStatusSchema = z21.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path35) {
+function validateDailyBudgetFloor(money, ctx, path36) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path35, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path36, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -16640,19 +16640,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg3(path35) {
-  if (typeof path35 !== "string" || path35.length === 0) {
+function loadJsonFileArg3(path36) {
+  if (typeof path36 !== "string" || path36.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path35, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path36, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path35} must contain a JSON object`);
+      failWriteValidation3(`${path36} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path35} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path36} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -20664,14 +20664,99 @@ async function probeDuration(filePath) {
 }
 
 // src/commands/canvas/rerun.ts
-import path14 from "path";
+import path15 from "path";
 import { defineCommand as defineCommand96 } from "citty";
 
 // src/commands/canvas/run.ts
 import { readFile as readFile10 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 import { defineCommand as defineCommand95 } from "citty";
 
+// src/commands/canvas/normalize-paths.ts
+import { existsSync as existsSync3, realpathSync } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
+function findWorkspaceRoot(startDir, exists = existsSync3, maxDepth = 12) {
+  let dir = path4.resolve(startDir);
+  for (let i = 0; i < maxDepth; i++) {
+    if (exists(path4.join(dir, "package.json"))) return dir;
+    const parent = path4.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function canonicalize(target) {
+  const abs = path4.resolve(target);
+  let dir = abs;
+  for (; ; ) {
+    try {
+      const real = realpathSync(dir);
+      return dir === abs ? real : path4.join(real, path4.relative(dir, abs));
+    } catch {
+      const parent = path4.dirname(dir);
+      if (parent === dir) return abs;
+      dir = parent;
+    }
+  }
+}
+function isInside(root, target) {
+  const rel = path4.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel);
+}
+function toCanvasRelative(canvasDir, target) {
+  return path4.relative(canvasDir, target).split(path4.sep).join("/");
+}
+var RUNTIME_WORKSPACE_ROOT = "/home/user/repo";
+function rewriteTarget(value, workspaceRoot) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  if (value.includes("[TODO") || looksLikeHttpUrl(value) || !path4.isAbsolute(value)) return null;
+  const target = canonicalize(value);
+  if (isInside(workspaceRoot, target)) return target;
+  const fromRuntime = path4.relative(RUNTIME_WORKSPACE_ROOT, path4.normalize(value));
+  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path4.isAbsolute(fromRuntime)) {
+    return path4.join(workspaceRoot, fromRuntime);
+  }
+  return null;
+}
+function normalizeAbsoluteCanvasPaths(canvas, canvasDir, workspaceRoot) {
+  if (!canvas || typeof canvas !== "object") return { canvas, rewrites: [] };
+  const c = canvas;
+  if (!Array.isArray(c.nodes)) return { canvas, rewrites: [] };
+  const root = canonicalize(workspaceRoot);
+  const dir = canonicalize(canvasDir);
+  const rewrites = [];
+  const nodes = c.nodes.map((node) => {
+    if (!node || typeof node !== "object") return node;
+    const n = node;
+    const params = n.params;
+    if (!params || typeof params !== "object") return node;
+    const nodeId = typeof n.id === "string" ? n.id : "?";
+    const key = n.type === "ingest" && params.source === "path" ? "path" : n.type === "hyperframe_render" ? "composition" : null;
+    if (!key) return node;
+    const target = rewriteTarget(params[key], root);
+    if (target === null) return node;
+    const to = toCanvasRelative(dir, target);
+    rewrites.push({ nodeId, param: key, from: params[key], to });
+    return { ...node, params: { ...params, [key]: to } };
+  });
+  return rewrites.length === 0 ? { canvas, rewrites } : { canvas: { ...canvas, nodes }, rewrites };
+}
+async function healAbsoluteCanvasPaths(filePath, canvas) {
+  const canvasDir = path4.dirname(filePath);
+  const workspaceRoot = findWorkspaceRoot(canvasDir);
+  if (!workspaceRoot) return { canvas, rewrites: [], text: null };
+  const normalized = normalizeAbsoluteCanvasPaths(canvas, canvasDir, workspaceRoot);
+  if (normalized.rewrites.length === 0) return { ...normalized, text: null };
+  const text2 = `${JSON.stringify(normalized.canvas, null, 2)}
+`;
+  await writeFile2(filePath, text2, "utf8");
+  return { ...normalized, text: text2 };
+}
+function describeRewrites(rewrites) {
+  return rewrites.map((r) => `  ${r.nodeId}.${r.param}: ${r.from} \u2192 ${r.to}`).join("\n");
+}
+
 // src/commands/canvas/placeholders.ts
 function unsuppliedPlaceholderAssets(canvas) {
   const nodes = canvas?.nodes;
@@ -20689,7 +20774,7 @@ function unsuppliedPlaceholderAssets(canvas) {
 }
 
 // src/commands/canvas/resolve-paths.ts
-import path4 from "path";
+import path5 from "path";
 function resolveRelativeCanvasPaths(canvas, baseDir) {
   if (!canvas || typeof canvas !== "object") return canvas;
   const c = canvas;
@@ -20702,24 +20787,24 @@ function resolveNode(node, baseDir) {
   const params = n.params;
   if (!params || typeof params !== "object") return node;
   if (n.type === "ingest" && params.source === "path" && isResolvableRelative(params.path)) {
-    return { ...node, params: { ...params, path: path4.resolve(baseDir, params.path) } };
+    return { ...node, params: { ...params, path: path5.resolve(baseDir, params.path) } };
   }
   if (n.type === "hyperframe_render" && isResolvableRelative(params.composition)) {
-    return { ...node, params: { ...params, composition: path4.resolve(baseDir, params.composition) } };
+    return { ...node, params: { ...params, composition: path5.resolve(baseDir, params.composition) } };
   }
   return node;
 }
 function isResolvableRelative(value) {
-  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path4.isAbsolute(value);
+  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path5.isAbsolute(value);
 }
 
 // src/commands/canvas/source-version.ts
 import { readFile as readFile5 } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 
 // src/commands/canvas/scene-files.ts
-import { mkdir as mkdir2, readFile as readFile4, readdir as readdir2, rm, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+import { mkdir as mkdir2, readFile as readFile4, readdir as readdir2, rm, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
 var SCENES_DIR = "scenes";
 var GLOBAL_PROMPT_FILE = "prompt.json";
 var REBUILD_FILE = "prompt.rebuild.json";
@@ -20736,19 +20821,19 @@ function splitBlueprint(blueprint) {
 }
 async function writeSceneFiles(outDir, blueprint) {
   const { global, scenes } = splitBlueprint(blueprint);
-  await writeFile2(path5.join(outDir, GLOBAL_PROMPT_FILE), `${JSON.stringify(global, null, 2)}
+  await writeFile3(path6.join(outDir, GLOBAL_PROMPT_FILE), `${JSON.stringify(global, null, 2)}
 `, "utf8");
-  const scenesDir = path5.join(outDir, SCENES_DIR);
+  const scenesDir = path6.join(outDir, SCENES_DIR);
   await mkdir2(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 writeFile2(path5.join(scenesDir, name), `${JSON.stringify(scenes[i], null, 2)}
+    await writeFile3(path6.join(scenesDir, name), `${JSON.stringify(scenes[i], null, 2)}
 `, "utf8");
   }
   for (const name of await listSceneFileNames(scenesDir)) {
-    if (!written.has(name)) await rm(path5.join(scenesDir, name), { force: true });
+    if (!written.has(name)) await rm(path6.join(scenesDir, name), { force: true });
   }
 }
 async function listSceneFileNames(scenesDir) {
@@ -20761,13 +20846,13 @@ async function listSceneFileNames(scenesDir) {
   return entries.filter((n) => /^s\d+\.json$/.test(n)).sort(bySceneIndex);
 }
 async function listSceneFiles(creativeDir) {
-  const scenesDir = path5.join(creativeDir, SCENES_DIR);
-  return (await listSceneFileNames(scenesDir)).map((n) => path5.join(scenesDir, n));
+  const scenesDir = path6.join(creativeDir, SCENES_DIR);
+  return (await listSceneFileNames(scenesDir)).map((n) => path6.join(scenesDir, n));
 }
 async function reassembleBlueprint(creativeDir) {
   const files = await listSceneFiles(creativeDir);
   if (files.length === 0) return null;
-  const globalRaw = await readFile4(path5.join(creativeDir, GLOBAL_PROMPT_FILE), "utf8");
+  const globalRaw = await readFile4(path6.join(creativeDir, GLOBAL_PROMPT_FILE), "utf8");
   const global = JSON.parse(globalRaw);
   const scenes = [];
   for (const file of files) {
@@ -20789,8 +20874,8 @@ async function computeSourceSha(canvasPath) {
   } catch {
     return void 0;
   }
-  const canvasDir = path6.dirname(canvasPath);
-  const promptPath = path6.join(canvasDir, "prompt.json");
+  const canvasDir = path7.dirname(canvasPath);
+  const promptPath = path7.join(canvasDir, "prompt.json");
   let promptBytes;
   try {
     promptBytes = await readFile5(promptPath);
@@ -20817,7 +20902,7 @@ async function computeSourceSha(canvasPath) {
 
 // src/commands/canvas/scene-projection.ts
 import { readFile as readFile6 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 
 // src/engine/scaffold/video.ts
 import { toCardinal as nwAr } from "n2words/ar-SA";
@@ -24103,12 +24188,12 @@ function nonPromptParamsDiverge(live = {}, rebuilt = {}) {
   return false;
 }
 async function syncSceneNodeParams(canvas, canvasPath, log) {
-  const creativeDir = path7.dirname(canvasPath);
+  const creativeDir = path8.dirname(canvasPath);
   const blueprint = await reassembleBlueprint(creativeDir);
   if (!blueprint) return "not_applicable";
   let rebuildRaw;
   try {
-    rebuildRaw = await readFile6(path7.join(creativeDir, REBUILD_FILE), "utf8");
+    rebuildRaw = await readFile6(path8.join(creativeDir, REBUILD_FILE), "utf8");
   } catch {
     return "not_applicable";
   }
@@ -24149,7 +24234,7 @@ async function syncSceneNodeParams(canvas, canvasPath, log) {
 }
 
 // src/commands/canvas/style-projection.ts
-import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
 function findBlueprintProjection(canvas) {
   if (!canvas || typeof canvas !== "object") return null;
   const nodes = canvas.nodes;
@@ -24180,7 +24265,7 @@ async function syncStyleProjection(canvas, log) {
   const rendered = renderStyleProjection(await readFile7(pair.promptPath, "utf8"));
   const current = await readFile7(pair.stylePath, "utf8").catch(() => null);
   if (current === rendered) return "up_to_date";
-  await writeFile3(pair.stylePath, rendered, "utf8");
+  await writeFile4(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"
   );
@@ -24240,13 +24325,13 @@ ${body}` : header || body || compactJson(record);
 }
 
 // src/commands/canvas/run-record.ts
-import path8 from "path";
+import path9 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(path8.sep).join("/");
+  const normalized = filePath.split(path9.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;
@@ -24534,7 +24619,7 @@ var RunRecordPoster = class {
 
 // src/commands/canvas/run-retention.ts
 import { rm as rm2 } from "fs/promises";
-import path9 from "path";
+import path10 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;
@@ -24551,7 +24636,7 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
   const toPrune = runDirsToPrune(entries, keep, currentRunId);
   if (toPrune.length === 0) return;
   for (const dir of toPrune) {
-    await rm2(path9.join(outputsDir, dir), { recursive: true, force: true }).catch(
+    await rm2(path10.join(outputsDir, dir), { recursive: true, force: true }).catch(
       (e) => log(`[prune   ] could not remove ${dir}: ${e.message}`)
     );
   }
@@ -24559,13 +24644,13 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
 }
 
 // src/commands/canvas/dirty-marker.ts
-import { mkdir as mkdir3, readdir as readdir3, rm as rm3, writeFile as writeFile4 } from "fs/promises";
-import path10 from "path";
+import { mkdir as mkdir3, readdir as readdir3, rm as rm3, writeFile as writeFile5 } from "fs/promises";
+import path11 from "path";
 function creativeDirtyDir(base) {
-  return base ?? path10.resolve("canvas", ".dirty");
+  return base ?? path11.resolve("canvas", ".dirty");
 }
 function dirtyMarkerFile(slug, base) {
-  return path10.join(creativeDirtyDir(base), `${slug}.json`);
+  return path11.join(creativeDirtyDir(base), `${slug}.json`);
 }
 async function clearCreativeDirty(slug, base) {
   try {
@@ -24575,18 +24660,18 @@ async function clearCreativeDirty(slug, base) {
 }
 
 // src/commands/canvas/run-resume.ts
-import { mkdir as mkdir4, readFile as readFile8, rm as rm4, writeFile as writeFile5 } from "fs/promises";
-import path11 from "path";
+import { mkdir as mkdir4, readFile as readFile8, rm as rm4, writeFile as writeFile6 } from "fs/promises";
+import path12 from "path";
 function markerKey(canvasPath) {
   const slug = creativeSlugFromCanvasPath(canvasPath);
-  const identity = slug ?? path11.relative(process.cwd(), path11.resolve(canvasPath));
+  const identity = slug ?? path12.relative(process.cwd(), path12.resolve(canvasPath));
   return sha256Hex(Buffer.from(identity)).slice(0, 32);
 }
 function legacyMarkerKey(canvasPath) {
-  return sha256Hex(Buffer.from(path11.resolve(canvasPath))).slice(0, 32);
+  return sha256Hex(Buffer.from(path12.resolve(canvasPath))).slice(0, 32);
 }
 function markerFile(outputsDir, key) {
-  return path11.join(outputsDir, ".inflight", `${key}.json`);
+  return path12.join(outputsDir, ".inflight", `${key}.json`);
 }
 var REMOTE_ADOPT_STALE_MS = 12e4;
 function classifyRemoteRun(run, now) {
@@ -24633,8 +24718,8 @@ async function readMarkerRunId(outputsDir, canvasPath) {
 async function markRunInFlight(outputsDir, canvasPath, runId) {
   try {
     const file = markerFile(outputsDir, markerKey(canvasPath));
-    await mkdir4(path11.dirname(file), { recursive: true });
-    await writeFile5(file, JSON.stringify({ runId, canvasPath: path11.resolve(canvasPath), startedAt: Date.now() }));
+    await mkdir4(path12.dirname(file), { recursive: true });
+    await writeFile6(file, JSON.stringify({ runId, canvasPath: path12.resolve(canvasPath), startedAt: Date.now() }));
   } catch {
   }
 }
@@ -24648,8 +24733,8 @@ async function clearRunMarker(outputsDir, canvasPath) {
 }
 
 // src/commands/canvas/run-snapshot.ts
-import { mkdir as mkdir5, readdir as readdir4, readFile as readFile9, stat as stat2, writeFile as writeFile6 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir5, readdir as readdir4, readFile as readFile9, stat as stat2, writeFile as writeFile7 } from "fs/promises";
+import path13 from "path";
 var SNAPSHOT_SCHEMA = "baker-canvas-snapshot/1";
 var MAX_SNAPSHOT_FILE_BYTES = 32 * 1024 * 1024;
 var EXT_TO_MIME = {
@@ -24676,15 +24761,15 @@ var EXT_TO_MIME = {
   woff2: "font/woff2"
 };
 function mimeForFile(filePath) {
-  const ext = path12.extname(filePath).slice(1).toLowerCase();
+  const ext = path13.extname(filePath).slice(1).toLowerCase();
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
 function toPosix(p) {
-  return p.split(path12.sep).join("/");
+  return p.split(path13.sep).join("/");
 }
-function isInside(dir, target) {
-  const rel = path12.relative(dir, target);
-  return !rel.startsWith("..") && !path12.isAbsolute(rel);
+function isInside2(dir, target) {
+  const rel = path13.relative(dir, target);
+  return !rel.startsWith("..") && !path13.isAbsolute(rel);
 }
 function localPathRefsFromCanvas(parsed) {
   const nodes = parsed?.nodes;
@@ -24709,24 +24794,24 @@ function isSnapshotablePath(value) {
 async function sourceRefsToSnapshot(canvasDir, parsed) {
   const refs = new Set(localPathRefsFromCanvas(parsed));
   for (const sceneFile of await listSceneFiles(canvasDir)) {
-    refs.add(toPosix(path12.relative(canvasDir, sceneFile)));
+    refs.add(toPosix(path13.relative(canvasDir, sceneFile)));
   }
   refs.add(REBUILD_FILE);
   return [...refs];
 }
 async function uploadRunSnapshot(client, opts) {
   try {
-    const canvasDir = path12.dirname(opts.canvasPath);
+    const canvasDir = path13.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 await sourceRefsToSnapshot(canvasDir, opts.parsed)) {
-      const abs = path12.isAbsolute(refPath) ? refPath : path12.resolve(canvasDir, refPath);
-      if (!isInside(canvasDir, abs)) {
+      const abs = path13.isAbsolute(refPath) ? refPath : path13.resolve(canvasDir, refPath);
+      if (!isInside2(canvasDir, abs)) {
         skipped.push({
-          path: toPosix(path12.relative(canvasDir, abs)),
+          path: toPosix(path13.relative(canvasDir, abs)),
           reason: "outside the creative folder \u2014 read from the workspace on rerun"
         });
         continue;
@@ -24735,12 +24820,12 @@ async function uploadRunSnapshot(client, opts) {
       try {
         st = await stat2(abs);
       } catch {
-        skipped.push({ path: toPosix(path12.relative(canvasDir, abs)), reason: "missing" });
+        skipped.push({ path: toPosix(path13.relative(canvasDir, abs)), reason: "missing" });
         continue;
       }
       const fileList = st.isDirectory() ? await listFilesRecursive(abs) : [abs];
       for (const file of fileList) {
-        const rel = toPosix(path12.relative(canvasDir, file));
+        const rel = toPosix(path13.relative(canvasDir, file));
         const size = (await stat2(file)).size;
         if (size > MAX_SNAPSHOT_FILE_BYTES) {
           skipped.push({ path: rel, reason: `too large (${size} bytes)` });
@@ -24755,7 +24840,7 @@ async function uploadRunSnapshot(client, opts) {
       schema: SNAPSHOT_SCHEMA,
       creativeSlug: opts.creativeSlug,
       canvasSha: canvasUpload.sha256,
-      canvas: { path: path12.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
+      canvas: { path: path13.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
       files,
       skipped: skipped.length > 0 ? skipped : void 0
     };
@@ -24782,7 +24867,7 @@ async function putContentAddressed(client, bytes, mime, signal) {
 }
 async function listFilesRecursive(dir) {
   const entries = await readdir4(dir, { recursive: true, withFileTypes: true });
-  return entries.filter((d) => d.isFile()).map((d) => path12.join(d.parentPath, d.name));
+  return entries.filter((d) => d.isFile()).map((d) => path13.join(d.parentPath, d.name));
 }
 var SnapshotConflictError = class extends Error {
   conflicts;
@@ -24794,16 +24879,16 @@ var SnapshotConflictError = class extends Error {
 };
 async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
   const entries = [manifest.canvas, ...manifest.files];
-  const resolvedTarget = path12.resolve(targetDir);
+  const resolvedTarget = path13.resolve(targetDir);
   const planned = [];
   const conflicts = [];
   const upToDate = [];
   for (const entry of entries) {
-    if (path12.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
+    if (path13.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const target = path12.resolve(resolvedTarget, entry.path);
-    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path12.sep)) {
+    const target = path13.resolve(resolvedTarget, entry.path);
+    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path13.sep)) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
     const existing = await readFile9(target).catch(() => null);
@@ -24828,11 +24913,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 mkdir5(path12.dirname(target), { recursive: true });
-    await writeFile6(target, bytes);
+    await mkdir5(path13.dirname(target), { recursive: true });
+    await writeFile7(target, bytes);
     restored.push(entry.path);
   }
-  return { canvasPath: path12.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
+  return { canvasPath: path13.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
 }
 
 // src/commands/canvas/run.ts
@@ -24912,7 +24997,7 @@ function resolveMaxCredits(...candidates) {
   return void 0;
 }
 async function executeCanvasRun(opts) {
-  const filePath = path13.resolve(opts.file);
+  const filePath = path14.resolve(opts.file);
   const raw = await readFile10(filePath, "utf8");
   let parsed;
   try {
@@ -24925,7 +25010,17 @@ async function executeCanvasRun(opts) {
   }
   const attemptedSlug = creativeSlugFromCanvasPath(filePath);
   if (attemptedSlug) await clearCreativeDirty(attemptedSlug);
-  parsed = resolveRelativeCanvasPaths(parsed, path13.dirname(filePath));
+  const healed = await healAbsoluteCanvasPaths(filePath, parsed);
+  parsed = healed.canvas;
+  const canvasText = healed.text ?? raw;
+  if (healed.rewrites.length > 0) {
+    process.stderr.write(
+      `[canvas] rewrote ${healed.rewrites.length} absolute asset path(s) to canvas-relative \u2014 they resolve only in this workspace:
+${describeRewrites(healed.rewrites)}
+`
+    );
+  }
+  parsed = resolveRelativeCanvasPaths(parsed, path14.dirname(filePath));
   try {
     await syncStyleProjection(parsed, (line) => process.stderr.write(`${line}
 `));
@@ -25028,10 +25123,10 @@ async function executeCanvasRun(opts) {
     process.stdout.write(`[warn] ${w.code}: ${w.message}
 `);
   }
-  const canvasSha = sha256Hex(Buffer.from(raw));
+  const canvasSha = sha256Hex(Buffer.from(canvasText));
   const creativeSlug = creativeSlugFromCanvasPath(filePath) ?? void 0;
   const client = opts.record === false ? null : buildBackendClient();
-  const outputsDir = opts.outputsDir ? path13.resolve(opts.outputsDir) : path13.resolve("canvas");
+  const outputsDir = opts.outputsDir ? path14.resolve(opts.outputsDir) : path14.resolve("canvas");
   const { runId, resumed, source, concurrentRunId } = await resolveRunId({
     explicitRunId: opts.runId,
     fresh: opts.fresh === true,
@@ -25062,10 +25157,10 @@ async function executeCanvasRun(opts) {
     });
   }
   await markRunInFlight(outputsDir, filePath, runId);
-  const canvasSnapshotUrl = client && creativeSlug ? await uploadRunSnapshot(client, { canvasPath: filePath, raw, creativeSlug, parsed }) ?? void 0 : void 0;
+  const canvasSnapshotUrl = client && creativeSlug ? await uploadRunSnapshot(client, { canvasPath: filePath, raw: canvasText, creativeSlug, parsed }) ?? void 0 : void 0;
   const recordMeta = {
     creativeSlug,
-    canvasPath: path13.relative(process.cwd(), filePath) || void 0,
+    canvasPath: path14.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 +
@@ -25252,7 +25347,7 @@ var rerunCommand = defineCommand96({
     if (latest.canvasSha && manifest.canvasSha !== latest.canvasSha) {
       fail2("snapshot_mismatch", `snapshot manifest for run ${latest.runId} does not match its recorded canvas sha`);
     }
-    const targetDir = path14.resolve("src", "creatives", slug);
+    const targetDir = path15.resolve("src", "creatives", slug);
     let restoredCanvasPath;
     try {
       const restore = await restoreRunSnapshot(manifest, targetDir, { force: args["force-remote"] === true });
@@ -25301,8 +25396,8 @@ async function fetchManifest(url) {
 }
 
 // src/commands/canvas/scaffold-static-ad.ts
-import { access, mkdir as mkdir6, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
-import path18 from "path";
+import { access, mkdir as mkdir6, readFile as readFile12, writeFile as writeFile8 } from "fs/promises";
+import path19 from "path";
 import { defineCommand as defineCommand98 } from "citty";
 
 // src/engine/scaffold/staticAd.ts
@@ -25584,7 +25679,7 @@ function staticAdReport(input, elementsInput, opts) {
 }
 
 // src/commands/canvas/creative-definition.ts
-import path15 from "path";
+import path16 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) {
@@ -25632,16 +25727,16 @@ function buildCreativeDefinition(input) {
 }
 
 // src/commands/canvas/scaffold-static-ad-paths.ts
-import path16 from "path";
+import path17 from "path";
 function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
   const file = rawFile.trim();
   const imageIsUrl = /^https?:\/\//i.test(file);
-  const imageSource = imageIsUrl ? file : path16.resolve(cwd, file);
-  const outPath = out ? path16.resolve(cwd, out) : slug ? path16.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path16.join(cwd, "static-ad.canvas.json") : path16.join(path16.dirname(imageSource), "static-ad.canvas.json");
-  const blueprintPath = path16.join(path16.dirname(outPath), "prompt.json");
-  const creativeDir = slug ? path16.dirname(outPath) : null;
-  const definitionPath = creativeDir ? path16.join(creativeDir, "_definition.md") : null;
-  const referencesDir = creativeDir ? path16.join(creativeDir, "references") : null;
+  const imageSource = imageIsUrl ? file : path17.resolve(cwd, file);
+  const outPath = out ? path17.resolve(cwd, out) : slug ? path17.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path17.join(cwd, "static-ad.canvas.json") : path17.join(path17.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath = path17.join(path17.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path17.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path17.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path17.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])?$/;
@@ -25652,7 +25747,7 @@ function isValidScaffoldSlug(slug) {
 
 // src/commands/canvas/sync-definition.ts
 import { readdir as readdir5, readFile as readFile11, stat as stat3 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import { defineCommand as defineCommand97 } from "citty";
 
 // src/commands/canvas/definition-graph.ts
@@ -25745,15 +25840,15 @@ async function syncCreativeDefinitionBestEffort(input) {
   }
 }
 async function resolveCanvasPath(inputPath) {
-  const resolved = path17.resolve(inputPath);
+  const resolved = path18.resolve(inputPath);
   let dir = resolved;
   try {
     if ((await stat3(resolved)).isFile()) {
       if (resolved.endsWith(".canvas.json")) return resolved;
-      dir = path17.dirname(resolved);
+      dir = path18.dirname(resolved);
     }
   } catch {
-    dir = resolved.endsWith(".canvas.json") ? path17.dirname(resolved) : resolved;
+    dir = resolved.endsWith(".canvas.json") ? path18.dirname(resolved) : resolved;
   }
   let entries;
   try {
@@ -25764,7 +25859,7 @@ async function resolveCanvasPath(inputPath) {
   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 ? path17.join(dir, chosen) : null;
+  return chosen ? path18.join(dir, chosen) : null;
 }
 var syncDefinitionCommand = defineCommand97({
   meta: {
@@ -26045,7 +26140,7 @@ var scaffoldStaticAdCommand = defineCommand98({
       process.cwd(),
       slug
     );
-    await mkdir6(path18.dirname(outPath), { recursive: true });
+    await mkdir6(path19.dirname(outPath), { recursive: true });
     const { describeModel, selectModel, layoutModel, genModel } = resolveModels(args);
     let durableSourceUrl;
     if (referencesDir) {
@@ -26071,7 +26166,7 @@ var scaffoldStaticAdCommand = defineCommand98({
     if (layout && annotated && typeof annotated === "object") {
       annotated.layout = layout;
     }
-    await writeFile7(blueprintPath, `${JSON.stringify(annotated, null, 2)}
+    await writeFile8(blueprintPath, `${JSON.stringify(annotated, null, 2)}
 `, "utf8");
     let canvasImagePath = imageSource;
     let canvasImageIsUrl = imageIsUrl;
@@ -26116,10 +26211,10 @@ var scaffoldStaticAdCommand = defineCommand98({
       );
       process.exit(2);
     }
-    await writeFile7(outPath, `${JSON.stringify(canvas, null, 2)}
+    await writeFile8(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
     if (definitionPath && !await fileExists(definitionPath)) {
-      await writeFile7(
+      await writeFile8(
         definitionPath,
         buildCreativeDefinition({
           title: args.title ? String(args.title) : titleFromSlug(slug ?? ""),
@@ -26165,7 +26260,7 @@ var scaffoldStaticAdCommand = defineCommand98({
             run_estimated_credits: validation.estimatedCredits
           },
           checklist: {
-            edit_prompt: `Edit ${path18.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 ${path19.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)",
@@ -26182,9 +26277,9 @@ var scaffoldStaticAdCommand = defineCommand98({
 });
 
 // src/commands/canvas/scaffold-video.ts
-import { access as access2, cp, mkdir as mkdir7, readFile as readFile15, rm as rm6, writeFile as writeFile8 } from "fs/promises";
+import { access as access2, cp, mkdir as mkdir7, readFile as readFile15, rm as rm6, writeFile as writeFile9 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path21 from "path";
+import path22 from "path";
 import { defineCommand as defineCommand99 } from "citty";
 
 // src/engine/scaffold/lib/model-router.ts
@@ -26324,24 +26419,24 @@ async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
 }
 
 // src/commands/canvas/composition-path.ts
-import { existsSync as existsSync3 } from "fs";
-import path19 from "path";
-function resolveShippedCanvasDir(name, startDir, exists = existsSync3, maxDepth = 8) {
-  const rel = path19.join("canvas", name);
+import { existsSync as existsSync4 } from "fs";
+import path20 from "path";
+function resolveShippedCanvasDir(name, startDir, exists = existsSync4, maxDepth = 8) {
+  const rel = path20.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
-    const candidate = path19.join(dir, rel);
-    if (exists(path19.join(candidate, "meta.json"))) return candidate;
-    const parent = path19.dirname(dir);
+    const candidate = path20.join(dir, rel);
+    if (exists(path20.join(candidate, "meta.json"))) return candidate;
+    const parent = path20.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path19.resolve(startDir, "../../../", rel);
+  return path20.resolve(startDir, "../../../", rel);
 }
 
 // src/commands/canvas/gitignore.ts
 import { appendFile, readFile as readFile14 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 function missingGitignoreEntries(existing, entries) {
   const present2 = new Set(
     existing.split("\n").map((l) => l.trim().replace(/\/+$/, "")).filter((l) => l.length > 0 && !l.startsWith("#"))
@@ -26349,7 +26444,7 @@ function missingGitignoreEntries(existing, entries) {
   return entries.filter((e) => !present2.has(e.trim().replace(/\/+$/, "")));
 }
 async function ensureGitignore(dir, entries) {
-  const file = path20.join(dir, ".gitignore");
+  const file = path21.join(dir, ".gitignore");
   let existing;
   try {
     existing = await readFile14(file, "utf8");
@@ -26410,7 +26505,7 @@ async function loadTranscriptBestEffort(ref) {
 async function stageCaptions(outDir, transcript) {
   const text2 = transcript?.trim();
   if (!text2 || text2 === "[]") return {};
-  const compositionPath = path21.join(outDir, "tiktok-captions-composition");
+  const compositionPath = path22.join(outDir, "tiktok-captions-composition");
   await cp(SHIPPED_CAPTIONS_DIR, compositionPath, { recursive: true });
   return { compositionPath };
 }
@@ -26428,12 +26523,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 = path21.join(compositionDir, "meta.json");
+  const metaPath = path22.join(compositionDir, "meta.json");
   const rawMeta = await readFile15(metaPath, "utf8");
-  await writeFile8(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
-  const htmlPath = path21.join(compositionDir, "index.html");
+  await writeFile9(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
+  const htmlPath = path22.join(compositionDir, "index.html");
   const rawHtml = await readFile15(htmlPath, "utf8");
-  await writeFile8(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
+  await writeFile9(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
 }
 function parseElements2(raw) {
   const parsed = JSON.parse(raw);
@@ -26480,7 +26575,7 @@ var VIDEO_EXT_BY_MIME = {
   "video/x-matroska": ".mkv"
 };
 function referenceVideoExt(url, contentType) {
-  const fromPath = path21.extname(new URL(url).pathname).toLowerCase();
+  const fromPath = path22.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";
@@ -26506,7 +26601,7 @@ function videoDefinitionDescription(blueprint) {
   return typeof product === "string" && product.trim() ? product.trim() : void 0;
 }
 async function materializeReferenceVideo(fileArg2) {
-  if (!/^https?:\/\//i.test(fileArg2)) return path21.resolve(fileArg2);
+  if (!/^https?:\/\//i.test(fileArg2)) return path22.resolve(fileArg2);
   let bytes;
   let contentType;
   try {
@@ -26518,11 +26613,11 @@ async function materializeReferenceVideo(fileArg2) {
     throw new Error(`failed to download reference video: ${e instanceof Error ? e.message : String(e)}`);
   }
   if (bytes.length === 0) throw new Error("reference video download was empty");
-  const dest = path21.join(
+  const dest = path22.join(
     tmpdir2(),
     `baker-ref-${sha256Hex(bytes).slice(0, 16)}${referenceVideoExt(fileArg2, contentType)}`
   );
-  await writeFile8(dest, bytes);
+  await writeFile9(dest, bytes);
   return dest;
 }
 function resolveSeamDedup(raw) {
@@ -26738,11 +26833,11 @@ var scaffoldVideoCommand = defineCommand99({
     } catch (e) {
       return fail4("download", e instanceof Error ? e.message : String(e));
     }
-    const base = path21.basename(videoPath, path21.extname(videoPath));
-    const outPath = args.out ? path21.resolve(String(args.out)) : slug ? path21.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path21.join(path21.dirname(videoPath), `${base}.video.canvas.json`);
-    const outDir = path21.dirname(outPath);
-    const blueprintPath = path21.join(outDir, "prompt.json");
-    const blueprintStylePath = path21.join(outDir, "prompt.style.json");
+    const base = path22.basename(videoPath, path22.extname(videoPath));
+    const outPath = args.out ? path22.resolve(String(args.out)) : slug ? path22.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path22.join(path22.dirname(videoPath), `${base}.video.canvas.json`);
+    const outDir = path22.dirname(outPath);
+    const blueprintPath = path22.join(outDir, "prompt.json");
+    const blueprintStylePath = path22.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)) {
@@ -26769,7 +26864,7 @@ var scaffoldVideoCommand = defineCommand99({
     await mkdir7(outDir, { recursive: true });
     const annotated = annotateBlueprintWithElements(blueprint, elements);
     await writeSceneFiles(outDir, annotated);
-    await writeFile8(blueprintStylePath, renderStyleProjectionFromValue(annotated), "utf8");
+    await writeFile9(blueprintStylePath, renderStyleProjectionFromValue(annotated), "utf8");
     let aspect;
     try {
       aspect = resolveAspect(
@@ -26787,10 +26882,10 @@ var scaffoldVideoCommand = defineCommand99({
 `
       );
     }
-    const compositionDest = path21.join(outDir, "video-overlay-composition");
+    const compositionDest = path22.join(outDir, "video-overlay-composition");
     await cp(SHIPPED_COMPOSITION_DIR, compositionDest, { recursive: true });
     await stampCompositionDims(compositionDest, outDims);
-    const indexPath = path21.join(compositionDest, "index.html");
+    const indexPath = path22.join(compositionDest, "index.html");
     const overlayHtml = buildOverlayHtml(blueprint, { captionsActive: Boolean(transcript) });
     const indexHtml = await readFile15(indexPath, "utf8");
     const injected = indexHtml.replace("<!--OVERLAYS-->", () => overlayHtml);
@@ -26800,16 +26895,16 @@ var scaffoldVideoCommand = defineCommand99({
         `video-overlay-composition/index.html is missing the <!--OVERLAYS--> marker \u2014 cannot inject the overlay layer`
       );
     }
-    await writeFile8(indexPath, injected, "utf8");
+    await writeFile9(indexPath, injected, "utf8");
     const captions = await stageCaptions(outDir, transcript);
     if (captions.compositionPath) await stampCompositionDims(captions.compositionPath, outDims);
     const opts = {
       imageModel,
       videoModel,
-      overlayCompositionPath: path21.relative(outDir, compositionDest),
-      captionsCompositionPath: captions.compositionPath ? path21.relative(outDir, captions.compositionPath) : void 0,
-      blueprintPath: path21.relative(outDir, blueprintPath),
-      blueprintStylePath: path21.relative(outDir, blueprintStylePath),
+      overlayCompositionPath: path22.relative(outDir, compositionDest),
+      captionsCompositionPath: captions.compositionPath ? path22.relative(outDir, captions.compositionPath) : void 0,
+      blueprintPath: path22.relative(outDir, blueprintPath),
+      blueprintStylePath: path22.relative(outDir, blueprintStylePath),
       frames,
       ambient: Boolean(args.ambient),
       seamDedup: resolveSeamDedup(args["seam-dedup"]),
@@ -26834,10 +26929,10 @@ var scaffoldVideoCommand = defineCommand99({
       todo.blocking_validation_issues = validation.issues;
       meta.todo = todo;
     }
-    await writeFile8(outPath, `${JSON.stringify(canvas, null, 2)}
+    await writeFile9(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
-    await writeFile8(
-      path21.join(outDir, REBUILD_FILE),
+    await writeFile9(
+      path22.join(outDir, REBUILD_FILE),
       `${JSON.stringify({ elements, opts }, null, 2)}
 `,
       "utf8"
@@ -26862,9 +26957,9 @@ var scaffoldVideoCommand = defineCommand99({
     await ensureGitignore(process.cwd(), ["canvas/", ".context/"]);
     const sourceRef = videoSourceReference(blueprint, fileArg2);
     if (slug) {
-      const definitionPath = path21.join(outDir, "_definition.md");
+      const definitionPath = path22.join(outDir, "_definition.md");
       if (!await fileExists2(definitionPath)) {
-        await writeFile8(
+        await writeFile9(
           definitionPath,
           buildCreativeDefinition({
             title: titleFromSlug(slug),
@@ -26917,7 +27012,7 @@ var scaffoldVideoCommand = defineCommand99({
             graph: canvas.metadata?.video?.graph_stats
           },
           checklist: {
-            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 \`${path21.basename(blueprintPath)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path21.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 ${path21.basename(blueprintStylePath)}; both are regenerated.`,
+            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 \`${path22.basename(blueprintPath)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path22.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 ${path22.basename(blueprintStylePath)}; both are regenerated.`,
             recurring_elements_to_supply: report.elements,
             voices_to_confirm: report.dialogue.map((d) => ({
               scene: d.scene,
@@ -26954,8 +27049,8 @@ var scaffoldVideoCommand = defineCommand99({
 });
 
 // src/commands/canvas/set-prompt.ts
-import { readFile as readFile16, writeFile as writeFile9 } from "fs/promises";
-import path22 from "path";
+import { readFile as readFile16, writeFile as writeFile10 } from "fs/promises";
+import path23 from "path";
 import { defineCommand as defineCommand100 } from "citty";
 function setNodePrompt(canvas, nodeId, text2) {
   const nodes = canvas?.nodes;
@@ -26983,7 +27078,7 @@ var setPromptCommand = defineCommand100({
     "text-file": { type: "string", description: "Read the new prompt from a UTF-8 file (preserves accents/newlines)" }
   },
   async run({ args }) {
-    const filePath = path22.resolve(String(args.file));
+    const filePath = path23.resolve(String(args.file));
     let canvas;
     try {
       canvas = JSON.parse(await readFile16(filePath, "utf8"));
@@ -26993,7 +27088,7 @@ var setPromptCommand = defineCommand100({
       process.exit(2);
     }
     let text2;
-    if (args["text-file"]) text2 = await readFile16(path22.resolve(String(args["text-file"])), "utf8");
+    if (args["text-file"]) text2 = await readFile16(path23.resolve(String(args["text-file"])), "utf8");
     else if (args.text !== void 0) text2 = String(args.text);
     else {
       process.stderr.write(
@@ -27014,14 +27109,14 @@ var setPromptCommand = defineCommand100({
       process.exit(2);
       return;
     }
-    const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(updated, path22.dirname(filePath)), defaultRegistry());
+    const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(updated, path23.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 writeFile9(filePath, `${JSON.stringify(updated, null, 2)}
+    await writeFile10(filePath, `${JSON.stringify(updated, null, 2)}
 `, "utf8");
     process.stdout.write(`${JSON.stringify({ ok: true, node: String(args.node), bytes: text2.length }, null, 2)}
 `);
@@ -27030,7 +27125,7 @@ var setPromptCommand = defineCommand100({
 
 // src/commands/canvas/validate.ts
 import { readFile as readFile17 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import { defineCommand as defineCommand101 } from "citty";
 var validateCommand = defineCommand101({
   meta: {
@@ -27039,7 +27134,7 @@ var validateCommand = defineCommand101({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args }) {
-    const filePath = path23.resolve(String(args.file));
+    const filePath = path24.resolve(String(args.file));
     const raw = await readFile17(filePath, "utf8");
     let parsed;
     try {
@@ -27050,7 +27145,9 @@ var validateCommand = defineCommand101({
 `);
       process.exit(2);
     }
-    parsed = resolveRelativeCanvasPaths(parsed, path23.dirname(filePath));
+    const healed = await healAbsoluteCanvasPaths(filePath, parsed);
+    parsed = healed.canvas;
+    parsed = resolveRelativeCanvasPaths(parsed, path24.dirname(filePath));
     let styleProjection = "not_applicable";
     try {
       styleProjection = await syncStyleProjection(parsed, (line) => process.stderr.write(`${line}
@@ -27091,6 +27188,7 @@ var validateCommand = defineCommand101({
           cost_preview: result.perNodeCredits ?? [],
           style_projection: styleProjection,
           scene_projection: sceneProjection,
+          normalized_paths: healed.rewrites,
           warnings: result.warnings ?? []
         },
         null,
@@ -27695,14 +27793,14 @@ Full guide: __tooling__/docs/tools/baker/creatives.md`
 import { defineCommand as defineCommand107 } from "citty";
 
 // src/commands/flows/shared.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync9 } from "fs";
 import { join as join3 } from "path";
 var FLOWS_DIR = "src/lib/flow-engine/flows";
 function flowsDir() {
   let dir = process.cwd();
   for (let i = 0; i < 6; i++) {
     const candidate = join3(dir, FLOWS_DIR);
-    if (existsSync4(candidate)) {
+    if (existsSync5(candidate)) {
       return candidate;
     }
     const parent = join3(dir, "..");
@@ -27719,18 +27817,18 @@ function failLocal(message) {
 }
 function listFlowSlugs() {
   const dir = flowsDir();
-  if (!existsSync4(dir)) {
+  if (!existsSync5(dir)) {
     return [];
   }
   return readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
 }
 function readFlowTree(slug) {
-  const path35 = join3(flowsDir(), slug, "_data.json");
-  if (!existsSync4(path35)) {
+  const path36 = join3(flowsDir(), slug, "_data.json");
+  if (!existsSync5(path36)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync9(path35, "utf-8"));
+    return JSON.parse(readFileSync9(path36, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -28143,10 +28241,10 @@ async function stageOps(ops) {
     handleError(err);
   }
 }
-async function draftAction2(path35, body, chat) {
+async function draftAction2(path36, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path35, { chatId, ...body });
+    const data = await apiPost(path36, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -28392,7 +28490,7 @@ Examples:
 });
 
 // src/commands/ga4/query.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
 import { resolve as resolve2 } from "path";
 import { defineCommand as defineCommand112 } from "citty";
 
@@ -28466,7 +28564,7 @@ function writeRowsToFile2(filePath, rows, append) {
   const fields = extractFields2(rows);
   const ext = filePath.split(".").pop()?.toLowerCase();
   if (ext === "csv") {
-    if (!append || !existsSync5(filePath)) {
+    if (!append || !existsSync6(filePath)) {
       writeFileSync3(filePath, `${toCsvRow(fields)}
 `, "utf-8");
     }
@@ -28477,12 +28575,12 @@ function writeRowsToFile2(filePath, rows, append) {
     const lines = rows.map((row) => JSON.stringify(row));
     const content = `${lines.join("\n")}
 `;
-    if (append && existsSync5(filePath)) {
+    if (append && existsSync6(filePath)) {
       appendFileSync2(filePath, content, "utf-8");
     } else {
       writeFileSync3(filePath, content, "utf-8");
     }
-  } else if (append && existsSync5(filePath)) {
+  } else if (append && existsSync6(filePath)) {
     const existing = JSON.parse(readFileSync11(filePath, "utf-8"));
     writeFileSync3(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
@@ -29006,7 +29104,7 @@ Full guide: __tooling__/docs/tools/baker/ga4.md`
 import { defineCommand as defineCommand118 } from "citty";
 
 // src/commands/gsc/query.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve3 } from "path";
 import { defineCommand as defineCommand115 } from "citty";
 
@@ -29138,7 +29236,7 @@ function writeRowsToFile3(filePath, rows, append) {
   const fields = extractFields3(rows);
   const ext = filePath.split(".").pop()?.toLowerCase();
   if (ext === "csv") {
-    if (!append || !existsSync6(filePath)) {
+    if (!append || !existsSync7(filePath)) {
       writeFileSync4(filePath, `${toCsvRow(fields)}
 `, "utf-8");
     }
@@ -29148,12 +29246,12 @@ function writeRowsToFile3(filePath, rows, append) {
   } else if (ext === "jsonl") {
     const content = `${rows.map((row) => JSON.stringify(row)).join("\n")}
 `;
-    if (append && existsSync6(filePath)) {
+    if (append && existsSync7(filePath)) {
       appendFileSync3(filePath, content, "utf-8");
     } else {
       writeFileSync4(filePath, content, "utf-8");
     }
-  } else if (append && existsSync6(filePath)) {
+  } else if (append && existsSync7(filePath)) {
     const existing = JSON.parse(readFileSync12(filePath, "utf-8"));
     writeFileSync4(filePath, JSON.stringify([...existing, ...rows], null, 2), "utf-8");
   } else {
@@ -30132,7 +30230,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile19, rename, stat as stat4, writeFile as writeFile10 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile19, rename, stat as stat4, writeFile as writeFile11 } 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 = /[*?[\]{}]/;
@@ -30167,9 +30265,9 @@ async function readImageBuffer(pathOrUrl) {
   }
   return readFile19(pathOrUrl);
 }
-async function isDirectory(path35) {
+async function isDirectory(path36) {
   try {
-    const s = await stat4(path35);
+    const s = await stat4(path36);
     return s.isDirectory();
   } catch {
     return false;
@@ -30188,7 +30286,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 writeFile10(tmp, data);
+  await writeFile11(tmp, data);
   await rename(tmp, absolute);
 }
 
@@ -30453,13 +30551,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path35) => {
-    if (!taken.has(path35)) {
-      taken.add(path35);
-      return path35;
+  return paths.map((path36) => {
+    if (!taken.has(path36)) {
+      taken.add(path36);
+      return path36;
     }
-    const ext = extname3(path35);
-    const stem = path35.slice(0, path35.length - ext.length);
+    const ext = extname3(path36);
+    const stem = path36.slice(0, path36.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -30586,10 +30684,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path35 = paths[index] ?? item.path;
+    const path36 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path35, item.buffer);
-      downloaded.push({ input: item.input, output: path35, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path36, item.buffer);
+      downloaded.push({ input: item.input, output: path36, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -33529,12 +33627,12 @@ import { defineCommand as defineCommand157 } from "citty";
 
 // src/commands/landing/critique.ts
 import { readdir as readdir8, stat as stat6 } from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 import { defineCommand as defineCommand147 } from "citty";
 
 // src/engine/landing/lib/brand-tokens.ts
 import { readFile as readFile20 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 
 // src/engine/landing/lib/color.ts
 var NEUTRAL_COLOR_KEYWORDS = /* @__PURE__ */ new Set([
@@ -33711,7 +33809,7 @@ function brandTokensFromCanonical(tokens) {
   return { fonts, colors, hasTokens: fonts.size > 0 || colors.length > 0 };
 }
 async function loadBrandTokens(projectRoot) {
-  const tokensRaw = await safeRead(path24.join(projectRoot, "src", "brand", "tokens.json"));
+  const tokensRaw = await safeRead(path25.join(projectRoot, "src", "brand", "tokens.json"));
   if (tokensRaw) {
     try {
       const canonical2 = brandTokensSchema.safeParse(JSON.parse(tokensRaw));
@@ -33719,8 +33817,8 @@ async function loadBrandTokens(projectRoot) {
     } catch {
     }
   }
-  const globalCss = await safeRead(path24.join(projectRoot, "src", "styles", "global.css"));
-  const brandMd = await safeRead(path24.join(projectRoot, "src", "brand", "BRAND.md"));
+  const globalCss = await safeRead(path25.join(projectRoot, "src", "styles", "global.css"));
+  const brandMd = await safeRead(path25.join(projectRoot, "src", "brand", "BRAND.md"));
   if (!globalCss && !brandMd) return EMPTY;
   return parseBrandTokens(globalCss, brandMd);
 }
@@ -34781,13 +34879,13 @@ function describeCounts(findings) {
 }
 
 // src/engine/landing/lib/referenceStore.ts
-import { mkdir as mkdir8, readFile as readFile21, writeFile as writeFile11 } from "fs/promises";
-import path25 from "path";
+import { mkdir as mkdir8, readFile as readFile21, writeFile as writeFile12 } from "fs/promises";
+import path26 from "path";
 var REFERENCES_FILE = ".cache/inspiration-refs.json";
 var REFERENCE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 async function readReferences(projectRoot) {
   try {
-    const raw = await readFile21(path25.join(projectRoot, REFERENCES_FILE), "utf8");
+    const raw = await readFile21(path26.join(projectRoot, REFERENCES_FILE), "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     const cutoff = Date.now() - REFERENCE_TTL_MS;
@@ -34811,9 +34909,9 @@ async function recordReferences(projectRoot, references) {
     const existing = await readReferences(projectRoot);
     const replaced = new Set(references.map((reference) => reference.sectionId));
     const merged = [...existing.filter((entry) => !replaced.has(entry.sectionId)), ...references];
-    const file = path25.join(projectRoot, REFERENCES_FILE);
-    await mkdir8(path25.dirname(file), { recursive: true });
-    await writeFile11(file, `${JSON.stringify(merged, null, 2)}
+    const file = path26.join(projectRoot, REFERENCES_FILE);
+    await mkdir8(path26.dirname(file), { recursive: true });
+    await writeFile12(file, `${JSON.stringify(merged, null, 2)}
 `);
     return true;
   } catch {
@@ -34822,40 +34920,40 @@ async function recordReferences(projectRoot, references) {
 }
 
 // src/commands/landing/snapshot.ts
-import { mkdir as mkdir9, rename as rename2, writeFile as writeFile12 } from "fs/promises";
-import path26 from "path";
+import { mkdir as mkdir9, rename as rename2, writeFile as writeFile13 } from "fs/promises";
+import path27 from "path";
 var CRITIC_VERSION = "2";
 function critiqueCacheDir(projectRoot) {
-  return path26.join(projectRoot, ".cache", "landing-critique");
+  return path27.join(projectRoot, ".cache", "landing-critique");
 }
 function snapshotPath(projectRoot, slug) {
-  return path26.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+  return path27.join(critiqueCacheDir(projectRoot), `${slug}.json`);
 }
 async function writeCritiqueSnapshot(projectRoot, snapshot) {
   await mkdir9(critiqueCacheDir(projectRoot), { recursive: true });
   const dest = snapshotPath(projectRoot, snapshot.slug);
   const tmp = `${dest}.tmp`;
-  await writeFile12(tmp, `${JSON.stringify(snapshot, null, 2)}
+  await writeFile13(tmp, `${JSON.stringify(snapshot, null, 2)}
 `, "utf8");
   await rename2(tmp, dest);
 }
 
 // src/commands/landing/source-version.ts
 import { readdir as readdir7, readFile as readFile22, stat as stat5 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 async function landingSourceRelPaths(landingDir) {
   const rel = [];
-  if (await isFile(path27.join(landingDir, "index.astro"))) rel.push("index.astro");
-  const componentsDir = path27.join(landingDir, "_components");
+  if (await isFile(path28.join(landingDir, "index.astro"))) rel.push("index.astro");
+  const componentsDir = path28.join(landingDir, "_components");
   for (const abs of await walkAstro(componentsDir)) {
-    rel.push(path27.relative(landingDir, abs).split(path27.sep).join("/"));
+    rel.push(path28.relative(landingDir, abs).split(path28.sep).join("/"));
   }
   return rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
 }
 async function readLandingSources(landingDir) {
   const rel = await landingSourceRelPaths(landingDir);
   const out = [];
-  for (const r of rel) out.push({ path: r, text: await readFile22(path27.join(landingDir, r), "utf8") });
+  for (const r of rel) out.push({ path: r, text: await readFile22(path28.join(landingDir, r), "utf8") });
   return out;
 }
 async function computeLandingSourceSha(landingDir) {
@@ -34864,7 +34962,7 @@ async function computeLandingSourceSha(landingDir) {
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile22(path27.join(landingDir, r));
+      bytes = await readFile22(path28.join(landingDir, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -34888,7 +34986,7 @@ async function walkAstro(dir) {
   }
   const out = [];
   for (const entry of entries) {
-    const abs = path27.join(dir, entry.name);
+    const abs = path28.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkAstro(abs));
     else if (entry.isFile() && entry.name.endsWith(".astro")) out.push(abs);
   }
@@ -34949,7 +35047,7 @@ var critiqueCommand2 = defineCommand147({
           { availableSlugs: await listLandingSlugs(projectRoot) }
         );
       }
-      if (!await isDir(path28.resolve(projectRoot, "src", "pages", slug))) {
+      if (!await isDir(path29.resolve(projectRoot, "src", "pages", slug))) {
         fail5("NOT_FOUND", `No landing at src/pages/${slug}/`, {
           availableSlugs: await listLandingSlugs(projectRoot)
         });
@@ -34988,7 +35086,7 @@ var critiqueCommand2 = defineCommand147({
   }
 });
 async function critiqueOne(projectRoot, slug, brand, references) {
-  const landingDir = path28.resolve(projectRoot, "src", "pages", slug);
+  const landingDir = path29.resolve(projectRoot, "src", "pages", slug);
   const [sources, sourceSha] = await Promise.all([readLandingSources(landingDir), computeLandingSourceSha(landingDir)]);
   const report = critiqueLanding({ slug, sources, brand, references });
   let snapshotFailed = false;
@@ -35008,7 +35106,7 @@ async function critiqueOne(projectRoot, slug, brand, references) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir8(path28.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir8(path29.join(projectRoot, "src", "pages"), { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return [];
@@ -35159,8 +35257,8 @@ var addCommand = defineCommand148({
 });
 
 // src/commands/landing/inspiration/code.ts
-import { mkdir as mkdir10, writeFile as writeFile13 } from "fs/promises";
-import path29 from "path";
+import { mkdir as mkdir10, writeFile as writeFile14 } from "fs/promises";
+import path30 from "path";
 import { defineCommand as defineCommand149 } from "citty";
 registerSchema({
   command: "landing.inspiration.code",
@@ -35183,10 +35281,10 @@ var codeCommand = defineCommand149({
     try {
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section-code", { id });
-      const dir = path29.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path30.join(process.cwd(), ".baker", "inspiration", id);
       await mkdir10(dir, { recursive: true });
-      const file = path29.join(dir, "section.html");
-      await writeFile13(file, data.html);
+      const file = path30.join(dir, "section.html");
+      await writeFile14(file, data.html);
       const recorded = await recordReference(process.cwd(), {
         sectionId: id,
         sourceUrl: data.sourceUrl,
@@ -35206,7 +35304,7 @@ var codeCommand = defineCommand149({
         ok: true,
         data: {
           id,
-          file: path29.relative(process.cwd(), file),
+          file: path30.relative(process.cwd(), file),
           bytes: data.html.length,
           fidelity: data.fidelity,
           reproduction_notes: data.reproductionNotes,
@@ -35462,7 +35560,7 @@ var pageCommand = defineCommand151({
 
 // src/commands/landing/inspiration/scrape.ts
 import { readFile as readFile23 } from "fs/promises";
-import path32 from "path";
+import path33 from "path";
 import { defineCommand as defineCommand152 } from "citty";
 
 // src/engine/landing/lib/capturedReferences.ts
@@ -35654,8 +35752,8 @@ function classifyCaptureFailure(error) {
 }
 
 // src/engine/landing-library/run.ts
-import { mkdir as mkdir11, writeFile as writeFile15 } from "fs/promises";
-import path31 from "path";
+import { mkdir as mkdir11, writeFile as writeFile16 } from "fs/promises";
+import path32 from "path";
 
 // ../proxy/src/preflight.ts
 import http from "http";
@@ -37070,11 +37168,11 @@ async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
 }
 
 // src/engine/landing-library/report.ts
-import { writeFile as writeFile14 } from "fs/promises";
-import path30 from "path";
+import { writeFile as writeFile15 } from "fs/promises";
+import path31 from "path";
 async function writeCaptureReport(manifest, outDir) {
-  const file = path30.join(outDir, "report.html");
-  await writeFile14(file, renderReport(manifest));
+  const file = path31.join(outDir, "report.html");
+  await writeFile15(file, renderReport(manifest));
   return file;
 }
 function escapeHtml3(value) {
@@ -37252,32 +37350,32 @@ async function reproducePage(args) {
   const { browser, page, outDir, pageUrl, livePageShot } = args;
   const built = await buildSectionBundle(page, "body", pageUrl).catch(() => null);
   if (!built) return { bundle: null, fidelity: null };
-  await writeFile15(path31.join(outDir, "page.html"), built.html);
+  await writeFile16(path32.join(outDir, "page.html"), built.html);
   const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width, {
     wholePage: true,
     timeoutMs: 6e4
   });
   if (!rendered || !livePageShot) return { bundle: "page.html", fidelity: null };
-  await writeFile15(path31.join(outDir, "page-rendered.png"), rendered);
+  await writeFile16(path32.join(outDir, "page-rendered.png"), rendered);
   const { score, note } = await scoreFidelity(livePageShot, rendered);
   return { bundle: "page.html", fidelity: score, ...note ? { fidelityNote: note } : {} };
 }
 async function captureOneSection(args) {
   const { browser, page, candidate, sectionsDir, outDir, pageUrl, withCode } = args;
-  const dir = path31.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  const dir = path32.join(sectionsDir, String(candidate.index).padStart(2, "0"));
   await mkdir11(dir, { recursive: true });
   const desktop = await captureSection(page, candidate);
-  if (desktop) await writeFile15(path31.join(dir, "desktop.png"), desktop);
+  if (desktop) await writeFile16(path32.join(dir, "desktop.png"), desktop);
   const visualHash = desktop ? await perceptualHash(desktop) : null;
   const motion = await collectMotion(page, candidate.selector);
   const built = withCode ? await buildSectionBundle(page, candidate.selector, pageUrl) : null;
   let fidelity = null;
   let fidelityNote;
   if (built) {
-    await writeFile15(path31.join(dir, "section.html"), built.html);
+    await writeFile16(path32.join(dir, "section.html"), built.html);
     const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
     if (rendered && desktop) {
-      await writeFile15(path31.join(dir, "section-rendered.png"), rendered);
+      await writeFile16(path32.join(dir, "section-rendered.png"), rendered);
       const result = await scoreFidelity(desktop, rendered);
       fidelity = result.score;
       fidelityNote = result.note;
@@ -37285,9 +37383,9 @@ async function captureOneSection(args) {
   }
   return {
     ...candidate,
-    desktopShot: desktop ? path31.relative(outDir, path31.join(dir, "desktop.png")) : null,
+    desktopShot: desktop ? path32.relative(outDir, path32.join(dir, "desktop.png")) : null,
     mobileShot: null,
-    bundle: built ? path31.relative(outDir, path31.join(dir, "section.html")) : null,
+    bundle: built ? path32.relative(outDir, path32.join(dir, "section.html")) : null,
     fidelity,
     ...fidelityNote ? { fidelityNote } : {},
     ...built ? { cssStats: built.stats } : {},
@@ -37306,9 +37404,9 @@ async function captureMobileShots(args) {
     for (const section of sections) {
       const shot = await captureSectionOnMobile(mobile.page, section);
       if (!shot) continue;
-      const file = path31.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
-      await writeFile15(file, shot);
-      section.mobileShot = path31.relative(outDir, file);
+      const file = path32.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      await writeFile16(file, shot);
+      section.mobileShot = path32.relative(outDir, file);
     }
   } finally {
     await mobile.context.close();
@@ -37323,10 +37421,10 @@ async function captureMotionTakes(args) {
   const filmOne = async (section) => {
     const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
     if (!take) return;
-    const dir = path31.join(sectionsDir, String(section.index).padStart(2, "0"));
-    const file = path31.join(dir, "motion-filmstrip.png");
-    await writeFile15(file, take.filmstrip);
-    section.motionFilmstrip = path31.relative(outDir, file);
+    const dir = path32.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path32.join(dir, "motion-filmstrip.png");
+    await writeFile16(file, take.filmstrip);
+    section.motionFilmstrip = path32.relative(outDir, file);
     log(`  [${section.index}] ${section.motion.summary}`);
   };
   const queue = [...moving];
@@ -37383,7 +37481,7 @@ async function captureAlternateViews(args) {
 async function reproduceWholePage(args) {
   const { browser, page, outDir, pageUrl, withCode, log } = args;
   const fullPage = await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
-  if (fullPage) await writeFile15(path31.join(outDir, "full-page.png"), fullPage);
+  if (fullPage) await writeFile16(path32.join(outDir, "full-page.png"), fullPage);
   if (!withCode) return { bundle: null, fidelity: null };
   const reproduction = await reproducePage({ browser, page, outDir, pageUrl, livePageShot: fullPage });
   log(`page reproduction: ${reproduction.fidelity === null ? "unavailable" : reproduction.fidelity.toFixed(2)}`);
@@ -37454,7 +37552,7 @@ async function openViaLadder(args) {
 async function scrapeLanding(options) {
   const timeoutMs = options.timeoutMs ?? 45e3;
   const log = options.onProgress ?? (() => void 0);
-  const sectionsDir = path31.join(options.outDir, "sections");
+  const sectionsDir = path32.join(options.outDir, "sections");
   const nonPublic = refuseNonPublicUrl(options.url);
   if (nonPublic) {
     throw new BlockedPageError({
@@ -37516,7 +37614,7 @@ async function scrapeLanding(options) {
       security: prepared.security,
       captureTier: tier
     };
-    await writeFile15(path31.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile16(path32.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     if (options.report !== false) {
       const reportPath = await writeCaptureReport(manifest, options.outDir);
@@ -37543,7 +37641,7 @@ async function recordCapture(manifest, outDir) {
   for (const section of manifest.sections) {
     if (!section.bundle) continue;
     try {
-      const markup = await readFile23(path32.join(outDir, section.bundle), "utf8");
+      const markup = await readFile23(path33.join(outDir, section.bundle), "utf8");
       const copyStrings = capturedCopyStrings(markup);
       if (copyStrings.length === 0) continue;
       references.push({
@@ -37705,8 +37803,8 @@ var scrapeCommand = defineCommand152({
 });
 
 // src/commands/landing/inspiration/search.ts
-import { mkdir as mkdir12, writeFile as writeFile16 } from "fs/promises";
-import path33 from "path";
+import { mkdir as mkdir12, writeFile as writeFile17 } from "fs/promises";
+import path34 from "path";
 import { defineCommand as defineCommand153 } from "citty";
 registerSchema({
   command: "landing.inspiration.search",
@@ -37793,7 +37891,7 @@ function buildSearchBody(args) {
   return body;
 }
 async function downloadShots(results) {
-  const dir = path33.join(process.cwd(), ".baker", "inspiration");
+  const dir = path34.join(process.cwd(), ".baker", "inspiration");
   await mkdir12(dir, { recursive: true });
   const saved = /* @__PURE__ */ new Map();
   await Promise.all(
@@ -37802,9 +37900,9 @@ async function downloadShots(results) {
       try {
         const response = await fetch(result.desktopShotUrl);
         if (!response.ok) return;
-        const file = path33.join(dir, `${result.id}.png`);
-        await writeFile16(file, Buffer.from(await response.arrayBuffer()));
-        saved.set(result.id, path33.relative(process.cwd(), file));
+        const file = path34.join(dir, `${result.id}.png`);
+        await writeFile17(file, Buffer.from(await response.arrayBuffer()));
+        saved.set(result.id, path34.relative(process.cwd(), file));
       } catch {
       }
     })
@@ -38032,8 +38130,8 @@ var sequencesCommand = defineCommand154({
 });
 
 // src/commands/landing/inspiration/view.ts
-import { mkdir as mkdir13, writeFile as writeFile17 } from "fs/promises";
-import path34 from "path";
+import { mkdir as mkdir13, writeFile as writeFile18 } from "fs/promises";
+import path35 from "path";
 import { defineCommand as defineCommand155 } from "citty";
 registerSchema({
   command: "landing.inspiration.view",
@@ -38052,9 +38150,9 @@ async function download(url, file) {
   try {
     const response = await fetch(url);
     if (!response.ok) return null;
-    await mkdir13(path34.dirname(file), { recursive: true });
-    await writeFile17(file, Buffer.from(await response.arrayBuffer()));
-    return path34.relative(process.cwd(), file);
+    await mkdir13(path35.dirname(file), { recursive: true });
+    await writeFile18(file, Buffer.from(await response.arrayBuffer()));
+    return path35.relative(process.cwd(), file);
   } catch {
     return null;
   }
@@ -38078,11 +38176,11 @@ var viewCommand2 = defineCommand155({
       const id = args.id;
       const data = await apiGet("/api/landing-inspiration/section", { id });
       const section = data.section;
-      const dir = path34.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path35.join(process.cwd(), ".baker", "inspiration", id);
       const [desktop, mobile, filmstrip] = await Promise.all([
-        download(section.desktopShotUrl, path34.join(dir, "desktop.png")),
-        download(section.mobileShotUrl, path34.join(dir, "mobile.png")),
-        download(section.motionFilmstripUrl, path34.join(dir, "motion-filmstrip.png"))
+        download(section.desktopShotUrl, path35.join(dir, "desktop.png")),
+        download(section.mobileShotUrl, path35.join(dir, "mobile.png")),
+        download(section.motionFilmstripUrl, path35.join(dir, "motion-filmstrip.png"))
       ]);
       const full = args.full;
       const hints = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
@@ -40300,7 +40398,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path35) => uploadLocalImage({ file: path35, contentType: detectImageContentType(path35), source: "uploaded" })
+  upload: (path36) => uploadLocalImage({ file: path36, contentType: detectImageContentType(path36), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -40320,10 +40418,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path35) {
+function uploadFailure(path36) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path35}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path36}" as an image.`);
   };
 }
 
@@ -41373,10 +41471,10 @@ async function stageOp4(op) {
     handleError4(err);
   }
 }
-async function draftAction3(path35, body, chat) {
+async function draftAction3(path36, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path35, { chatId, ...body });
+    const data = await apiPost(path36, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {