@koda-sl/baker-cli 0.352.0-dev.fabc18041 → 0.353.0-dev.0a55fe912

package/dist/cli.js

@@ -42,6 +42,7 @@ import {
   isAudioOnly,
   isPersistedAssetRef,
   isVimeoAuthFailure,
+  loadCompositionMeta,
   looksLikeHttpUrl,
   maxInputReferences,
   maxInputSlot,
@@ -68,7 +69,7 @@ import {
   validateCanvasDeep,
   withoutCastName,
   ytDlpBlockSignal
-} from "./chunk-B7MLH3K6.js";
+} from "./chunk-Q2VR3FVM.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -11035,41 +11036,6 @@ function adCopyHints(payload) {
   return tells.slice(0, MAX_HINTS).map(hintFor);
 }
 
-// src/commands/ads/google/copy-list-usage.ts
-var AD_COPY_LIST_USAGE = `repeat the flag once per item, or pass one comma-separated list and wrap an item that contains a comma in double quotes: '"Fast, free quotes",Book today'. A flag given once is read as a list, so a lone item with a comma needs its double quotes too: '"Fast, free quotes"'`;
-var COPY_LIST_FLAG = {
-  headlines: "--headlines",
-  descriptions: "--descriptions",
-  longHeadlines: "--long-headlines"
-};
-function valueAt(root, path48) {
-  let node = root;
-  for (const key of path48) {
-    if (node === null || typeof node !== "object") return void 0;
-    node = node[key];
-  }
-  return node;
-}
-function countRefusal(op, issue) {
-  if (issue.code !== "too_big" && issue.code !== "too_small" || issue.origin !== "array") return void 0;
-  const flag = COPY_LIST_FLAG[String(issue.path.at(-1))];
-  if (!flag) return void 0;
-  const value = valueAt(op, issue.path);
-  const count2 = Array.isArray(value) ? value.length : void 0;
-  return issue.code === "too_big" ? { flag, count: count2, bound: `at most ${issue.maximum}`, tooMany: true } : { flag, count: count2, bound: `at least ${issue.minimum}`, tooMany: false };
-}
-function copyListCountFix(op, issues) {
-  const refusals = issues.map((issue) => countRefusal(op, issue));
-  if (refusals.length === 0 || refusals.some((refusal) => refusal === void 0)) return void 0;
-  const counted = refusals.filter((refusal) => refusal !== void 0);
-  const limits = counted.map(({ flag, count: count2, bound }) => `${flag} has ${count2 ?? "the wrong number of"} items; this ad takes ${bound}.`).join(" ");
-  const commaCause = counted.some((refusal) => refusal.tooMany) ? ` If you meant fewer items, the copy was cut at its commas: a flag given once is read as a comma-separated list, so an item with a comma in it ("Fast, free quotes", a decimal like "4,5/5") becomes two. To keep a comma, ${AD_COPY_LIST_USAGE} \u2014 or put the content in --file as JSON.` : "";
-  return {
-    action: "fix_copy_list_count",
-    explanation: `${limits}${commaCause} ${commaCause ? "Otherwise add" : "Add"} or drop items to fit the limit, then stage again; the field names are right.`
-  };
-}
-
 // src/commands/ads/google/draft-status.ts
 var OPERATION_LABELS = {
   create: "Creating",
@@ -11390,7 +11356,7 @@ async function stageGoogleOp(raw, hints2) {
         code: "VALIDATION_ERROR",
         message: fields.map((f) => f.path ? `${f.path}: ${f.message}` : f.message).join("; "),
         fields,
-        fix: copyListCountFix(raw, preflight.error.issues) ?? capabilityFix("google-ads")
+        fix: capabilityFix("google-ads")
       }
     });
     process.exit(1);
@@ -11426,7 +11392,7 @@ async function stageGoogleOps(rawOps, hints2) {
           code: "VALIDATION_ERROR",
           message: fields.map((f) => `${f.path}: ${f.message}`).join("; "),
           fields,
-          fix: copyListCountFix(raw, preflight.error.issues) ?? capabilityFix("google-ads")
+          fix: capabilityFix("google-ads")
         }
       });
       process.exit(1);
@@ -16833,6 +16799,7 @@ import { defineCommand as defineCommand31 } from "citty";
 
 // src/commands/ads/google/ad-copy-flags.ts
 var AD_COPY_LIST_FLAGS = ["headlines", "descriptions", "long-headlines"];
+var AD_COPY_LIST_USAGE = `repeat the flag once per item, or pass one comma-separated list and wrap an item that contains a comma in double quotes: '"Fast, free quotes",Book today'. A flag given once is read as a list, so a lone item with a comma needs its double quotes too: '"Fast, free quotes"'`;
 function skipBlanks(value, at) {
   let i = at;
   while (value[i] === " " || value[i] === "	") i++;
@@ -35565,7 +35532,49 @@ import { defineCommand as defineCommand119 } from "citty";
 
 // src/commands/canvas/catalog.ts
 import { defineCommand as defineCommand108 } from "citty";
-var DESCRIPTION = "The canvas node catalog. Start here: `baker canvas catalog` lists every node by category with one line each (a few KB). Then `--node video_generate` prints that node's full JSON Schema \u2014 params, inputs, outputs, models, when to use it. `--category image` narrows the list; add `--full` for that category's schemas. `--full` alone prints every schema (~160 KB) \u2014 prefer `--node`.";
+
+// src/commands/canvas/composition-path.ts
+import { existsSync as existsSync4 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import path3 from "path";
+function resolveShippedCanvasDir(name, startDir, exists2 = existsSync4, maxDepth = 8) {
+  const rel = path3.join("canvas", name);
+  let dir = startDir;
+  for (let i = 0; i < maxDepth; i++) {
+    const candidate = path3.join(dir, rel);
+    if (exists2(path3.join(candidate, "meta.json"))) return candidate;
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path3.resolve(startDir, "../../../", rel);
+}
+async function listShippedCompositions(startDir, maxDepth = 8) {
+  let dir = startDir;
+  for (let i = 0; i < maxDepth; i++) {
+    const root = path3.join(dir, "canvas");
+    const found = await compositionsIn(root);
+    if (found.length > 0) return found.sort((a, b) => a.id.localeCompare(b.id));
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return [];
+}
+async function compositionsIn(root) {
+  const children = await readdir2(root, { withFileTypes: true }).catch(() => []);
+  const loaded = await Promise.all(
+    children.filter((child) => child.isDirectory()).map(async (child) => {
+      const compositionDir = path3.join(root, child.name);
+      const meta = await loadCompositionMeta(compositionDir).catch(() => null);
+      return meta ? { id: meta.id, title: meta.title, dir: compositionDir } : null;
+    })
+  );
+  return loaded.filter((c) => c !== null);
+}
+
+// src/commands/canvas/catalog.ts
+var DESCRIPTION = "The canvas node catalog. Start here: `baker canvas catalog` lists every node by category with one line each (a few KB). Then `--node video_generate` prints that node's full JSON Schema \u2014 params, inputs, outputs, models, when to use it. `--category image` narrows the list; add `--full` for that category's schemas. `--full` alone prints every schema (~160 KB) \u2014 prefer `--node`. The unfiltered list also carries `compositions` \u2014 ready-made motion graphics, each with the `dir` to copy next to your canvas.";
 var ARGS = {
   node: {
     type: "string",
@@ -35584,12 +35593,16 @@ var ARGS = {
     description: "Print full JSON Schemas instead of the one-line index (every node, or the --category)."
   }
 };
+async function canvasCatalog(opts) {
+  const compositions = await listShippedCompositions(import.meta.dirname);
+  return catalogView(generateCatalog(defaultRegistry(), { compositions }), opts);
+}
 registerSchema({ command: "canvas.catalog", description: DESCRIPTION, args: ARGS });
 var catalogCommand = defineCommand108({
   meta: { name: "catalog", description: DESCRIPTION },
   args: ARGS,
   async run({ args: args5 }) {
-    const view = catalogView(generateCatalog(defaultRegistry()), {
+    const view = await canvasCatalog({
       node: typeof args5.node === "string" ? args5.node : void 0,
       category: typeof args5.category === "string" ? args5.category : void 0,
       full: args5.full === true
@@ -35602,7 +35615,7 @@ var catalogCommand = defineCommand108({
 
 // src/commands/canvas/critique.ts
 import { readFile as readFile3 } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 import { defineCommand as defineCommand109 } from "citty";
 
 // src/engine/scaffold/lib/critique.ts
@@ -35730,7 +35743,7 @@ var critiqueCommand = defineCommand109({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args: args5 }) {
-    const filePath = path3.resolve(String(args5.file));
+    const filePath = path4.resolve(String(args5.file));
     const raw = await readFile3(filePath, "utf8");
     let parsed;
     try {
@@ -35762,8 +35775,8 @@ var critiqueCommand = defineCommand109({
 
 // src/commands/canvas/inspect.ts
 import { execFile } from "child_process";
-import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
-import path4 from "path";
+import { readdir as readdir3, readFile as readFile4, stat } from "fs/promises";
+import path5 from "path";
 import { promisify } from "util";
 import { defineCommand as defineCommand110 } from "citty";
 var execFileAsync = promisify(execFile);
@@ -35781,7 +35794,7 @@ var inspectCommand = defineCommand110({
     }
   },
   async run({ args: args5 }) {
-    const outputsDir = path4.resolve(String(args5["outputs-dir"] ?? "canvas"));
+    const outputsDir = path5.resolve(String(args5["outputs-dir"] ?? "canvas"));
     const runArg = String(args5.run);
     const runDir = await resolveRunDir(runArg, outputsDir);
     const manifest = await loadManifest(runDir);
@@ -35793,7 +35806,7 @@ var inspectCommand = defineCommand110({
     }
     const summary = {
       ok: true,
-      run_id: manifest.run_id ?? path4.basename(runDir),
+      run_id: manifest.run_id ?? path5.basename(runDir),
       run_dir: runDir,
       stats: manifest.stats ?? null,
       output: manifest.output ?? null,
@@ -35806,18 +35819,18 @@ var inspectCommand = defineCommand110({
   }
 });
 async function resolveRunDir(run, outputsDir) {
-  if (path4.isAbsolute(run)) {
+  if (path5.isAbsolute(run)) {
     const s2 = await stat(run).catch(() => null);
     if (s2?.isDirectory()) return run;
     throw new Error(`inspect: ${run} is not a directory`);
   }
-  const candidate = path4.join(outputsDir, run);
+  const candidate = path5.join(outputsDir, run);
   const s = await stat(candidate).catch(() => null);
   if (s?.isDirectory()) return candidate;
   throw new Error(`inspect: no run directory at ${candidate}`);
 }
 async function loadManifest(runDir) {
-  const manifestPath = path4.join(runDir, "manifest.json");
+  const manifestPath = path5.join(runDir, "manifest.json");
   try {
     const raw = await readFile4(manifestPath, "utf-8");
     return JSON.parse(raw);
@@ -35827,9 +35840,9 @@ async function loadManifest(runDir) {
 }
 async function listRunFiles(runDir) {
   const out = [];
-  const names = await readdir2(runDir);
+  const names = await readdir3(runDir);
   for (const name of names) {
-    const abs = path4.join(runDir, name);
+    const abs = path5.join(runDir, name);
     const s = await stat(abs).catch(() => null);
     if (!s?.isFile()) continue;
     out.push({ name, path: abs, size: s.size });
@@ -35874,58 +35887,58 @@ async function probeDuration(filePath) {
 }
 
 // src/commands/canvas/rerun.ts
-import path17 from "path";
+import path18 from "path";
 import { defineCommand as defineCommand112 } from "citty";
 
 // src/commands/canvas/run.ts
 import { readFile as readFile12 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import { defineCommand as defineCommand111 } from "citty";
 
 // src/commands/canvas/normalize-paths.ts
-import { existsSync as existsSync4, realpathSync } from "fs";
+import { existsSync as existsSync5, realpathSync } from "fs";
 import { writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
-function findWorkspaceRoot(startDir, exists2 = existsSync4, maxDepth = 12) {
-  let dir = path5.resolve(startDir);
+import path6 from "path";
+function findWorkspaceRoot(startDir, exists2 = existsSync5, maxDepth = 12) {
+  let dir = path6.resolve(startDir);
   for (let i = 0; i < maxDepth; i++) {
-    if (exists2(path5.join(dir, "package.json"))) return dir;
-    const parent = path5.dirname(dir);
+    if (exists2(path6.join(dir, "package.json"))) return dir;
+    const parent = path6.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function canonicalize(target) {
-  const abs = path5.resolve(target);
+  const abs = path6.resolve(target);
   let dir = abs;
   for (; ; ) {
     try {
       const real = realpathSync(dir);
-      return dir === abs ? real : path5.join(real, path5.relative(dir, abs));
+      return dir === abs ? real : path6.join(real, path6.relative(dir, abs));
     } catch {
-      const parent = path5.dirname(dir);
+      const parent = path6.dirname(dir);
       if (parent === dir) return abs;
       dir = parent;
     }
   }
 }
 function isInside(root, target) {
-  const rel = path5.relative(root, target);
-  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
+  const rel = path6.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path6.isAbsolute(rel);
 }
 function toCanvasRelative(canvasDir, target) {
-  return path5.relative(canvasDir, target).split(path5.sep).join("/");
+  return path6.relative(canvasDir, target).split(path6.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) || !path5.isAbsolute(value)) return null;
+  if (value.includes("[TODO") || looksLikeHttpUrl(value) || !path6.isAbsolute(value)) return null;
   const target = canonicalize(value);
   if (isInside(workspaceRoot, target)) return target;
-  const fromRuntime = path5.relative(RUNTIME_WORKSPACE_ROOT, path5.normalize(value));
-  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path5.isAbsolute(fromRuntime)) {
-    return path5.join(workspaceRoot, fromRuntime);
+  const fromRuntime = path6.relative(RUNTIME_WORKSPACE_ROOT, path6.normalize(value));
+  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path6.isAbsolute(fromRuntime)) {
+    return path6.join(workspaceRoot, fromRuntime);
   }
   return null;
 }
@@ -35953,7 +35966,7 @@ function normalizeAbsoluteCanvasPaths(canvas, canvasDir, workspaceRoot) {
   return rewrites.length === 0 ? { canvas, rewrites } : { canvas: { ...canvas, nodes }, rewrites };
 }
 async function healAbsoluteCanvasPaths(filePath, canvas) {
-  const canvasDir = path5.dirname(filePath);
+  const canvasDir = path6.dirname(filePath);
   const workspaceRoot = findWorkspaceRoot(canvasDir);
   if (!workspaceRoot) return { canvas, rewrites: [], text: null };
   const normalized = normalizeAbsoluteCanvasPaths(canvas, canvasDir, workspaceRoot);
@@ -35984,7 +35997,7 @@ function unsuppliedPlaceholderAssets(canvas) {
 }
 
 // src/commands/canvas/resolve-paths.ts
-import path6 from "path";
+import path7 from "path";
 function resolveRelativeCanvasPaths(canvas, baseDir) {
   if (!canvas || typeof canvas !== "object") return canvas;
   const c = canvas;
@@ -35997,24 +36010,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: path6.resolve(baseDir, params.path) } };
+    return { ...node, params: { ...params, path: path7.resolve(baseDir, params.path) } };
   }
   if (n.type === "hyperframe_render" && isResolvableRelative(params.composition)) {
-    return { ...node, params: { ...params, composition: path6.resolve(baseDir, params.composition) } };
+    return { ...node, params: { ...params, composition: path7.resolve(baseDir, params.composition) } };
   }
   return node;
 }
 function isResolvableRelative(value) {
-  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path6.isAbsolute(value);
+  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path7.isAbsolute(value);
 }
 
 // src/commands/canvas/source-version.ts
 import { readFile as readFile6 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 
 // src/commands/canvas/scene-files.ts
-import { mkdir as mkdir2, readFile as readFile5, readdir as readdir3, rm, writeFile as writeFile3 } from "fs/promises";
-import path7 from "path";
+import { mkdir as mkdir2, readFile as readFile5, readdir as readdir4, rm, writeFile as writeFile3 } from "fs/promises";
+import path8 from "path";
 var SCENES_DIR = "scenes";
 var GLOBAL_PROMPT_FILE = "prompt.json";
 var REBUILD_FILE = "prompt.rebuild.json";
@@ -36031,38 +36044,38 @@ function splitBlueprint(blueprint) {
 }
 async function writeSceneFiles(outDir, blueprint) {
   const { global, scenes } = splitBlueprint(blueprint);
-  await writeFile3(path7.join(outDir, GLOBAL_PROMPT_FILE), `${JSON.stringify(global, null, 2)}
+  await writeFile3(path8.join(outDir, GLOBAL_PROMPT_FILE), `${JSON.stringify(global, null, 2)}
 `, "utf8");
-  const scenesDir = path7.join(outDir, SCENES_DIR);
+  const scenesDir = path8.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 writeFile3(path7.join(scenesDir, name), `${JSON.stringify(scenes[i], null, 2)}
+    await writeFile3(path8.join(scenesDir, name), `${JSON.stringify(scenes[i], null, 2)}
 `, "utf8");
   }
   for (const name of await listSceneFileNames(scenesDir)) {
-    if (!written.has(name)) await rm(path7.join(scenesDir, name), { force: true });
+    if (!written.has(name)) await rm(path8.join(scenesDir, name), { force: true });
   }
 }
 async function listSceneFileNames(scenesDir) {
   let entries;
   try {
-    entries = await readdir3(scenesDir);
+    entries = await readdir4(scenesDir);
   } catch {
     return [];
   }
   return entries.filter((n) => /^s\d+\.json$/.test(n)).sort(bySceneIndex);
 }
 async function listSceneFiles(creativeDir) {
-  const scenesDir = path7.join(creativeDir, SCENES_DIR);
-  return (await listSceneFileNames(scenesDir)).map((n) => path7.join(scenesDir, n));
+  const scenesDir = path8.join(creativeDir, SCENES_DIR);
+  return (await listSceneFileNames(scenesDir)).map((n) => path8.join(scenesDir, n));
 }
 async function reassembleBlueprint(creativeDir) {
   const files = await listSceneFiles(creativeDir);
   if (files.length === 0) return null;
-  const globalRaw = await readFile5(path7.join(creativeDir, GLOBAL_PROMPT_FILE), "utf8");
+  const globalRaw = await readFile5(path8.join(creativeDir, GLOBAL_PROMPT_FILE), "utf8");
   const global = JSON.parse(globalRaw);
   const scenes = [];
   for (const file of files) {
@@ -36084,8 +36097,8 @@ async function computeSourceSha(canvasPath) {
   } catch {
     return void 0;
   }
-  const canvasDir = path8.dirname(canvasPath);
-  const promptPath = path8.join(canvasDir, "prompt.json");
+  const canvasDir = path9.dirname(canvasPath);
+  const promptPath = path9.join(canvasDir, "prompt.json");
   let promptBytes;
   try {
     promptBytes = await readFile6(promptPath);
@@ -36112,7 +36125,7 @@ async function computeSourceSha(canvasPath) {
 
 // src/commands/canvas/scene-projection.ts
 import { readFile as readFile7 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 
 // src/engine/scaffold/video.ts
 import { toCardinal as nwAr } from "n2words/ar-SA";
@@ -39518,12 +39531,12 @@ function nonPromptParamsDiverge(live = {}, rebuilt = {}) {
   return false;
 }
 async function syncSceneNodeParams(canvas, canvasPath, log) {
-  const creativeDir = path9.dirname(canvasPath);
+  const creativeDir = path10.dirname(canvasPath);
   const blueprint = await reassembleBlueprint(creativeDir);
   if (!blueprint) return "not_applicable";
   let rebuildRaw;
   try {
-    rebuildRaw = await readFile7(path9.join(creativeDir, REBUILD_FILE), "utf8");
+    rebuildRaw = await readFile7(path10.join(creativeDir, REBUILD_FILE), "utf8");
   } catch {
     log(
       `[scenes] this creative has scene files but no ${REBUILD_FILE}, so edits to scenes/*.json are NOT reaching the render \u2014 the prompts inlined in the canvas are what renders. Re-scaffold the creative to restore the link, or edit the canvas node prompts directly.`
@@ -39658,13 +39671,13 @@ ${body}` : header || body || compactJson(record);
 }
 
 // src/commands/canvas/run-record.ts
-import path10 from "path";
+import path11 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(path10.sep).join("/");
+  const normalized = filePath.split(path11.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;
@@ -39957,24 +39970,24 @@ var RunRecordPoster = class {
 
 // src/commands/canvas/run-retention.ts
 import { rm as rm2 } from "fs/promises";
-import path11 from "path";
+import path12 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: readdir16 } = await import("fs/promises");
+  const { readdir: readdir17 } = await import("fs/promises");
   let entries;
   try {
-    entries = await readdir16(outputsDir);
+    entries = await readdir17(outputsDir);
   } catch {
     return;
   }
   const toPrune = runDirsToPrune(entries, keep, currentRunId);
   if (toPrune.length === 0) return;
   for (const dir of toPrune) {
-    await rm2(path11.join(outputsDir, dir), { recursive: true, force: true }).catch(
+    await rm2(path12.join(outputsDir, dir), { recursive: true, force: true }).catch(
       (e) => log(`[prune   ] could not remove ${dir}: ${e.message}`)
     );
   }
@@ -39982,13 +39995,13 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
 }
 
 // src/commands/canvas/dirty-marker.ts
-import { mkdir as mkdir3, readdir as readdir4, rm as rm3, writeFile as writeFile5 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir3, readdir as readdir5, rm as rm3, writeFile as writeFile5 } from "fs/promises";
+import path13 from "path";
 function creativeDirtyDir(base) {
-  return base ?? path12.resolve("canvas", ".dirty");
+  return base ?? path13.resolve("canvas", ".dirty");
 }
 function dirtyMarkerFile(slug, base) {
-  return path12.join(creativeDirtyDir(base), `${slug}.json`);
+  return path13.join(creativeDirtyDir(base), `${slug}.json`);
 }
 async function clearCreativeDirty(slug, base) {
   try {
@@ -39999,17 +40012,17 @@ async function clearCreativeDirty(slug, base) {
 
 // src/commands/canvas/run-resume.ts
 import { mkdir as mkdir4, readFile as readFile9, rm as rm4, writeFile as writeFile6 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 function markerKey(canvasPath) {
   const slug = creativeSlugFromCanvasPath(canvasPath);
-  const identity = slug ?? path13.relative(process.cwd(), path13.resolve(canvasPath));
+  const identity = slug ?? path14.relative(process.cwd(), path14.resolve(canvasPath));
   return sha256Hex(Buffer.from(identity)).slice(0, 32);
 }
 function legacyMarkerKey(canvasPath) {
-  return sha256Hex(Buffer.from(path13.resolve(canvasPath))).slice(0, 32);
+  return sha256Hex(Buffer.from(path14.resolve(canvasPath))).slice(0, 32);
 }
 function markerFile(outputsDir, key) {
-  return path13.join(outputsDir, ".inflight", `${key}.json`);
+  return path14.join(outputsDir, ".inflight", `${key}.json`);
 }
 var REMOTE_ADOPT_STALE_MS = 12e4;
 function classifyRemoteRun(run, now) {
@@ -40056,8 +40069,8 @@ async function readMarkerRunId(outputsDir, canvasPath) {
 async function markRunInFlight(outputsDir, canvasPath, runId) {
   try {
     const file = markerFile(outputsDir, markerKey(canvasPath));
-    await mkdir4(path13.dirname(file), { recursive: true });
-    await writeFile6(file, JSON.stringify({ runId, canvasPath: path13.resolve(canvasPath), startedAt: Date.now() }));
+    await mkdir4(path14.dirname(file), { recursive: true });
+    await writeFile6(file, JSON.stringify({ runId, canvasPath: path14.resolve(canvasPath), startedAt: Date.now() }));
   } catch {
   }
 }
@@ -40071,8 +40084,8 @@ async function clearRunMarker(outputsDir, canvasPath) {
 }
 
 // src/commands/canvas/run-snapshot.ts
-import { mkdir as mkdir5, readdir as readdir5, readFile as readFile10, stat as stat2, writeFile as writeFile7 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir5, readdir as readdir6, readFile as readFile10, stat as stat2, writeFile as writeFile7 } from "fs/promises";
+import path15 from "path";
 var SNAPSHOT_SCHEMA = "baker-canvas-snapshot/1";
 var MAX_SNAPSHOT_FILE_BYTES = 32 * 1024 * 1024;
 var EXT_TO_MIME = {
@@ -40099,15 +40112,15 @@ var EXT_TO_MIME = {
   woff2: "font/woff2"
 };
 function mimeForFile(filePath) {
-  const ext = path14.extname(filePath).slice(1).toLowerCase();
+  const ext = path15.extname(filePath).slice(1).toLowerCase();
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
 function toPosix(p) {
-  return p.split(path14.sep).join("/");
+  return p.split(path15.sep).join("/");
 }
 function isInside2(dir, target) {
-  const rel = path14.relative(dir, target);
-  return !rel.startsWith("..") && !path14.isAbsolute(rel);
+  const rel = path15.relative(dir, target);
+  return !rel.startsWith("..") && !path15.isAbsolute(rel);
 }
 function localPathRefsFromCanvas(parsed) {
   const nodes = parsed?.nodes;
@@ -40132,24 +40145,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(path14.relative(canvasDir, sceneFile)));
+    refs.add(toPosix(path15.relative(canvasDir, sceneFile)));
   }
   refs.add(REBUILD_FILE);
   return [...refs];
 }
 async function uploadRunSnapshot(client, opts) {
   try {
-    const canvasDir = path14.dirname(opts.canvasPath);
+    const canvasDir = path15.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 = path14.isAbsolute(refPath) ? refPath : path14.resolve(canvasDir, refPath);
+      const abs = path15.isAbsolute(refPath) ? refPath : path15.resolve(canvasDir, refPath);
       if (!isInside2(canvasDir, abs)) {
         skipped.push({
-          path: toPosix(path14.relative(canvasDir, abs)),
+          path: toPosix(path15.relative(canvasDir, abs)),
           reason: "outside the creative folder \u2014 read from the workspace on rerun"
         });
         continue;
@@ -40158,12 +40171,12 @@ async function uploadRunSnapshot(client, opts) {
       try {
         st = await stat2(abs);
       } catch {
-        skipped.push({ path: toPosix(path14.relative(canvasDir, abs)), reason: "missing" });
+        skipped.push({ path: toPosix(path15.relative(canvasDir, abs)), reason: "missing" });
         continue;
       }
       const fileList = st.isDirectory() ? await listFilesRecursive(abs) : [abs];
       for (const file of fileList) {
-        const rel = toPosix(path14.relative(canvasDir, file));
+        const rel = toPosix(path15.relative(canvasDir, file));
         const size = (await stat2(file)).size;
         if (size > MAX_SNAPSHOT_FILE_BYTES) {
           skipped.push({ path: rel, reason: `too large (${size} bytes)` });
@@ -40178,7 +40191,7 @@ async function uploadRunSnapshot(client, opts) {
       schema: SNAPSHOT_SCHEMA,
       creativeSlug: opts.creativeSlug,
       canvasSha: canvasUpload.sha256,
-      canvas: { path: path14.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
+      canvas: { path: path15.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
       files,
       skipped: skipped.length > 0 ? skipped : void 0
     };
@@ -40204,8 +40217,8 @@ async function putContentAddressed(client, bytes, mime, signal) {
   return { sha256, url: publicUrl };
 }
 async function listFilesRecursive(dir) {
-  const entries = await readdir5(dir, { recursive: true, withFileTypes: true });
-  return entries.filter((d) => d.isFile()).map((d) => path14.join(d.parentPath, d.name));
+  const entries = await readdir6(dir, { recursive: true, withFileTypes: true });
+  return entries.filter((d) => d.isFile()).map((d) => path15.join(d.parentPath, d.name));
 }
 var SnapshotConflictError = class extends Error {
   conflicts;
@@ -40217,16 +40230,16 @@ var SnapshotConflictError = class extends Error {
 };
 async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
   const entries = [manifest.canvas, ...manifest.files];
-  const resolvedTarget = path14.resolve(targetDir);
+  const resolvedTarget = path15.resolve(targetDir);
   const planned = [];
   const conflicts = [];
   const upToDate = [];
   for (const entry of entries) {
-    if (path14.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
+    if (path15.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const target = path14.resolve(resolvedTarget, entry.path);
-    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path14.sep)) {
+    const target = path15.resolve(resolvedTarget, entry.path);
+    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path15.sep)) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
     const existing = await readFile10(target).catch(() => null);
@@ -40251,18 +40264,18 @@ 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(path14.dirname(target), { recursive: true });
+    await mkdir5(path15.dirname(target), { recursive: true });
     await writeFile7(target, bytes);
     restored.push(entry.path);
   }
-  return { canvasPath: path14.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
+  return { canvasPath: path15.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
 }
 
 // src/engine/nodes/local/lib/render-review.ts
 import { execFile as execFile2 } from "child_process";
-import { mkdtemp, readdir as readdir6, readFile as readFile11, rm as rm5 } from "fs/promises";
+import { mkdtemp, readdir as readdir7, readFile as readFile11, rm as rm5 } from "fs/promises";
 import { tmpdir } from "os";
-import path15 from "path";
+import path16 from "path";
 import { promisify as promisify2 } from "util";
 import { z as z39 } from "zod";
 var RENDER_REVIEW_MODEL = "~google/gemini-pro-latest";
@@ -40684,11 +40697,11 @@ async function reviewRenderedVideo(opts) {
   const duration = await videoDuration(opts.video);
   if (duration === null) return null;
   const spent = (usage) => opts.onSpend?.(usage);
-  const dir = await mkdtemp(path15.join(tmpdir(), "baker-review-"));
+  const dir = await mkdtemp(path16.join(tmpdir(), "baker-review-"));
   try {
     const grabbed = [];
     for (const [i, at] of reviewFrameTimes(duration, RENDER_REVIEW_FRAMES).entries()) {
-      const out = path15.join(dir, `f${String(i).padStart(2, "0")}.jpg`);
+      const out = path16.join(dir, `f${String(i).padStart(2, "0")}.jpg`);
       try {
         await execFileAsync2("ffmpeg", buildFrameGrabArgs(opts.video, at, out), { timeout: 3e4 });
         grabbed.push({ at, image: await readFile11(out, { encoding: "base64" }) });
@@ -40738,7 +40751,7 @@ async function reviewRenderedVideo(opts) {
   }
 }
 async function reviewContextBeside(canvasPath) {
-  const raw = await readFile11(path15.join(path15.dirname(canvasPath), "prompt.json"), "utf-8").catch(() => null);
+  const raw = await readFile11(path16.join(path16.dirname(canvasPath), "prompt.json"), "utf-8").catch(() => null);
   if (!raw) return {};
   try {
     const blueprint = JSON.parse(raw);
@@ -40754,12 +40767,12 @@ async function reviewContextBeside(canvasPath) {
   }
 }
 async function sceneWindowsBeside(canvasPath) {
-  const dir = path15.join(path15.dirname(canvasPath), "scenes");
-  const files = await readdir6(dir).catch(() => null);
+  const dir = path16.join(path16.dirname(canvasPath), "scenes");
+  const files = await readdir7(dir).catch(() => null);
   if (!files) return [];
   const windows = [];
   for (const name of files.filter((f) => f.endsWith(".json")).sort()) {
-    const raw = await readFile11(path15.join(dir, name), "utf-8").catch(() => null);
+    const raw = await readFile11(path16.join(dir, name), "utf-8").catch(() => null);
     if (!raw) continue;
     try {
       const scene = JSON.parse(raw);
@@ -40885,7 +40898,7 @@ function stopBeforeKinds(until) {
   return null;
 }
 async function executeCanvasRun(opts) {
-  const filePath = path16.resolve(opts.file);
+  const filePath = path17.resolve(opts.file);
   const raw = await readFile12(filePath, "utf8");
   let parsed;
   try {
@@ -40908,7 +40921,7 @@ ${describeRewrites(healed.rewrites)}
 `
     );
   }
-  parsed = resolveRelativeCanvasPaths(parsed, path16.dirname(filePath));
+  parsed = resolveRelativeCanvasPaths(parsed, path17.dirname(filePath));
   try {
     await syncStyleProjection(parsed, (line) => process.stderr.write(`${line}
 `));
@@ -41014,7 +41027,7 @@ ${describeRewrites(healed.rewrites)}
   const canvasSha = sha256Hex(Buffer.from(canvasText));
   const creativeSlug = creativeSlugFromCanvasPath(filePath) ?? void 0;
   const client = opts.record === false ? null : buildBackendClient();
-  const outputsDir = opts.outputsDir ? path16.resolve(opts.outputsDir) : path16.resolve("canvas");
+  const outputsDir = opts.outputsDir ? path17.resolve(opts.outputsDir) : path17.resolve("canvas");
   const { runId, resumed, source, concurrentRunId } = await resolveRunId({
     explicitRunId: opts.runId,
     fresh: opts.fresh === true,
@@ -41048,7 +41061,7 @@ ${describeRewrites(healed.rewrites)}
   const canvasSnapshotUrl = client && creativeSlug ? await uploadRunSnapshot(client, { canvasPath: filePath, raw: canvasText, creativeSlug, parsed }) ?? void 0 : void 0;
   const recordMeta = {
     creativeSlug,
-    canvasPath: path16.relative(process.cwd(), filePath) || void 0,
+    canvasPath: path17.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 +
@@ -41306,7 +41319,7 @@ var rerunCommand = defineCommand112({
     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 = path17.resolve("src", "creatives", slug);
+    const targetDir = path18.resolve("src", "creatives", slug);
     let restoredCanvasPath;
     try {
       const restore = await restoreRunSnapshot(manifest, targetDir, { force: args5["force-remote"] === true });
@@ -41356,7 +41369,7 @@ async function fetchManifest(url) {
 
 // src/commands/canvas/scaffold-static-ad.ts
 import { access, mkdir as mkdir6, readFile as readFile14, writeFile as writeFile8 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 import { defineCommand as defineCommand114 } from "citty";
 
 // src/engine/scaffold/staticAd.ts
@@ -41644,7 +41657,7 @@ function staticAdReport(input, elementsInput, opts) {
 }
 
 // src/commands/canvas/creative-definition.ts
-import path18 from "path";
+import path19 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) {
@@ -41692,16 +41705,16 @@ function buildCreativeDefinition(input) {
 }
 
 // src/commands/canvas/scaffold-static-ad-paths.ts
-import path19 from "path";
+import path20 from "path";
 function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
   const file = rawFile.trim();
   const imageIsUrl = /^https?:\/\//i.test(file);
-  const imageSource = imageIsUrl ? file : path19.resolve(cwd, file);
-  const outPath = out ? path19.resolve(cwd, out) : slug ? path19.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path19.join(cwd, "static-ad.canvas.json") : path19.join(path19.dirname(imageSource), "static-ad.canvas.json");
-  const blueprintPath = path19.join(path19.dirname(outPath), "prompt.json");
-  const creativeDir = slug ? path19.dirname(outPath) : null;
-  const definitionPath = creativeDir ? path19.join(creativeDir, "_definition.md") : null;
-  const referencesDir = creativeDir ? path19.join(creativeDir, "references") : null;
+  const imageSource = imageIsUrl ? file : path20.resolve(cwd, file);
+  const outPath = out ? path20.resolve(cwd, out) : slug ? path20.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path20.join(cwd, "static-ad.canvas.json") : path20.join(path20.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath = path20.join(path20.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path20.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path20.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path20.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])?$/;
@@ -41711,8 +41724,8 @@ function isValidScaffoldSlug(slug) {
 }
 
 // src/commands/canvas/sync-definition.ts
-import { readdir as readdir7, readFile as readFile13, stat as stat3 } from "fs/promises";
-import path20 from "path";
+import { readdir as readdir8, readFile as readFile13, stat as stat3 } from "fs/promises";
+import path21 from "path";
 import { defineCommand as defineCommand113 } from "citty";
 
 // src/commands/canvas/definition-graph.ts
@@ -41805,26 +41818,26 @@ async function syncCreativeDefinitionBestEffort(input) {
   }
 }
 async function resolveCanvasPath(inputPath) {
-  const resolved = path20.resolve(inputPath);
+  const resolved = path21.resolve(inputPath);
   let dir = resolved;
   try {
     if ((await stat3(resolved)).isFile()) {
       if (resolved.endsWith(".canvas.json")) return resolved;
-      dir = path20.dirname(resolved);
+      dir = path21.dirname(resolved);
     }
   } catch {
-    dir = resolved.endsWith(".canvas.json") ? path20.dirname(resolved) : resolved;
+    dir = resolved.endsWith(".canvas.json") ? path21.dirname(resolved) : resolved;
   }
   let entries;
   try {
-    entries = await readdir7(dir);
+    entries = await readdir8(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 ? path20.join(dir, chosen) : null;
+  return chosen ? path21.join(dir, chosen) : null;
 }
 var syncDefinitionCommand = defineCommand113({
   meta: {
@@ -42105,7 +42118,7 @@ var scaffoldStaticAdCommand = defineCommand114({
       process.cwd(),
       slug
     );
-    await mkdir6(path21.dirname(outPath), { recursive: true });
+    await mkdir6(path22.dirname(outPath), { recursive: true });
     const { describeModel, selectModel, layoutModel, genModel } = resolveModels(args5);
     let durableSourceUrl;
     if (referencesDir) {
@@ -42225,7 +42238,7 @@ var scaffoldStaticAdCommand = defineCommand114({
             run_estimated_credits: validation.estimatedCredits
           },
           checklist: {
-            edit_prompt: `Edit ${path21.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 ${path22.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)",
@@ -42994,8 +43007,8 @@ function injectAdBrandOverlay(indexHtml, overlayHtml) {
 }
 
 // src/engine/scaffold/ad-brand-source.ts
-import { readdir as readdir8, readFile as readFile15 } from "fs/promises";
-import path22 from "path";
+import { readdir as readdir9, readFile as readFile15 } from "fs/promises";
+import path23 from "path";
 import sharp from "sharp";
 var BRAND_DIR = "src/brand";
 function paletteFromBrandDoc(markdown) {
@@ -43047,16 +43060,16 @@ function pickBrandMark(files) {
 }
 async function readBrandFromWorkspace(root = ".") {
   const found = {};
-  const doc = await readFile15(path22.join(root, BRAND_DIR, "BRAND.md"), "utf-8").catch(() => null);
+  const doc = await readFile15(path23.join(root, BRAND_DIR, "BRAND.md"), "utf-8").catch(() => null);
   if (doc) {
     const palette = paletteFromBrandDoc(doc);
     if (palette.length > 0) found.palette = palette;
   }
-  const dir = path22.join(root, BRAND_DIR, "logos");
-  const files = await readdir8(dir).catch(() => null);
+  const dir = path23.join(root, BRAND_DIR, "logos");
+  const files = await readdir9(dir).catch(() => null);
   if (files) {
     const mark = pickBrandMark(files);
-    if (mark) found.logo = path22.join(BRAND_DIR, "logos", mark);
+    if (mark) found.logo = path23.join(BRAND_DIR, "logos", mark);
   }
   return found;
 }
@@ -43066,20 +43079,20 @@ function svgIsLiveText(svg) {
 async function markIsReal(markPath, root = ".") {
   const brandLogos = await findBrandLogosDir(markPath, root);
   if (brandLogos) return await markDirectoryIsReal(brandLogos);
-  return await markDirectoryIsReal(path22.dirname(markPath));
+  return await markDirectoryIsReal(path23.dirname(markPath));
 }
 async function findBrandLogosDir(markPath, root) {
   const candidates = [];
-  let dir = path22.resolve(path22.dirname(markPath));
+  let dir = path23.resolve(path23.dirname(markPath));
   for (; ; ) {
-    candidates.push(path22.join(dir, BRAND_DIR, "logos"));
-    const parent = path22.dirname(dir);
+    candidates.push(path23.join(dir, BRAND_DIR, "logos"));
+    const parent = path23.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  candidates.push(path22.join(root, BRAND_DIR, "logos"));
+  candidates.push(path23.join(root, BRAND_DIR, "logos"));
   for (const candidate of candidates) {
-    if (await readdir8(candidate).then(
+    if (await readdir9(candidate).then(
       () => true,
       () => false
     ))
@@ -43088,12 +43101,12 @@ async function findBrandLogosDir(markPath, root) {
   return null;
 }
 async function markDirectoryIsReal(dir) {
-  const files = await readdir8(dir).catch(() => null);
+  const files = await readdir9(dir).catch(() => null);
   if (!files) return false;
   const marks = files.filter((f) => /\.(svg|png|webp)$/i.test(f));
   if (marks.length === 0) return false;
   for (const f of marks.filter((f2) => /\.svg$/i.test(f2))) {
-    const svg = await readFile15(path22.join(dir, f), "utf-8").catch(() => null);
+    const svg = await readFile15(path23.join(dir, f), "utf-8").catch(() => null);
     if (svg === null || svgIsLiveText(svg)) return false;
   }
   return true;
@@ -43120,22 +43133,6 @@ async function markInkIsLight(markPath) {
   }
 }
 
-// src/commands/canvas/composition-path.ts
-import { existsSync as existsSync5 } from "fs";
-import path23 from "path";
-function resolveShippedCanvasDir(name, startDir, exists2 = existsSync5, maxDepth = 8) {
-  const rel = path23.join("canvas", name);
-  let dir = startDir;
-  for (let i = 0; i < maxDepth; i++) {
-    const candidate = path23.join(dir, rel);
-    if (exists2(path23.join(candidate, "meta.json"))) return candidate;
-    const parent = path23.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return path23.resolve(startDir, "../../../", rel);
-}
-
 // src/commands/canvas/scaffold-ad.ts
 function pinnedOnAvatar(handle, model) {
   const hint = pinnedModelHint({ avatar: handle ?? void 0, model, generateAudio: true });
@@ -43686,7 +43683,7 @@ function routeVideoModel(input) {
 
 // src/engine/nodes/local/lib/sceneDetect.ts
 import { execFile as execFile3 } from "child_process";
-import { mkdtemp as mkdtemp2, readdir as readdir9, readFile as readFile17, rm as rm6 } from "fs/promises";
+import { mkdtemp as mkdtemp2, readdir as readdir10, readFile as readFile17, rm as rm6 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join3 } from "path";
 import { promisify as promisify3 } from "util";
@@ -43760,7 +43757,7 @@ async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs)
       ],
       { encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, timeout: timeoutMs }
     );
-    const csvName = (await readdir9(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
+    const csvName = (await readdir10(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
     if (!csvName) return [];
     return parsePySceneDetectCsvCuts(await readFile17(join3(outDir, csvName), "utf-8"));
   } finally {
@@ -45162,11 +45159,11 @@ Full guide: __tooling__/docs/tools/baker/creatives.md`
 import { defineCommand as defineCommand124 } from "citty";
 
 // src/commands/experiment/composition.ts
-import { readdir as readdir11, readFile as readFile24 } from "fs/promises";
+import { readdir as readdir12, readFile as readFile24 } from "fs/promises";
 import path30 from "path";
 
 // src/commands/landing/import-graph.ts
-import { readdir as readdir10, readFile as readFile23, stat as stat5 } from "fs/promises";
+import { readdir as readdir11, readFile as readFile23, stat as stat5 } from "fs/promises";
 import path29 from "path";
 var SOURCE_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte)$/;
 var RESOLVE_CANDIDATES = [
@@ -45194,7 +45191,7 @@ async function isFile(p) {
 async function walkFiles(dir) {
   let entries;
   try {
-    entries = await readdir10(dir, { withFileTypes: true });
+    entries = await readdir11(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -45297,7 +45294,7 @@ function formsOnlyIn(these, those) {
 }
 async function knownFlows(root) {
   try {
-    const entries = await readdir11(path30.join(root, "src/lib/flow-engine/flows"), { withFileTypes: true });
+    const entries = await readdir12(path30.join(root, "src/lib/flow-engine/flows"), { withFileTypes: true });
     return new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -45318,7 +45315,7 @@ async function readForms(root, slug) {
 
 // src/commands/experiment/fold.ts
 import { statSync } from "fs";
-import { cp as cp3, mkdir as mkdir9, readdir as readdir12, readFile as readFile25, rm as rm8, stat as stat6, writeFile as writeFile12 } from "fs/promises";
+import { cp as cp3, mkdir as mkdir9, readdir as readdir13, readFile as readFile25, rm as rm8, stat as stat6, writeFile as writeFile12 } from "fs/promises";
 import path32 from "path";
 
 // ../api/src/experiments/variants.ts
@@ -45393,7 +45390,7 @@ async function isDir(p) {
 async function filesUnder(dir, prefix = "") {
   let entries;
   try {
-    entries = await readdir12(dir, { withFileTypes: true });
+    entries = await readdir13(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -55757,7 +55754,7 @@ Full guide: __tooling__/docs/tools/baker/images.md`
 import { defineCommand as defineCommand182 } from "citty";
 
 // src/commands/landing/critique.ts
-import { readdir as readdir14, readFile as readFile30, stat as stat9 } from "fs/promises";
+import { readdir as readdir15, readFile as readFile30, stat as stat9 } from "fs/promises";
 import path37 from "path";
 import { defineCommand as defineCommand171 } from "citty";
 
@@ -56968,7 +56965,7 @@ async function writeCritiqueSnapshot(projectRoot, snapshot) {
 }
 
 // src/commands/landing/source-version.ts
-import { readdir as readdir13, readFile as readFile29, stat as stat8 } from "fs/promises";
+import { readdir as readdir14, readFile as readFile29, stat as stat8 } from "fs/promises";
 import path36 from "path";
 var CRITIQUED_ROOTS = ["src/pages/", "src/components/"];
 async function landingSourceRelPaths(root, slug) {
@@ -57024,7 +57021,7 @@ async function isFile2(p) {
 async function walkAstro(dir) {
   let entries;
   try {
-    entries = await readdir13(dir, { withFileTypes: true });
+    entries = await readdir14(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -57157,7 +57154,7 @@ async function readCompetitorNames(projectRoot) {
   const dir = path37.join(projectRoot, "src", "content", "competitors");
   let entries;
   try {
-    entries = (await readdir14(dir)).filter((f) => f.endsWith(".md"));
+    entries = (await readdir15(dir)).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
@@ -57175,7 +57172,7 @@ async function readCompetitorNames(projectRoot) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir14(path37.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir15(path37.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 [];
@@ -60368,7 +60365,7 @@ Full guide: __tooling__/docs/tools/baker/landing.md`
 
 // src/commands/landing/variant.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir14, readdir as readdir15, readFile as readFile31, stat as stat10, writeFile as writeFile19 } from "fs/promises";
+import { mkdir as mkdir14, readdir as readdir16, readFile as readFile31, stat as stat10, writeFile as writeFile19 } from "fs/promises";
 import path45 from "path";
 import { defineCommand as defineCommand181 } from "citty";
 registerSchema({
@@ -60405,7 +60402,7 @@ async function readInternalId(definitionPath) {
 async function archivedVariantNumbers(root, internalId) {
   if (!internalId) return [];
   try {
-    const entries = await readdir15(path45.resolve(root, "src/_variants", internalId), { withFileTypes: true });
+    const entries = await readdir16(path45.resolve(root, "src/_variants", internalId), { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => Number(entry.name)).filter((n) => Number.isInteger(n) && n > 0);
   } catch {
     return [];
@@ -60435,7 +60432,7 @@ async function exists(p) {
 }
 async function listLandingSlugs2(root) {
   try {
-    const entries = await readdir15(path45.resolve(root, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir16(path45.resolve(root, "src", "pages"), { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return [];
@@ -60444,7 +60441,7 @@ async function listLandingSlugs2(root) {
 async function listComponents(componentsDir, prefix = "") {
   let entries;
   try {
-    entries = await readdir15(componentsDir, { withFileTypes: true });
+    entries = await readdir16(componentsDir, { withFileTypes: true });
   } catch {
     return [];
   }