@koda-sl/baker-cli 0.421.0 → 0.422.0

package/dist/cli.js

@@ -136,6 +136,7 @@ import {
   candidPersonPortraitPrompt,
   canonicalUrl,
   canonicalize,
+  canvasAssetMime,
   catalogView,
   clipAudioMode,
   clipDurationsFor,
@@ -176,6 +177,7 @@ import {
   imageRenderParams,
   imageSourceSchema,
   inSceneText,
+  inferMimeFromPath,
   isAudioOnly,
   isFlowOauthSideEffect,
   isPersistedAssetRef,
@@ -263,7 +265,7 @@ import {
   wordCount,
   xDraftOpInputSchema,
   ytDlpBlockSignal
-} from "./chunk-GLPQQP5C.js";
+} from "./chunk-2S6QIXLX.js";
 import {
   NAME_CONTAINS_ARG,
   csvOrJson,
@@ -274,7 +276,7 @@ import {
   resolveEffectiveStatus,
   statusFilterHints,
   todayIso
-} from "./chunk-EXWIIEZP.js";
+} from "./chunk-XNFV6BQU.js";
 import {
   buildQueryCacheKey,
   cacheGet,
@@ -290,19 +292,19 @@ import {
   writeAdsJson,
   writeAdsOutput,
   writeJsonEnvelope
-} from "./chunk-LRRWIOJG.js";
+} from "./chunk-3X2EMLBQ.js";
 import {
   ApiError,
   apiGet,
   apiGetWithHeaders,
   apiPost,
   validateConvexId
-} from "./chunk-ZADYWHL5.js";
+} from "./chunk-G5L5FX2B.js";
 import {
   installExitRecord,
   installStreamTaps,
   logInvocation
-} from "./chunk-FKFJKE75.js";
+} from "./chunk-S36N4SOX.js";
 import {
   __commonJS,
   __esm,
@@ -322,6 +324,7 @@ import {
   listSchemas,
   nextPlannedRoute,
   optionalChatId,
+  optionalConnection,
   outputFlagForCommand,
   plannedRoutes,
   refuseNonPublicUrl,
@@ -336,7 +339,7 @@ import {
   winningAdNormalizer,
   writeJson,
   writeOutput
-} from "./chunk-YZLLC7DL.js";
+} from "./chunk-5JVAP5DC.js";
 
 // ../../node_modules/.pnpm/i18n-iso-countries@7.14.0/node_modules/i18n-iso-countries/langs/af.json
 var require_af = __commonJS({
@@ -25997,16 +26000,16 @@ async function runChatgptRead(reference, read, hintsFor4) {
   }
 }
 var TRUNCATED_HINT = "These rows are the first 2,000, not the whole account \u2014 narrow the read (--campaign-id, --ad-group-id) before counting them or concluding something is missing.";
-async function getChatgptList(path59, params) {
-  const { data, headers } = await apiGetWithHeaders(path59, params);
+async function getChatgptList(path60, params) {
+  const { data, headers } = await apiGetWithHeaders(path60, params);
   return { data, truncated: headers.get(CHATGPT_ADS_TRUNCATED_HEADER) === "true" };
 }
-async function runChatgptListRead(reference, path59, params, hintsFor4) {
+async function runChatgptListRead(reference, path60, params, hintsFor4) {
   let truncated = false;
   await runChatgptRead(
     reference,
     async () => {
-      const read = await getChatgptList(path59, params);
+      const read = await getChatgptList(path60, params);
       truncated = read.truncated;
       return read.data;
     },
@@ -26811,8 +26814,8 @@ var MEMBER_ARGS = {
   },
   country: { type: "string", description: "Country of phones written without a +code, e.g. ES" }
 };
-function membersFromArgs(args8, readFile43 = (path59) => readFileSync2(path59, "utf8")) {
-  const fromFile = typeof args8.file === "string" && args8.file ? membersFromFile(readFile43(args8.file)) : { emails: [], phones: [] };
+function membersFromArgs(args8, readFile44 = (path60) => readFileSync2(path60, "utf8")) {
+  const fromFile = typeof args8.file === "string" && args8.file ? membersFromFile(readFile44(args8.file)) : { emails: [], phones: [] };
   const given = [...csvArg(args8.emails) ?? [], ...fromFile.emails];
   const givenPhones = [...csvArg(args8.phones) ?? [], ...fromFile.phones];
   const members = hashedMembers({
@@ -30186,9 +30189,9 @@ var COPY_LIST_FLAG = {
   descriptions: "--descriptions",
   longHeadlines: "--long-headlines"
 };
-function valueAt(root, path59) {
+function valueAt(root, path60) {
   let node = root;
-  for (const key of path59) {
+  for (const key of path60) {
     if (node === null || typeof node !== "object") return void 0;
     node = node[key];
   }
@@ -30421,11 +30424,11 @@ function parseKeywordEntry(raw, defaultMatch) {
 function rawTextEntries(value2, rawArgs) {
   return repeatedValues(rawArgs, "text", value2).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path59) {
-  if (typeof path59 !== "string" || path59.length === 0) {
+function rawFileEntries(path60) {
+  if (typeof path60 !== "string" || path60.length === 0) {
     return [];
   }
-  return readFileSync4(path59, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync4(path60, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args8, rawArgs) {
   const defaultMatch = typeof args8["match-type"] === "string" ? args8["match-type"].toUpperCase() : void 0;
@@ -30448,14 +30451,14 @@ function keywordEntries(args8, rawArgs) {
   }
   return entries;
 }
-function loadJsonFileArg(path59) {
-  if (typeof path59 !== "string" || path59.length === 0) {
+function loadJsonFileArg(path60) {
+  if (typeof path60 !== "string" || path60.length === 0) {
     return {};
   }
-  const inline = path59.trimStart().startsWith("{");
-  const source = inline ? "inline JSON" : path59;
+  const inline = path60.trimStart().startsWith("{");
+  const source = inline ? "inline JSON" : path60;
   try {
-    const parsed = JSON.parse(inline ? path59 : readFileSync4(path59, "utf8"));
+    const parsed = JSON.parse(inline ? path60 : readFileSync4(path60, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
       failWriteValidation2(`${source} must contain a JSON object`);
     }
@@ -30592,10 +30595,10 @@ async function stageUpdate(kind, customerId, target, payload, hints2) {
 async function stageTarget(kind, customerId, target, hints2) {
   await stageGoogleOp({ kind, customerId, target }, hints2);
 }
-async function draftAction(path59, body, chat) {
+async function draftAction(path60, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path59, { chatId, ...body });
+    const response = await apiPost(path60, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -33015,14 +33018,14 @@ function mappingRowProblem(row2) {
 
 // ../api/src/event-sources/template.ts
 var MENTION = /\{\{\s*([^{}]+?)\s*\}\}/g;
-function mentionOf(path59) {
-  return `{{${path59}}}`;
+function mentionOf(path60) {
+  return `{{${path60}}}`;
 }
 function templateMentions(template) {
   const seen = [];
   for (const match of template.matchAll(MENTION)) {
-    const path59 = (match[1] ?? "").trim();
-    if (path59 !== "" && !seen.includes(path59)) seen.push(path59);
+    const path60 = (match[1] ?? "").trim();
+    if (path60 !== "" && !seen.includes(path60)) seen.push(path60);
   }
   return seen;
 }
@@ -36397,17 +36400,17 @@ function ignoredColumnHints(columns) {
     `Ignored ${columns.length} column(s) that are not part of a conversion: ${columns.join(", ")}. A conversion carries an order id, a date, and something to match on: a click id (gclid / gbraid / wbraid), an email, a phone, or all four of givenName + familyName + country + postalCode. Optionally a value + currency, conversionCount, and eventSource (WEB / APP / IN_STORE / PHONE / OTHER). A column named just \`Name\` is ignored on purpose \u2014 Google needs the first and last name separately, so split it before re-running.`
   ];
 }
-function readRowsFile(path59) {
-  const inline = path59.trimStart().startsWith("[") || path59.trimStart().startsWith("{");
+function readRowsFile(path60) {
+  const inline = path60.trimStart().startsWith("[") || path60.trimStart().startsWith("{");
   let text3;
   try {
-    text3 = inline ? path59 : readFileSync6(path59, "utf8");
+    text3 = inline ? path60 : readFileSync6(path60, "utf8");
   } catch (err) {
-    failWriteValidation2(`could not read ${path59}: ${err instanceof Error ? err.message : String(err)}`);
+    failWriteValidation2(`could not read ${path60}: ${err instanceof Error ? err.message : String(err)}`);
   }
   const parsed = parseConversionRowsText(text3);
   if (!parsed.ok) {
-    failWriteValidation2(`${inline ? "the conversions passed inline" : path59}: ${parsed.error}`);
+    failWriteValidation2(`${inline ? "the conversions passed inline" : path60}: ${parsed.error}`);
   }
   return { rows: parsed.rows, ignoredColumns: parsed.ignoredColumns };
 }
@@ -38308,19 +38311,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path59) {
-  if (typeof path59 !== "string" || path59.length === 0) {
+function loadJsonFileArg2(path60) {
+  if (typeof path60 !== "string" || path60.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync7(path59, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path60, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path59} must contain a JSON object`);
+      failWriteValidation3(`${path60} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path59} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path60} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -38405,15 +38408,15 @@ function parseLocaleFlag(value2) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path59) {
-  if (typeof path59 !== "string" || path59.length === 0) {
+function loadTargetingFileArg(path60) {
+  if (typeof path60 !== "string" || path60.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path59);
+  const parsed = loadJsonFileArg2(path60);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation3(
-      `${path59} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path60} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -38448,14 +38451,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell3) => cell3.trim());
 }
-function parseListFileArg(path59, maxRows) {
-  if (typeof path59 !== "string" || path59.length === 0) {
+function parseListFileArg(path60, maxRows) {
+  if (typeof path60 !== "string" || path60.length === 0) {
     return void 0;
   }
-  const raw = readFileSync7(path59, "utf8");
+  const raw = readFileSync7(path60, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation3(`${path59} needs a header row and at least one data row`);
+    failWriteValidation3(`${path60} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -38474,7 +38477,7 @@ function parseListFileArg(path59, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation3(`${path59} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation3(`${path60} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -38570,11 +38573,11 @@ function readPositionals(args8) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path59) {
-  if (typeof path59 !== "string" || path59.length === 0) {
+function idsFileEntries(path60) {
+  if (typeof path60 !== "string" || path60.length === 0) {
     return [];
   }
-  return readFileSync7(path59, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync7(path60, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
 }
 function requireTargets2(args8, entity) {
   const positionals = readPositionals(args8);
@@ -41335,9 +41338,9 @@ import { defineCommand as defineCommand64 } from "citty";
 function asRecord(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) ? value2 : void 0;
 }
-function readPath(row2, path59) {
+function readPath(row2, path60) {
   let current = row2;
-  for (const segment of path59.split(".")) {
+  for (const segment of path60.split(".")) {
     const record = asRecord(current);
     if (!record) return void 0;
     current = record[segment];
@@ -41347,10 +41350,10 @@ function readPath(row2, path59) {
 function projectFields(rows, paths) {
   return rows.map((row2) => {
     const projected = {};
-    for (const path59 of paths) {
-      const value2 = readPath(row2, path59);
+    for (const path60 of paths) {
+      const value2 = readPath(row2, path60);
       if (value2 !== void 0) {
-        projected[path59] = value2;
+        projected[path60] = value2;
       }
     }
     return projected;
@@ -41363,16 +41366,16 @@ function shapeListRows(rows, args8, compact5) {
     const paths = fields.split(",").map((field) => field.trim()).filter((field) => field.length > 0);
     if (paths.length > 0) {
       const projected = projectFields(raw, paths).map((row2, i) => {
-        const missing = paths.filter((path59) => row2[path59] === void 0);
+        const missing = paths.filter((path60) => row2[path60] === void 0);
         const source = rows[i];
         if (missing.length === 0 || source === void 0) return row2;
         const compactRow3 = compact5.row(source);
-        for (const path59 of missing) {
-          if (compactRow3[path59] !== void 0) row2[path59] = compactRow3[path59];
+        for (const path60 of missing) {
+          if (compactRow3[path60] !== void 0) row2[path60] = compactRow3[path60];
         }
         return row2;
       });
-      const unmatched = paths.filter((path59) => projected.every((row2) => row2[path59] === void 0));
+      const unmatched = paths.filter((path60) => projected.every((row2) => row2[path60] === void 0));
       if (projected.length === 0 || unmatched.length === 0) return { rows: projected, fields: paths };
       const carried = /* @__PURE__ */ new Set([...compact5.columns, ...raw.flatMap((row2) => Object.keys(row2))]);
       return {
@@ -42732,54 +42735,54 @@ function ruleFields(node) {
     ([key, value2]) => (key === "and" || key === "or") && Array.isArray(value2) ? value2.flatMap(ruleFields) : [key]
   );
 }
-function branchRefusal(key, value2, path59) {
+function branchRefusal(key, value2, path60) {
   if (!Array.isArray(value2) || value2.length === 0) {
-    return `${path59}.${key} must be a non-empty array of conditions \u2014 an empty one counts every event the pixel sends`;
+    return `${path60}.${key} must be a non-empty array of conditions \u2014 an empty one counts every event the pixel sends`;
   }
   for (const [index, child] of value2.entries()) {
-    const refusal = ruleNodeRefusal(child, `${path59}.${key}[${index}]`);
+    const refusal = ruleNodeRefusal(child, `${path60}.${key}[${index}]`);
     if (refusal) {
       return refusal;
     }
   }
   return void 0;
 }
-function conditionRefusal(key, value2, path59) {
-  return key === "and" || key === "or" ? branchRefusal(key, value2, path59) : leafRefusal(key, value2, path59);
+function conditionRefusal(key, value2, path60) {
+  return key === "and" || key === "or" ? branchRefusal(key, value2, path60) : leafRefusal(key, value2, path60);
 }
-function ruleNodeRefusal(node, path59) {
+function ruleNodeRefusal(node, path60) {
   if (!isRecord2(node)) {
-    return `${path59} must be an object like {"URL":{"i_contains":"/thank-you"}}`;
+    return `${path60} must be an object like {"URL":{"i_contains":"/thank-you"}}`;
   }
   const entries = Object.entries(node);
   if (entries.length === 0) {
-    return `${path59} is empty \u2014 a rule with no condition counts every event the pixel sends`;
+    return `${path60} is empty \u2014 a rule with no condition counts every event the pixel sends`;
   }
   if (entries.length > 1) {
-    return `${path59} names ${entries.length} conditions side by side (${entries.map(([key]) => key).join(", ")}) \u2014 Meta reads one branch or one field test per object, so combine them with {"and":[\u2026]}`;
+    return `${path60} names ${entries.length} conditions side by side (${entries.map(([key]) => key).join(", ")}) \u2014 Meta reads one branch or one field test per object, so combine them with {"and":[\u2026]}`;
   }
   for (const [key, value2] of entries) {
-    const refusal = conditionRefusal(key, value2, path59);
+    const refusal = conditionRefusal(key, value2, path60);
     if (refusal) {
       return refusal;
     }
   }
   return void 0;
 }
-function leafRefusal(field, condition, path59) {
+function leafRefusal(field, condition, path60) {
   if (!isRecord2(condition)) {
-    return `${path59}.${field} must be a test like {"i_contains":"/thank-you"}, not a bare value`;
+    return `${path60}.${field} must be a test like {"i_contains":"/thank-you"}, not a bare value`;
   }
   const tests = Object.entries(condition);
   if (tests.length === 0) {
-    return `${path59}.${field} names no test \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")}`;
+    return `${path60}.${field} names no test \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")}`;
   }
   if (tests.length > 1) {
-    return `${path59}.${field} names ${tests.length} operators at once (${tests.map(([operator]) => operator).join(", ")}) \u2014 test a field once per condition and combine them with {"and":[\u2026]}`;
+    return `${path60}.${field} names ${tests.length} operators at once (${tests.map(([operator]) => operator).join(", ")}) \u2014 test a field once per condition and combine them with {"and":[\u2026]}`;
   }
   for (const [operator] of tests) {
     if (!RULE_OPERATORS[operator]) {
-      return `${path59}.${field} uses "${operator}", which is not a Meta rule operator \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")} (URL matching is i_contains, not contains or includes)`;
+      return `${path60}.${field} uses "${operator}", which is not a Meta rule operator \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")} (URL matching is i_contains, not contains or includes)`;
     }
   }
   return void 0;
@@ -43495,11 +43498,11 @@ var updateStatusSchema2 = z10.enum(UPDATE_STATUSES);
 function currencyMinimums(currencyCode) {
   return CURRENCY_MINIMUMS[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM;
 }
-function validateDailyBudgetFloor(money, ctx, path59) {
+function validateDailyBudgetFloor(money, ctx, path60) {
   if (money?.currencyCode) {
     const min = currencyMinimums(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path59, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path60, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -44417,19 +44420,19 @@ function refuseDeleteByUpdate(payload, group) {
     );
   }
 }
-function loadJsonFileArg3(path59) {
-  if (typeof path59 !== "string" || path59.length === 0) {
+function loadJsonFileArg3(path60) {
+  if (typeof path60 !== "string" || path60.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync11(path59, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path60, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation4(`${path59} must contain a JSON object`);
+      failWriteValidation4(`${path60} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation4(`${path59} is not valid JSON: ${err.message}`);
+      failWriteValidation4(`${path60} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -45007,10 +45010,10 @@ Example: baker ads meta ads retag 120252158038400247 --url-tags "utm_source={{si
     }
   },
   run: async ({ args: args8 }) => {
-    const { apiPost: apiPost2 } = await import("./client-CUHMSNK5.js");
-    const { requireChatId: requireChatId2 } = await import("./env-PJTJTW3N.js");
-    const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-A2ASA36U.js");
-    const { handleMetaError: handleMetaError2 } = await import("./shared-LV6PIKFE.js");
+    const { apiPost: apiPost2 } = await import("./client-PIKJZFRA.js");
+    const { requireChatId: requireChatId2 } = await import("./env-6UAIAY4M.js");
+    const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-CFDBWWYJ.js");
+    const { handleMetaError: handleMetaError2 } = await import("./shared-3O5RKQYZ.js");
     try {
       const accountId = bareAccountId2(args8);
       const urlTags = typeof args8["url-tags"] === "string" ? args8["url-tags"] : void 0;
@@ -45161,10 +45164,10 @@ function duplicateCommand2(entity, label) {
       replace: { type: "boolean", description: "Pause the original once the copy publishes" }
     },
     run: async ({ args: args8 }) => {
-      const { apiPost: apiPost2 } = await import("./client-CUHMSNK5.js");
-      const { requireChatId: requireChatId2 } = await import("./env-PJTJTW3N.js");
-      const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-A2ASA36U.js");
-      const { handleMetaError: handleMetaError2 } = await import("./shared-LV6PIKFE.js");
+      const { apiPost: apiPost2 } = await import("./client-PIKJZFRA.js");
+      const { requireChatId: requireChatId2 } = await import("./env-6UAIAY4M.js");
+      const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-CFDBWWYJ.js");
+      const { handleMetaError: handleMetaError2 } = await import("./shared-3O5RKQYZ.js");
       try {
         const accountId = bareAccountId2(args8);
         const chatId = requireChatId2();
@@ -45478,9 +45481,9 @@ var listArgs6 = {
   },
   ...META_LIST_SHAPE_ARGS
 };
-async function readOrEmpty(path59, params, label, hints2) {
+async function readOrEmpty(path60, params, label, hints2) {
   try {
-    return await apiGet(path59, params);
+    return await apiGet(path60, params);
   } catch (err) {
     const message = err instanceof Error ? err.message : "unknown error";
     hints2.push(`Could not read the account's ${label} (${message}); the viewer was read without them.`);
@@ -50419,12 +50422,12 @@ function flowExists(slug) {
   return existsSync3(join2(flowsDir(), slug, "_data.json"));
 }
 function readFlowTree(slug) {
-  const path59 = join2(flowsDir(), slug, "_data.json");
-  if (!existsSync3(path59)) {
+  const path60 = join2(flowsDir(), slug, "_data.json");
+  if (!existsSync3(path60)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync13(path59, "utf-8"));
+    return JSON.parse(readFileSync13(path60, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -51401,12 +51404,12 @@ function readPeopleFile(args8) {
 }
 function unreadablePeopleFile(args8) {
   if (!args8["people-file"]) return void 0;
-  const path59 = String(args8["people-file"]);
+  const path60 = String(args8["people-file"]);
   try {
-    readFileSync14(path59, "utf8");
+    readFileSync14(path60, "utf8");
     return void 0;
   } catch {
-    return `Couldn't read --people-file ${path59}. Check the path, or pass the people inline with --person.`;
+    return `Couldn't read --people-file ${path60}. Check the path, or pass the people inline with --person.`;
   }
 }
 function peopleLimitError(args8) {
@@ -52378,11 +52381,11 @@ function parseFieldArgs(argv) {
   for (const pair of parseRepeated(argv, "--field")) {
     const eq = pair.indexOf("=");
     const field = eq === -1 ? pair : pair.slice(0, eq);
-    const path59 = eq === -1 ? "" : pair.slice(eq + 1).trim();
+    const path60 = eq === -1 ? "" : pair.slice(eq + 1).trim();
     const problem = mappingRowProblem(field);
     if (problem !== null) throw new ConversionArgsError(problem);
-    if (path59 === "") throw new ConversionArgsError(`--field ${field} needs a path: --field ${field}=<dotted.path>.`);
-    mapping[field] = path59;
+    if (path60 === "") throw new ConversionArgsError(`--field ${field} needs a path: --field ${field}=<dotted.path>.`);
+    mapping[field] = path60;
   }
   return mapping;
 }
@@ -53984,11 +53987,11 @@ function unwrap(response) {
   }
   return response.data;
 }
-async function readAvatars(path59, params) {
-  return unwrap(await apiGet(path59, params));
+async function readAvatars(path60, params) {
+  return unwrap(await apiGet(path60, params));
 }
-async function writeAvatars(path59, body) {
-  return unwrap(await apiPost(path59, body));
+async function writeAvatars(path60, body) {
+  return unwrap(await apiPost(path60, body));
 }
 
 // src/commands/avatars/create.ts
@@ -54901,12 +54904,12 @@ function missingFontFiles(urls, available) {
 function planFontAdoption(sources, families) {
   const wanted = new Map(families.map((family) => [normalizeFamily(family), family]));
   const byFamily = /* @__PURE__ */ new Map();
-  for (const { path: path59, source } of sources) {
-    const dir = posix.dirname(path59);
+  for (const { path: path60, source } of sources) {
+    const dir = posix.dirname(path60);
     for (const face of declaredFontFaces(source)) {
       if (!wanted.has(face.family)) continue;
       const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
-      perFile.set(path59, [...perFile.get(path59) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      perFile.set(path60, [...perFile.get(path60) ?? [], rebaseFontFaceSrc(face.block, dir)]);
       byFamily.set(face.family, perFile);
     }
   }
@@ -55668,7 +55671,7 @@ var catalogCommand = defineCommand128({
 });
 
 // src/commands/canvas/critique.ts
-import path11 from "path";
+import path12 from "path";
 import { defineCommand as defineCommand129 } from "citty";
 
 // src/engine/scaffold/lib/shoot-modes.ts
@@ -56412,8 +56415,8 @@ function critiqueCanvas(canvas) {
 }
 
 // src/commands/canvas/prepare-canvas.ts
-import { readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
+import path11 from "path";
 
 // src/commands/canvas/normalize-paths.ts
 import { existsSync as existsSync4, realpathSync } from "fs";
@@ -56554,9 +56557,90 @@ function unsuppliedPlaceholderAssets(canvas) {
   return out;
 }
 
+// src/commands/canvas/promote-canvas-outputs.ts
+import { readFile as readFile3 } from "fs/promises";
+import path5 from "path";
+async function promoteCanvasOutputPaths(canvas, canvasDir, workspaceRoot, durableUrlFor, log = () => void 0) {
+  if (!canvas || typeof canvas !== "object") return { canvas, rewrites: [] };
+  const nodes = canvas.nodes;
+  if (!Array.isArray(nodes)) return { canvas, rewrites: [] };
+  const outputsRoot = path5.join(path5.resolve(workspaceRoot), "canvas");
+  const rewrites = [];
+  const promoted = [];
+  for (const node of nodes) {
+    promoted.push(await promoteNode(node));
+  }
+  return rewrites.length === 0 ? { canvas, rewrites } : { canvas: { ...canvas, nodes: promoted }, rewrites };
+  async function promoteNode(node) {
+    const n = node;
+    const params = n?.params;
+    if (n?.type !== "ingest" || !params || params.source !== "path" || typeof params.path !== "string") return node;
+    const from = params.path;
+    const target = path5.resolve(canvasDir, from);
+    const inOutputs = path5.relative(outputsRoot, target);
+    if (inOutputs === "" || inOutputs.startsWith("..") || path5.isAbsolute(inOutputs)) return node;
+    const nodeId = typeof n.id === "string" ? n.id : "?";
+    const url = await durableCopyOf(target, inOutputs, durableUrlFor);
+    if (url === null) {
+      log(`[canvas] ${nodeId}: "${from}" is in canvas/, which is not committed, and no durable copy could be found for it`);
+      return node;
+    }
+    const expect = typeof params.expect === "string" ? params.expect : "";
+    if (!isAssetKind(expect) || canvasAssetMime(url, expect) === null) {
+      log(`[canvas] ${nodeId}: "${from}" is in canvas/; its durable copy ${url} would not ingest back as ${expect || "its kind"}, so the path was left as it is`);
+      return node;
+    }
+    const { path: _path, ...rest } = params;
+    rewrites.push({ nodeId, param: "source", from, to: url });
+    return { ...n, params: { ...rest, source: "url", url } };
+  }
+}
+function isAssetKind(value2) {
+  return ["image", "video", "audio", "text", "json", "font"].includes(value2);
+}
+async function durableCopyOf(target, inOutputs, durableUrlFor) {
+  const bytes = await readFile3(target).catch(() => null);
+  if (bytes !== null) {
+    return durableUrlFor({ sha256: sha256Hex(bytes), mime: inferMimeFromPath(target, bytes), bytes });
+  }
+  const address = /^\.cache[/\\]assets[/\\]([0-9a-f]{2})[/\\]([0-9a-f]{64})\.[a-z0-9]+$/.exec(inOutputs);
+  if (!address?.[2] || !address[2].startsWith(address[1] ?? "")) return null;
+  return durableUrlFor({ sha256: address[2], mime: inferMimeFromPath(target, Buffer.alloc(0)) });
+}
+function backendDurableUrlFor(log = () => void 0) {
+  const connection = optionalConnection();
+  if (!connection) return async () => null;
+  const client = new BackendClient(connection);
+  return async ({ sha256: sha2562, mime, bytes }) => {
+    try {
+      const { putUrl, publicUrl, conditional } = await client.presignAssetUpload(sha2562, mime, void 0, "source", true);
+      const held = await fetch(publicUrl, { method: "HEAD" }).then(
+        (res) => res.ok,
+        () => false
+      );
+      if (held) return publicUrl;
+      if (!bytes) {
+        log(`[canvas] the asset store does not hold ${sha2562.slice(0, 12)}\u2026, and the file is not here to keep`);
+        return null;
+      }
+      const put = await fetch(putUrl, {
+        method: "PUT",
+        body: new Uint8Array(bytes),
+        headers: conditional ? { "Content-Type": mime, "If-None-Match": "*" } : { "Content-Type": mime }
+      });
+      if (put.ok || conditional === true && put.status === 412) return publicUrl;
+      log(`[canvas] could not keep ${sha2562.slice(0, 12)}\u2026 in the asset store (upload answered ${put.status})`);
+      return null;
+    } catch (e) {
+      log(`[canvas] could not reach the asset store for ${sha2562.slice(0, 12)}\u2026: ${e instanceof Error ? e.message : String(e)}`);
+      return null;
+    }
+  };
+}
+
 // src/commands/canvas/scene-projection.ts
-import { readFile as readFile4 } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path7 from "path";
 
 // src/engine/scaffold/video/aspect.ts
 var OUTPUT_ASPECTS = ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "4:5", "2:3", "3:2"];
@@ -59209,8 +59293,8 @@ function scaffoldVideoCanvas(input, elementsInput, requested) {
 }
 
 // src/commands/canvas/scene-files.ts
-import { mkdir as mkdir2, readFile as readFile3, readdir as readdir2, rm, writeFile as writeFile3 } 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";
@@ -59227,19 +59311,19 @@ function splitBlueprint(blueprint) {
 }
 async function writeSceneFiles(outDir, blueprint) {
   const { global, scenes } = splitBlueprint(blueprint);
-  await writeFile3(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 writeFile3(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) {
@@ -59252,17 +59336,17 @@ 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 readFile3(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) {
-    scenes.push(JSON.parse(await readFile3(file, "utf8")));
+    scenes.push(JSON.parse(await readFile4(file, "utf8")));
   }
   return { ...global, scenes };
 }
@@ -59336,12 +59420,12 @@ function parseRebuild(raw) {
   return { elements, ...registeredRebuildOpts(opts) };
 }
 async function sceneOwnedPrompts(canvasPath) {
-  const creativeDir = path6.dirname(canvasPath);
+  const creativeDir = path7.dirname(canvasPath);
   const blueprint = await reassembleBlueprint(creativeDir);
   if (!blueprint) return /* @__PURE__ */ new Map();
   let rebuildRaw;
   try {
-    rebuildRaw = await readFile4(path6.join(creativeDir, REBUILD_FILE), "utf8");
+    rebuildRaw = await readFile5(path7.join(creativeDir, REBUILD_FILE), "utf8");
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -59357,12 +59441,12 @@ async function sceneOwnedPrompts(canvasPath) {
   return owned;
 }
 async function syncSceneNodeParams(canvas, canvasPath, log) {
-  const creativeDir = path6.dirname(canvasPath);
+  const creativeDir = path7.dirname(canvasPath);
   const blueprint = await reassembleBlueprint(creativeDir);
   if (!blueprint) return "not_applicable";
   let rebuildRaw;
   try {
-    rebuildRaw = await readFile4(path6.join(creativeDir, REBUILD_FILE), "utf8");
+    rebuildRaw = await readFile5(path7.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.`
@@ -59408,27 +59492,27 @@ async function syncSceneNodeParams(canvas, canvasPath, log) {
 }
 
 // src/commands/canvas/source-version.ts
-import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import path7 from "path";
+import { readdir as readdir3, readFile as readFile6 } from "fs/promises";
+import path8 from "path";
 import { parse as parseYaml } from "yaml";
 async function computeSourceSha(canvasPath, opts = {}) {
   let canvasBytes;
   try {
-    canvasBytes = await readFile5(canvasPath);
+    canvasBytes = await readFile6(canvasPath);
   } catch {
     return void 0;
   }
-  const canvasDir = path7.dirname(canvasPath);
+  const canvasDir = path8.dirname(canvasPath);
   const parts = [];
   const fold2 = (bytes) => parts.push(Buffer.from(`${bytes.length}\0`), bytes);
   const graph = opts.graph !== void 0 ? opts.graph : parseOrUndefined(canvasBytes);
   fold2(graph === void 0 ? canvasBytes : Buffer.from(canonicalize(graph)));
-  fold2(canonicalJson(await readOrEmpty2(path7.join(canvasDir, "prompt.json")), withoutBookkeeping));
+  fold2(canonicalJson(await readOrEmpty2(path8.join(canvasDir, "prompt.json")), withoutBookkeeping));
   for (const sceneFile of await listSceneFiles(canvasDir)) fold2(canonicalJson(await readOrEmpty2(sceneFile)));
   for (const dir of compositionDirs(graph, canvasPath)) {
-    fold2(Buffer.from(`composition:${toPosix(path7.relative(canvasDir, dir))}`));
+    fold2(Buffer.from(`composition:${toPosix(path8.relative(canvasDir, dir))}`));
     for (const file of await listCompositionFiles(dir)) {
-      fold2(Buffer.from(toPosix(path7.relative(dir, file))));
+      fold2(Buffer.from(toPosix(path8.relative(dir, file))));
       fold2(await readOrEmpty2(file));
     }
   }
@@ -59458,7 +59542,7 @@ function withoutBookkeeping(blueprint) {
 }
 async function readOrEmpty2(file) {
   try {
-    return await readFile5(file);
+    return await readFile6(file);
   } catch {
     return Buffer.alloc(0);
   }
@@ -59467,15 +59551,15 @@ var COMPOSITION_NODE_TYPES = /* @__PURE__ */ new Set(["hyperframe_render", "hype
 function compositionDirs(canvas, canvasPath) {
   const nodes = canvas?.nodes;
   if (!Array.isArray(nodes)) return [];
-  const canvasDir = path7.dirname(canvasPath);
+  const canvasDir = path8.dirname(canvasPath);
   const dirs = /* @__PURE__ */ new Set();
   for (const node of nodes) {
     if (typeof node?.type !== "string" || !COMPOSITION_NODE_TYPES.has(node.type)) continue;
     const ref2 = node.params?.composition;
     if (typeof ref2 !== "string" || ref2.length === 0 || ref2.includes("[TODO") || looksLikeHttpUrl(ref2)) continue;
-    const dir = path7.resolve(canvasDir, ref2);
-    const rel = path7.relative(dir, canvasDir);
-    if (rel === "" || !rel.startsWith("..") && !path7.isAbsolute(rel)) continue;
+    const dir = path8.resolve(canvasDir, ref2);
+    const rel = path8.relative(dir, canvasDir);
+    if (rel === "" || !rel.startsWith("..") && !path8.isAbsolute(rel)) continue;
     dirs.add(dir);
   }
   return [...dirs].sort();
@@ -59488,12 +59572,12 @@ async function listCompositionFiles(dir) {
   } catch {
     return [];
   }
-  return entries.filter((entry) => entry.isFile()).map((entry) => path7.join(entry.parentPath, entry.name)).filter((file) => !path7.relative(dir, file).split(path7.sep).some((part) => SKIPPED_ENTRIES.has(part))).sort();
+  return entries.filter((entry) => entry.isFile()).map((entry) => path8.join(entry.parentPath, entry.name)).filter((file) => !path8.relative(dir, file).split(path8.sep).some((part) => SKIPPED_ENTRIES.has(part))).sort();
 }
 async function definitionFormats(canvasDir) {
   let raw;
   try {
-    raw = await readFile5(path7.join(canvasDir, "_definition.md"), "utf8");
+    raw = await readFile6(path8.join(canvasDir, "_definition.md"), "utf8");
   } catch {
     return [];
   }
@@ -59507,16 +59591,16 @@ async function definitionFormats(canvasDir) {
   }
 }
 function toPosix(p) {
-  return p.split(path7.sep).join("/");
+  return p.split(path8.sep).join("/");
 }
 
 // src/commands/canvas/static-copy-projection.ts
-import { readFile as readFile7, stat } from "fs/promises";
-import path9 from "path";
+import { readFile as readFile8, stat } from "fs/promises";
+import path10 from "path";
 
 // src/engine/scaffold/ad-brand-source.ts
-import { readdir as readdir4, readFile as readFile6 } from "fs/promises";
-import path8 from "path";
+import { readdir as readdir4, readFile as readFile7 } from "fs/promises";
+import path9 from "path";
 import sharp from "sharp";
 var BRAND_DIR = "src/brand";
 function paletteFromBrandDoc(markdown) {
@@ -59568,16 +59652,16 @@ function pickBrandMark(files) {
 }
 async function readBrandFromWorkspace(root = ".") {
   const found = {};
-  const doc = await readFile6(path8.join(root, BRAND_DIR, "BRAND.md"), "utf-8").catch(() => null);
+  const doc = await readFile7(path9.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 = path8.join(root, BRAND_DIR, "logos");
+  const dir = path9.join(root, BRAND_DIR, "logos");
   const files = await readdir4(dir).catch(() => null);
   if (files) {
     const mark = pickBrandMark(files);
-    if (mark) found.logo = path8.join(BRAND_DIR, "logos", mark);
+    if (mark) found.logo = path9.join(BRAND_DIR, "logos", mark);
   }
   return found;
 }
@@ -59587,18 +59671,18 @@ function svgIsLiveText(svg) {
 async function markIsReal(markPath, root = ".") {
   const brandLogos = await findBrandLogosDir(markPath, root);
   if (brandLogos) return await markDirectoryIsReal(brandLogos);
-  return await markDirectoryIsReal(path8.dirname(markPath));
+  return await markDirectoryIsReal(path9.dirname(markPath));
 }
 async function findBrandLogosDir(markPath, root) {
   const candidates = [];
-  let dir = path8.resolve(path8.dirname(markPath));
+  let dir = path9.resolve(path9.dirname(markPath));
   for (; ; ) {
-    candidates.push(path8.join(dir, BRAND_DIR, "logos"));
-    const parent = path8.dirname(dir);
+    candidates.push(path9.join(dir, BRAND_DIR, "logos"));
+    const parent = path9.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  candidates.push(path8.join(root, BRAND_DIR, "logos"));
+  candidates.push(path9.join(root, BRAND_DIR, "logos"));
   for (const candidate of candidates) {
     if (await readdir4(candidate).then(
       () => true,
@@ -59614,7 +59698,7 @@ async function markDirectoryIsReal(dir) {
   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 readFile6(path8.join(dir, f), "utf-8").catch(() => null);
+    const svg = await readFile7(path9.join(dir, f), "utf-8").catch(() => null);
     if (svg === null || svgIsLiveText(svg)) return false;
   }
   return true;
@@ -59967,17 +60051,17 @@ function blueprintPath(nodes) {
 }
 async function readStaticPromptJson(canvas) {
   const source = blueprintPath(nodesOf2(canvas));
-  return source ? JSON.parse(await readFile7(source, "utf8")) : null;
+  return source ? JSON.parse(await readFile8(source, "utf8")) : null;
 }
 async function findBrandRoot(start) {
-  let dir = path9.resolve(start);
+  let dir = path10.resolve(start);
   for (; ; ) {
-    if (await stat(path9.join(dir, BRAND_DIR)).then(
+    if (await stat(path10.join(dir, BRAND_DIR)).then(
       (s) => s.isDirectory(),
       () => false
     ))
       return dir;
-    const parent = path9.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -60018,7 +60102,7 @@ async function syncStaticAdLogo(canvas, log) {
   const logoNodes = nodes.filter((n) => n.type === "ingest" && n.tags?.role === BRAND_LOGO_ROLE);
   const renders = nodes.filter((n) => n.type === "image_generate" && typeof n.params?.prompt === "string");
   if (!source || renders.length === 0 || !isStaticBriefCanvas(canvas)) return "not_applicable";
-  const wanted = readAdSpec(JSON.parse(await readFile7(source, "utf8"))).logo;
+  const wanted = readAdSpec(JSON.parse(await readFile8(source, "utf8"))).logo;
   if (wanted && logoNodes.length === 0) {
     log("[logo] prompt.json keeps the logo but this canvas was scaffolded without the brand's file: put it in src/brand/logos/ and re-scaffold to have it drawn");
     return "up_to_date";
@@ -60128,8 +60212,8 @@ function logoComposited(opts) {
 }
 var MAX_TAKES = 3;
 var UNCOMPILED = "compiled from prompt.json";
-function ingestNode(id, path59, expect) {
-  return { id, type: "ingest", params: { source: "path", path: path59, expect } };
+function ingestNode(id, path60, expect) {
+  return { id, type: "ingest", params: { source: "path", path: path60, expect } };
 }
 function sheetSubjectDescription(el) {
   const desc = el.description ?? `the ${el.type}`;
@@ -60684,7 +60768,7 @@ function upgradedDescription(text3, old, plan) {
 }
 
 // src/commands/canvas/style-projection.ts
-import { readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile4 } from "fs/promises";
 function findBlueprintProjection(canvas) {
   if (!canvas || typeof canvas !== "object") return null;
   const nodes = canvas.nodes;
@@ -60712,8 +60796,8 @@ function renderStyleProjectionFromValue(blueprint) {
 async function syncStyleProjection(canvas, log) {
   const pair = findBlueprintProjection(canvas);
   if (!pair) return "not_applicable";
-  const rendered = renderStyleProjection(await readFile8(pair.promptPath, "utf8"));
-  const current = await readFile8(pair.stylePath, "utf8").catch(() => null);
+  const rendered = renderStyleProjection(await readFile9(pair.promptPath, "utf8"));
+  const current = await readFile9(pair.stylePath, "utf8").catch(() => null);
   if (current === rendered) return "up_to_date";
   await writeFile4(pair.stylePath, rendered, "utf8");
   log(
@@ -60743,14 +60827,14 @@ var CanvasPrepareError = class extends Error {
   }
 };
 async function prepareCanvas(canvasPath, opts = {}) {
-  const filePath = path10.resolve(canvasPath);
-  const canvasDir = path10.dirname(filePath);
+  const filePath = path11.resolve(canvasPath);
+  const canvasDir = path11.dirname(filePath);
   const notes = [];
   const log = (line) => {
     notes.push(line);
     opts.log?.(line);
   };
-  const raw = await readFile9(filePath, "utf8");
+  const raw = await readFile10(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -60759,8 +60843,20 @@ async function prepareCanvas(canvasPath, opts = {}) {
   }
   const write = opts.write !== false;
   const healed = write ? await healCanvasPaths(filePath, parsed) : healInMemory(filePath, parsed);
-  const onDisk = healed.canvas;
+  let onDisk = healed.canvas;
   let text3 = healed.text ?? raw;
+  const rewrites = [...healed.rewrites];
+  if (write) {
+    const workspaceRoot = findWorkspaceRoot(canvasDir);
+    const promoted = workspaceRoot ? await promoteCanvasOutputPaths(onDisk, canvasDir, workspaceRoot, backendDurableUrlFor(log), log) : { canvas: onDisk, rewrites: [] };
+    if (promoted.rewrites.length > 0) {
+      onDisk = promoted.canvas;
+      text3 = `${JSON.stringify(onDisk, null, 2)}
+`;
+      await writeFile5(filePath, text3, "utf8");
+      rewrites.push(...promoted.rewrites);
+    }
+  }
   const upgrade = upgradeStaticCanvas(resolveRelativeCanvasPaths(structuredClone(onDisk), canvasDir));
   const canvas = upgrade.canvas;
   if (upgrade.upgraded) {
@@ -60775,7 +60871,7 @@ async function prepareCanvas(canvasPath, opts = {}) {
     if (logo === "regenerated") staticCopy = "regenerated";
   } catch (e) {
     throw new CanvasPrepareError("style_projection", `prompt.json is not readable or not a valid ad: ${errorMessage(e)}`, {
-      fix: `Fix ${path10.join(canvasDir, "prompt.json")} so it parses as JSON (and, for a static ad, matches the ad spec the message names), then re-run.`
+      fix: `Fix ${path11.join(canvasDir, "prompt.json")} so it parses as JSON (and, for a static ad, matches the ad spec the message names), then re-run.`
     });
   }
   let scenes;
@@ -60785,7 +60881,7 @@ async function prepareCanvas(canvasPath, opts = {}) {
     throw new CanvasPrepareError(
       "scene_projection",
       `a scenes/*.json file is not readable/valid or its rebuild failed: ${errorMessage(e)}`,
-      { fix: `Fix the scene files in ${path10.join(canvasDir, "scenes")} so each parses as JSON, then re-run.` }
+      { fix: `Fix the scene files in ${path11.join(canvasDir, "scenes")} so each parses as JSON, then re-run.` }
     );
   }
   const projected = withFilePaths(canvas, onDisk);
@@ -60815,13 +60911,13 @@ async function prepareCanvas(canvasPath, opts = {}) {
     text: text3,
     sourceSha: await computeSourceSha(filePath, { graph: projected ?? onDisk }),
     written,
-    rewrites: healed.rewrites,
+    rewrites,
     projections: { style, staticCopy, scenes },
     notes
   };
 }
 function healInMemory(filePath, canvas) {
-  const canvasDir = path10.dirname(filePath);
+  const canvasDir = path11.dirname(filePath);
   const workspaceRoot = findWorkspaceRoot(canvasDir);
   if (!workspaceRoot) return { canvas, rewrites: [], text: null };
   return { ...normalizeCanvasPaths(canvas, canvasDir, workspaceRoot), text: null };
@@ -60862,7 +60958,7 @@ var critiqueCommand = defineCommand129({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args: args8 }) {
-    const filePath = path11.resolve(String(args8.file));
+    const filePath = path12.resolve(String(args8.file));
     let prepared;
     try {
       prepared = await prepareCanvas(filePath, { log: (line) => process.stderr.write(`${line}
@@ -60890,8 +60986,8 @@ var critiqueCommand = defineCommand129({
 
 // src/commands/canvas/inspect.ts
 import { execFile } from "child_process";
-import { readdir as readdir5, readFile as readFile10, stat as stat2 } from "fs/promises";
-import path12 from "path";
+import { readdir as readdir5, readFile as readFile11, stat as stat2 } from "fs/promises";
+import path13 from "path";
 import { promisify } from "util";
 import { defineCommand as defineCommand130 } from "citty";
 
@@ -60923,12 +61019,12 @@ var inspectCommand = defineCommand130({
   },
   async run({ args: args8 }) {
     const cwd = process.cwd();
-    const outputsDir = args8["outputs-dir"] ? path12.resolve(String(args8["outputs-dir"])) : path12.join(findWorkspaceRoot(cwd) ?? cwd, "canvas");
+    const outputsDir = args8["outputs-dir"] ? path13.resolve(String(args8["outputs-dir"])) : path13.join(findWorkspaceRoot(cwd) ?? cwd, "canvas");
     const runArg = String(args8.run);
     const runDir = await localRunDir(runArg, outputsDir);
     if (!runDir) {
-      if (path12.isAbsolute(runArg)) fail3("not_found", `${runArg} is not a run directory`);
-      await inspectFromHistory(runArg, path12.join(outputsDir, runArg));
+      if (path13.isAbsolute(runArg)) fail3("not_found", `${runArg} is not a run directory`);
+      await inspectFromHistory(runArg, path13.join(outputsDir, runArg));
       return;
     }
     const manifest = await loadManifest(runDir);
@@ -60941,7 +61037,7 @@ var inspectCommand = defineCommand130({
     const summary = {
       ok: true,
       source: "local",
-      run_id: manifest.run_id ?? path12.basename(runDir),
+      run_id: manifest.run_id ?? path13.basename(runDir),
       run_dir: runDir,
       stats: manifest.stats ?? null,
       output: manifest.output ?? null,
@@ -60954,7 +61050,7 @@ var inspectCommand = defineCommand130({
   }
 });
 async function localRunDir(run2, outputsDir) {
-  const candidate = path12.isAbsolute(run2) ? run2 : path12.join(outputsDir, run2);
+  const candidate = path13.isAbsolute(run2) ? run2 : path13.join(outputsDir, run2);
   const s = await stat2(candidate).catch(() => null);
   return s?.isDirectory() ? candidate : null;
 }
@@ -61009,9 +61105,9 @@ function fail3(code, message) {
   process.exit(2);
 }
 async function loadManifest(runDir) {
-  const manifestPath = path12.join(runDir, "manifest.json");
+  const manifestPath = path13.join(runDir, "manifest.json");
   try {
-    const raw = await readFile10(manifestPath, "utf-8");
+    const raw = await readFile11(manifestPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -61021,7 +61117,7 @@ async function listRunFiles(runDir) {
   const out = [];
   const names = await readdir5(runDir);
   for (const name of names) {
-    const abs = path12.join(runDir, name);
+    const abs = path13.join(runDir, name);
     const s = await stat2(abs).catch(() => null);
     if (!s?.isFile()) continue;
     out.push({ name, path: abs, size: s.size });
@@ -61069,18 +61165,18 @@ async function probeDuration(filePath) {
 import { defineCommand as defineCommand133 } from "citty";
 
 // src/commands/canvas/run.ts
-import path25 from "path";
+import path26 from "path";
 import { defineCommand as defineCommand132 } from "citty";
 
 // src/commands/canvas/definition-status.ts
-import { readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
-import path13 from "path";
+import { readFile as readFile12, writeFile as writeFile6 } from "fs/promises";
+import path14 from "path";
 import { parseDocument } from "yaml";
 var ORDER = { draft: 0, rendered: 1, published: 2 };
 async function advanceDefinitionStatus(definitionPath, to) {
   let raw;
   try {
-    raw = await readFile11(definitionPath, "utf8");
+    raw = await readFile12(definitionPath, "utf8");
   } catch {
     return "missing";
   }
@@ -61103,12 +61199,12 @@ ${nextFrontmatter}---${raw.slice(match[0].length)}`, "utf8");
   return "updated";
 }
 function definitionPathFor(workspaceRoot, slug) {
-  return path13.join(workspaceRoot, "src", "creatives", slug, "_definition.md");
+  return path14.join(workspaceRoot, "src", "creatives", slug, "_definition.md");
 }
 
 // src/commands/canvas/output-ratio.ts
-import { readFile as readFile12 } from "fs/promises";
-import path14 from "path";
+import { readFile as readFile13 } from "fs/promises";
+import path15 from "path";
 function definitionFormats2(markdown) {
   const front = markdown.match(/^---\n([\s\S]*?)\n---/)?.[1];
   if (!front) return [];
@@ -61183,21 +61279,21 @@ function outputRatioWarnings(declared, produced) {
   });
 }
 async function outputRatioWarningsFor(canvas, canvasPath) {
-  const definition = await readFile12(path14.join(path14.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
+  const definition = await readFile13(path15.join(path15.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
   if (!definition) return [];
   return outputRatioWarnings(definitionFormats2(definition), await producedRatios(canvas));
 }
 
 // src/commands/canvas/render-state.ts
-import { mkdir as mkdir3, readdir as readdir6, readFile as readFile13, rm as rm2, writeFile as writeFile7 } from "fs/promises";
-import path15 from "path";
+import { mkdir as mkdir3, readdir as readdir6, readFile as readFile14, rm as rm2, writeFile as writeFile7 } from "fs/promises";
+import path16 from "path";
 var RENDER_STATE_DIR = ".rendered";
 function statePath(canvasRoot, slug) {
-  return path15.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);
+  return path16.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);
 }
 async function readRenderState(canvasRoot, slug) {
   try {
-    const parsed = JSON.parse(await readFile13(statePath(canvasRoot, slug), "utf8"));
+    const parsed = JSON.parse(await readFile14(statePath(canvasRoot, slug), "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -61206,7 +61302,7 @@ async function readRenderState(canvasRoot, slug) {
 async function updateRenderState(canvasRoot, slug, patch) {
   try {
     const next = { ...await readRenderState(canvasRoot, slug), ...patch };
-    await mkdir3(path15.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });
+    await mkdir3(path16.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });
     await writeFile7(statePath(canvasRoot, slug), `${JSON.stringify(next, null, 2)}
 `, "utf8");
   } catch {
@@ -61229,8 +61325,8 @@ function isRenderStale(state, currentSourceSha) {
   return state.attempted?.sourceSha !== currentSourceSha;
 }
 async function staleCreatives(workspaceRoot) {
-  const creativesDir = path15.join(workspaceRoot, "src", "creatives");
-  const canvasRoot = path15.join(workspaceRoot, "canvas");
+  const creativesDir = path16.join(workspaceRoot, "src", "creatives");
+  const canvasRoot = path16.join(workspaceRoot, "canvas");
   let slugs;
   try {
     slugs = (await readdir6(creativesDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -61241,7 +61337,7 @@ async function staleCreatives(workspaceRoot) {
   for (const slug of slugs.sort()) {
     const state = await readRenderState(canvasRoot, slug);
     if (!state.rendered) continue;
-    const canvasPath = path15.join(creativesDir, slug, `${slug}.canvas.json`);
+    const canvasPath = path16.join(creativesDir, slug, `${slug}.canvas.json`);
     let prepared;
     try {
       prepared = await prepareCanvas(canvasPath, { write: false });
@@ -61253,7 +61349,7 @@ async function staleCreatives(workspaceRoot) {
     if (!current || !isRenderStale(state, current)) continue;
     stale.push({
       slug,
-      canvasPath: path15.relative(workspaceRoot, canvasPath).split(path15.sep).join("/"),
+      canvasPath: path16.relative(workspaceRoot, canvasPath).split(path16.sep).join("/"),
       renderedRunId: state.rendered.runId,
       sourceSha: current
     });
@@ -61261,7 +61357,7 @@ async function staleCreatives(workspaceRoot) {
   return stale;
 }
 async function clearLegacyDirtyMarker(canvasRoot, slug) {
-  await rm2(path15.join(canvasRoot, ".dirty", `${slug}.json`), { force: true }).catch(() => void 0);
+  await rm2(path16.join(canvasRoot, ".dirty", `${slug}.json`), { force: true }).catch(() => void 0);
 }
 
 // src/commands/canvas/node-preview.ts
@@ -61317,13 +61413,13 @@ ${body}` : header || body || compactJson(record);
 }
 
 // src/commands/canvas/run-record.ts
-import path16 from "path";
+import path17 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(path16.sep).join("/");
+  const normalized = filePath.split(path17.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;
@@ -61631,7 +61727,7 @@ var RunRecordPoster = class {
 
 // src/commands/canvas/run-retention.ts
 import { rm as rm3 } from "fs/promises";
-import path17 from "path";
+import path18 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;
@@ -61648,7 +61744,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 rm3(path17.join(outputsDir, dir), { recursive: true, force: true }).catch(
+    await rm3(path18.join(outputsDir, dir), { recursive: true, force: true }).catch(
       (e) => log(`[prune   ] could not remove ${dir}: ${e.message}`)
     );
   }
@@ -61657,15 +61753,15 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
 
 // src/commands/canvas/run-resume.ts
 import { randomUUID } from "crypto";
-import { mkdir as mkdir4, readFile as readFile14, rm as rm4, writeFile as writeFile8 } from "fs/promises";
-import path18 from "path";
+import { mkdir as mkdir4, readFile as readFile15, rm as rm4, writeFile as writeFile8 } from "fs/promises";
+import path19 from "path";
 function markerKey(canvasPath) {
   const slug = creativeSlugFromCanvasPath(canvasPath);
-  const identity = slug ?? path18.relative(process.cwd(), path18.resolve(canvasPath));
+  const identity = slug ?? path19.relative(process.cwd(), path19.resolve(canvasPath));
   return sha256Hex(Buffer.from(identity)).slice(0, 32);
 }
 function markerFile(outputsDir, canvasPath) {
-  return path18.join(outputsDir, ".inflight", `${markerKey(canvasPath)}.json`);
+  return path19.join(outputsDir, ".inflight", `${markerKey(canvasPath)}.json`);
 }
 function classifyRemoteRun(run2) {
   if (run2.interrupted === true || run2.status === "awaiting_approval") return "adopt";
@@ -61718,7 +61814,7 @@ async function resolveRunId(opts) {
 }
 async function readMarker(outputsDir, canvasPath) {
   try {
-    const parsed = JSON.parse(await readFile14(markerFile(outputsDir, canvasPath), "utf8"));
+    const parsed = JSON.parse(await readFile15(markerFile(outputsDir, canvasPath), "utf8"));
     if (typeof parsed.runId !== "string" || parsed.runId.length === 0) return null;
     const num4 = (value2) => typeof value2 === "number" && Number.isFinite(value2) ? value2 : void 0;
     return {
@@ -61743,14 +61839,14 @@ async function markRunInFlight(outputsDir, canvasPath, runId, sourceSha) {
       runId,
       pid: process.pid,
       token,
-      canvasPath: path18.resolve(canvasPath),
+      canvasPath: path19.resolve(canvasPath),
       startedAt,
       heartbeatAt,
       ...sourceSha ? { sourceSha } : {}
     })
   );
   try {
-    await mkdir4(path18.dirname(file), { recursive: true });
+    await mkdir4(path19.dirname(file), { recursive: true });
     await write(startedAt);
   } catch {
   }
@@ -61773,8 +61869,8 @@ async function clearRunMarker(outputsDir, canvasPath, token) {
 
 // src/commands/canvas/run-snapshot.ts
 import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir5, readdir as readdir7, readFile as readFile15, stat as stat3, writeFile as writeFile9 } from "fs/promises";
-import path19 from "path";
+import { mkdir as mkdir5, readdir as readdir7, readFile as readFile16, stat as stat3, writeFile as writeFile9 } from "fs/promises";
+import path20 from "path";
 var SNAPSHOT_SCHEMA = "baker-canvas-snapshot/1";
 var MAX_SNAPSHOT_FILE_BYTES = 32 * 1024 * 1024;
 var EXT_TO_MIME = {
@@ -61801,15 +61897,15 @@ var EXT_TO_MIME = {
   woff2: "font/woff2"
 };
 function mimeForFile(filePath) {
-  const ext = path19.extname(filePath).slice(1).toLowerCase();
+  const ext = path20.extname(filePath).slice(1).toLowerCase();
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
 function toPosix2(p) {
-  return p.split(path19.sep).join("/");
+  return p.split(path20.sep).join("/");
 }
 function isInside2(dir, target) {
-  const rel = path19.relative(dir, target);
-  return !rel.startsWith("..") && !path19.isAbsolute(rel);
+  const rel = path20.relative(dir, target);
+  return !rel.startsWith("..") && !path20.isAbsolute(rel);
 }
 function localPathRefsFromCanvas(parsed) {
   const nodes = parsed?.nodes;
@@ -61832,20 +61928,20 @@ var FINGERPRINTED_FILES = ["prompt.json", "_definition.md"];
 async function sourceRefsToSnapshot(canvasDir, parsed) {
   const refs = new Set(localPathRefsFromCanvas(parsed));
   for (const sceneFile of await listSceneFiles(canvasDir)) {
-    refs.add(toPosix2(path19.relative(canvasDir, sceneFile)));
+    refs.add(toPosix2(path20.relative(canvasDir, sceneFile)));
   }
   refs.add(REBUILD_FILE);
   for (const fingerprinted of FINGERPRINTED_FILES) {
-    if (existsSync5(path19.join(canvasDir, fingerprinted))) refs.add(fingerprinted);
+    if (existsSync5(path20.join(canvasDir, fingerprinted))) refs.add(fingerprinted);
   }
   return [...refs];
 }
 async function uploadRunSnapshot(client, opts) {
   try {
-    const canvasDir = path19.dirname(opts.canvasPath);
+    const canvasDir = path20.dirname(opts.canvasPath);
     const canvasBytes = Buffer.from(opts.raw);
     const canvasEntry = {
-      path: path19.basename(opts.canvasPath),
+      path: path20.basename(opts.canvasPath),
       bytes: canvasBytes,
       sha256: sha256Hex(canvasBytes),
       mime: "application/json"
@@ -61853,10 +61949,10 @@ async function uploadRunSnapshot(client, opts) {
     const files = [];
     const skipped = [];
     for (const refPath of await sourceRefsToSnapshot(canvasDir, opts.parsed)) {
-      const abs = path19.isAbsolute(refPath) ? refPath : path19.resolve(canvasDir, refPath);
+      const abs = path20.isAbsolute(refPath) ? refPath : path20.resolve(canvasDir, refPath);
       if (!isInside2(canvasDir, abs)) {
         skipped.push({
-          path: toPosix2(path19.relative(canvasDir, abs)),
+          path: toPosix2(path20.relative(canvasDir, abs)),
           reason: "outside the creative folder \u2014 read from the workspace on rerun"
         });
         continue;
@@ -61865,18 +61961,18 @@ async function uploadRunSnapshot(client, opts) {
       try {
         st = await stat3(abs);
       } catch {
-        skipped.push({ path: toPosix2(path19.relative(canvasDir, abs)), reason: "missing" });
+        skipped.push({ path: toPosix2(path20.relative(canvasDir, abs)), reason: "missing" });
         continue;
       }
       const fileList = st.isDirectory() ? await listFilesRecursive(abs) : [abs];
       for (const file of fileList) {
-        const rel = toPosix2(path19.relative(canvasDir, file));
+        const rel = toPosix2(path20.relative(canvasDir, file));
         const size = (await stat3(file)).size;
         if (size > MAX_SNAPSHOT_FILE_BYTES) {
           skipped.push({ path: rel, reason: `too large (${size} bytes)` });
           continue;
         }
-        const bytes = await readFile15(file);
+        const bytes = await readFile16(file);
         files.push({ path: rel, bytes, sha256: sha256Hex(bytes), mime: mimeForFile(file) });
       }
     }
@@ -61933,7 +62029,7 @@ async function putContentAddressed(client, bytes, mime, signal) {
 }
 async function listFilesRecursive(dir) {
   const entries = await readdir7(dir, { recursive: true, withFileTypes: true });
-  return entries.filter((d) => d.isFile()).map((d) => path19.join(d.parentPath, d.name));
+  return entries.filter((d) => d.isFile()).map((d) => path20.join(d.parentPath, d.name));
 }
 var SnapshotConflictError = class extends Error {
   conflicts;
@@ -61945,19 +62041,19 @@ var SnapshotConflictError = class extends Error {
 };
 async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
   const entries = [manifest.canvas, ...manifest.files];
-  const resolvedTarget = path19.resolve(targetDir);
+  const resolvedTarget = path20.resolve(targetDir);
   const planned = [];
   const conflicts = [];
   const upToDate = [];
   for (const entry of entries) {
-    if (path19.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
+    if (path20.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const target = path19.resolve(resolvedTarget, entry.path);
-    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path19.sep)) {
+    const target = path20.resolve(resolvedTarget, entry.path);
+    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path20.sep)) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const existing = await readFile15(target).catch(() => null);
+    const existing = await readFile16(target).catch(() => null);
     if (existing) {
       if (sha256Hex(existing) === entry.sha256) {
         upToDate.push(entry.path);
@@ -61979,16 +62075,16 @@ 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(path19.dirname(target), { recursive: true });
+    await mkdir5(path20.dirname(target), { recursive: true });
     await writeFile9(target, bytes);
     restored.push(entry.path);
   }
-  return { canvasPath: path19.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
+  return { canvasPath: path20.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
 }
 
 // src/commands/canvas/render-budget.ts
-import { mkdir as mkdir6, readFile as readFile16, rm as rm5, writeFile as writeFile10 } from "fs/promises";
-import path20 from "path";
+import { mkdir as mkdir6, readFile as readFile17, rm as rm5, writeFile as writeFile10 } from "fs/promises";
+import path21 from "path";
 function claimRender(ledger, chatId) {
   const current = ledger && ledger.chatId === chatId ? ledger : { chatId, renders: 0 };
   if (current.renders >= RENDERS_PER_ROUND) return { allowed: false, renders: current.renders, ledger: current };
@@ -61996,11 +62092,11 @@ function claimRender(ledger, chatId) {
   return { allowed: true, renders: next.renders, ledger: next };
 }
 function ledgerFile(canvasRoot, slug) {
-  return path20.join(canvasRoot, ".render-budget", `${slug}.json`);
+  return path21.join(canvasRoot, ".render-budget", `${slug}.json`);
 }
 async function readLedger(canvasRoot, slug) {
   try {
-    const raw = JSON.parse(await readFile16(ledgerFile(canvasRoot, slug), "utf8"));
+    const raw = JSON.parse(await readFile17(ledgerFile(canvasRoot, slug), "utf8"));
     if (typeof raw.renders !== "number") return null;
     return {
       chatId: raw.chatId ?? null,
@@ -62013,7 +62109,7 @@ async function readLedger(canvasRoot, slug) {
 }
 async function writeLedger(canvasRoot, slug, ledger) {
   try {
-    await mkdir6(path20.dirname(ledgerFile(canvasRoot, slug)), { recursive: true });
+    await mkdir6(path21.dirname(ledgerFile(canvasRoot, slug)), { recursive: true });
     await writeFile10(ledgerFile(canvasRoot, slug), JSON.stringify(ledger));
   } catch {
   }
@@ -62060,7 +62156,7 @@ async function openRenderRound(canvasRoot, slug) {
 }
 async function openRenderRoundInWorkspace(slug) {
   const cwd = process.cwd();
-  await openRenderRound(canvasOutputsRoot(path20.join(cwd, "src", "creatives", slug, "canvas.json"), cwd), slug);
+  await openRenderRound(canvasOutputsRoot(path21.join(cwd, "src", "creatives", slug, "canvas.json"), cwd), slug);
 }
 function isStaticAdCanvas(parsed) {
   const nodes = parsed?.nodes;
@@ -62084,7 +62180,7 @@ function renderBudgetRefusal(slug) {
 
 // src/commands/canvas/slug-restore.ts
 import { existsSync as existsSync6 } from "fs";
-import path21 from "path";
+import path22 from "path";
 var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
 var SlugRestoreError = class extends Error {
   code;
@@ -62100,8 +62196,8 @@ async function canvasForSlug(slug, opts) {
   if (!SLUG_PATTERN.test(slug)) {
     throw new SlugRestoreError("invalid_slug", `"${slug}" is not a valid creative slug`);
   }
-  const targetDir = path21.join(opts.workspaceRoot, "src", "creatives", slug);
-  const local = path21.join(targetDir, `${slug}.canvas.json`);
+  const targetDir = path22.join(opts.workspaceRoot, "src", "creatives", slug);
+  const local = path22.join(targetDir, `${slug}.canvas.json`);
   if (!opts.forceRemote && existsSync6(local)) return { canvasPath: local };
   const client = opts.client();
   if (!client) {
@@ -62159,11 +62255,11 @@ async function fetchManifest(url) {
 }
 
 // src/commands/canvas/static-fix.ts
-import { readFile as readFile17 } from "fs/promises";
-import path22 from "path";
+import { readFile as readFile18 } from "fs/promises";
+import path23 from "path";
 async function previousAdImage(canvasRoot, runId, fetchRecord = fetchRunRecord, roles = {}) {
   try {
-    const manifest = JSON.parse(await readFile17(path22.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    const manifest = JSON.parse(await readFile18(path23.join(canvasRoot, runId, "manifest.json"), "utf8"));
     const byNode = Object.fromEntries(
       Object.entries(manifest.outputs_by_node ?? {}).map(([id, out]) => [id, { ...out, ...roles[id] ? { role: roles[id] } : {} }])
     );
@@ -62210,7 +62306,7 @@ function correctedUrl(byNode) {
 }
 async function correctedPicture(canvasRoot, runId, fetchRecord = fetchRunRecord) {
   try {
-    const manifest = JSON.parse(await readFile17(path22.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    const manifest = JSON.parse(await readFile18(path23.join(canvasRoot, runId, "manifest.json"), "utf8"));
     if (manifest.outputs_by_node) return correctedUrl(manifest.outputs_by_node);
   } catch {
   }
@@ -62235,7 +62331,7 @@ async function variantImage(canvasRoot, runId, sha2562, fetchRecord = fetchRunRe
   const sha = sha2562.trim().toLowerCase();
   if (!SHA_PREFIX.test(sha)) return null;
   try {
-    const manifest = JSON.parse(await readFile17(path22.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    const manifest = JSON.parse(await readFile18(path23.join(canvasRoot, runId, "manifest.json"), "utf8"));
     for (const [id, out] of Object.entries(manifest.outputs_by_node ?? {})) {
       if (roles[id] !== STATIC_VARIANTS_ROLE) continue;
       const url = matchVariant(out.images ?? [], sha);
@@ -62249,20 +62345,20 @@ async function variantImage(canvasRoot, runId, sha2562, fetchRecord = fetchRunRe
 }
 
 // src/commands/canvas/static-run-review.ts
-import { readFile as readFile20 } from "fs/promises";
+import { readFile as readFile21 } from "fs/promises";
 
 // src/commands/canvas/viewer-check.ts
 import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir8, readdir as readdir9, readFile as readFile19, stat as stat4, writeFile as writeFile12 } from "fs/promises";
-import path24 from "path";
+import { mkdir as mkdir8, readdir as readdir9, readFile as readFile20, stat as stat4, writeFile as writeFile12 } from "fs/promises";
+import path25 from "path";
 import { defineCommand as defineCommand131 } from "citty";
 import { parse as parseYaml2 } from "yaml";
 import { z as z21 } from "zod";
 
 // src/commands/canvas/unbilled-spend.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir7, readdir as readdir8, readFile as readFile18, rename, unlink, writeFile as writeFile11 } from "fs/promises";
-import path23 from "path";
+import { mkdir as mkdir7, readdir as readdir8, readFile as readFile19, rename, unlink, writeFile as writeFile11 } from "fs/promises";
+import path24 from "path";
 import { z as z20 } from "zod";
 var DIR = "unbilled-spend";
 var Held = z20.array(
@@ -62270,22 +62366,22 @@ var Held = z20.array(
 );
 async function holdUnbilledSpend(cacheDir, usage) {
   if (usage.length === 0) return;
-  const dir = path23.join(cacheDir, DIR);
+  const dir = path24.join(cacheDir, DIR);
   await mkdir7(dir, { recursive: true });
-  await writeFile11(path23.join(dir, `${Date.now()}-${randomUUID2()}.json`), JSON.stringify(usage), "utf8");
+  await writeFile11(path24.join(dir, `${Date.now()}-${randomUUID2()}.json`), JSON.stringify(usage), "utf8");
 }
 async function takeUnbilledSpend(cacheDir) {
-  const dir = path23.join(cacheDir, DIR);
+  const dir = path24.join(cacheDir, DIR);
   const files = await readdir8(dir).catch(() => []);
   const byModel = /* @__PURE__ */ new Map();
   for (const file of files.filter((f) => f.endsWith(".json"))) {
-    const claimed = path23.join(dir, `${file}.${randomUUID2()}.taken`);
+    const claimed = path24.join(dir, `${file}.${randomUUID2()}.taken`);
     try {
-      await rename(path23.join(dir, file), claimed);
+      await rename(path24.join(dir, file), claimed);
     } catch {
       continue;
     }
-    const parsed = Held.safeParse(await readFile18(claimed, "utf8").then(JSON.parse, () => null).catch(() => null));
+    const parsed = Held.safeParse(await readFile19(claimed, "utf8").then(JSON.parse, () => null).catch(() => null));
     await unlink(claimed).catch(() => {
     });
     for (const call of parsed.success ? parsed.data : []) {
@@ -62440,14 +62536,14 @@ function viewerCheckCacheKey(input, model) {
 }
 async function cachedAnswer(file) {
   try {
-    const parsed = ViewerAnswerSchema.safeParse(JSON.parse(await readFile19(file, "utf8")));
+    const parsed = ViewerAnswerSchema.safeParse(JSON.parse(await readFile20(file, "utf8")));
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
   }
 }
 async function checkViewer(input, opts) {
-  const file = path24.join(opts.cacheDir, "viewer-check", `${viewerCheckCacheKey(input, opts.model)}.json`);
+  const file = path25.join(opts.cacheDir, "viewer-check", `${viewerCheckCacheKey(input, opts.model)}.json`);
   let answer = await cachedAnswer(file);
   const cached = answer !== null;
   const prompt = buildViewerPrompt(input);
@@ -62457,7 +62553,7 @@ async function checkViewer(input, opts) {
   }
   if (answer === null) return { status: "unavailable", input };
   if (!cached) {
-    await mkdir8(path24.dirname(file), { recursive: true });
+    await mkdir8(path25.dirname(file), { recursive: true });
     await writeFile12(file, `${JSON.stringify(answer, null, 2)}
 `, "utf8");
   }
@@ -62583,8 +62679,8 @@ function frontmatterOf(raw) {
   }
 }
 async function readCreativeForViewerCheck(creativeDir) {
-  const spec = readAdSpec(JSON.parse(await readFile19(path24.join(creativeDir, "prompt.json"), "utf8")));
-  const definition = frontmatterOf(await readFile19(path24.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
+  const spec = readAdSpec(JSON.parse(await readFile20(path25.join(creativeDir, "prompt.json"), "utf8")));
+  const definition = frontmatterOf(await readFile20(path25.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
   const offer = spec.message?.trim() || definition.angle?.trim();
   const persona = spec.viewer?.who.trim() || definition.persona?.trim();
   const brand = spec.brand?.name?.trim();
@@ -62604,7 +62700,7 @@ async function readCreativeForViewerCheck(creativeDir) {
   };
 }
 async function readPersonas(workspaceRoot) {
-  const dir = path24.join(workspaceRoot, "src", "content", "personas");
+  const dir = path25.join(workspaceRoot, "src", "content", "personas");
   let files;
   try {
     files = (await readdir9(dir, { recursive: true })).filter((f) => f.endsWith(".md"));
@@ -62613,7 +62709,7 @@ async function readPersonas(workspaceRoot) {
   }
   return await Promise.all(
     files.map(async (file) => {
-      const raw = await readFile19(path24.join(dir, file), "utf8");
+      const raw = await readFile20(path25.join(dir, file), "utf8");
       const block2 = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1];
       let segment;
       try {
@@ -62623,7 +62719,7 @@ async function readPersonas(workspaceRoot) {
       }
       const title = raw.match(/^#\s+(.+)$/m)?.[1]?.trim();
       return {
-        slug: path24.basename(file, ".md"),
+        slug: path25.basename(file, ".md"),
         ...title ? { title } : {},
         ...typeof segment === "string" && segment.trim() ? { segment: segment.trim() } : {}
       };
@@ -62710,11 +62806,11 @@ var ARGS5 = {
 };
 registerSchema({ command: "canvas.viewer-check", description: DESCRIPTION2, args: ARGS5 });
 async function creativeDirOf(arg, workspaceRoot) {
-  const direct = path24.resolve(arg);
+  const direct = path25.resolve(arg);
   try {
-    return (await stat4(direct)).isDirectory() ? direct : path24.dirname(direct);
+    return (await stat4(direct)).isDirectory() ? direct : path25.dirname(direct);
   } catch {
-    return path24.join(workspaceRoot, "src", "creatives", arg);
+    return path25.join(workspaceRoot, "src", "creatives", arg);
   }
 }
 var viewerCheckCommand = defineCommand131({
@@ -62724,7 +62820,7 @@ var viewerCheckCommand = defineCommand131({
     const cwd = process.cwd();
     const workspaceRoot = findWorkspaceRoot(cwd) ?? cwd;
     const creativeDir = await creativeDirOf(String(args8.slug), workspaceRoot);
-    const slug = path24.basename(creativeDir);
+    const slug = path25.basename(creativeDir);
     let creative;
     try {
       creative = await readCreativeForViewerCheck(creativeDir);
@@ -62741,7 +62837,7 @@ var viewerCheckCommand = defineCommand131({
     }
     const resolved = await resolveViewer(creative.sources, liveViewerLookups(workspaceRoot));
     const input = { ...creative.ad, viewer: resolved.viewer };
-    const cacheDir = path24.join(workspaceRoot, "canvas", ".cache");
+    const cacheDir = path25.join(workspaceRoot, "canvas", ".cache");
     const spent = [];
     const outcome2 = await checkViewer(input, {
       cacheDir,
@@ -62870,7 +62966,7 @@ function shapeHint(shape, copy) {
 async function textOf(ref2) {
   const r = ref2;
   try {
-    if (typeof r?.path === "string") return await readFile20(r.path, "utf8");
+    if (typeof r?.path === "string") return await readFile21(r.path, "utf8");
     if (typeof r?.url === "string") {
       const res = await fetch(r.url);
       return res.ok ? await res.text() : null;
@@ -62922,7 +63018,7 @@ async function reviewStaticRun(opts) {
   let lines = [];
   let palette = [];
   try {
-    const spec = readAdSpec(JSON.parse(await readFile20(targets.promptPath, "utf8")));
+    const spec = readAdSpec(JSON.parse(await readFile21(targets.promptPath, "utf8")));
     copy = spec.copy.map((l) => l.text);
     lines = spec.copy.map((l) => ({ text: l.text, lettering: l.lettering }));
     palette = brandPalette(spec.brand);
@@ -63144,7 +63240,7 @@ function failPreflight3(code, message, fix) {
   process.exit(2);
 }
 async function canvasFileFor(opts) {
-  if (opts.file) return { canvasPath: path25.resolve(opts.file) };
+  if (opts.file) return { canvasPath: path26.resolve(opts.file) };
   if (!opts.slug) failPreflight3("missing_canvas", "Pass the canvas file, or --slug <slug> to run a creative by name.");
   const cwd = process.cwd();
   try {
@@ -63179,7 +63275,7 @@ async function executeCanvasRun(opts) {
   if (creativeSlug) await recordRenderAttempt(canvasRoot, creativeSlug, prepared.sourceSha);
   if (prepared.rewrites.length > 0) {
     process.stderr.write(
-      `[canvas] rewrote ${prepared.rewrites.length} asset reference(s) in the canvas file so it says what runs (absolute paths \u2192 canvas-relative, a URL in an ingest path \u2192 source "url"):
+      `[canvas] rewrote ${prepared.rewrites.length} asset reference(s) in the canvas file so it says what runs (absolute paths \u2192 canvas-relative, a URL in an ingest path \u2192 source "url", a path into canvas/ \u2192 the durable URL of the same bytes):
 ${describeRewrites(prepared.rewrites)}
 `
     );
@@ -63254,7 +63350,7 @@ ${describeRewrites(prepared.rewrites)}
 `);
     }
   }
-  const cacheDir = opts.cacheDir ?? path25.join(canvasRoot, ".cache");
+  const cacheDir = opts.cacheDir ?? path26.join(canvasRoot, ".cache");
   const engine = createEngineFromEnv({
     cacheDir,
     outputsDir: opts.outputsDir ?? canvasRoot,
@@ -63277,7 +63373,7 @@ ${describeRewrites(prepared.rewrites)}
   const canvasSha = sha256Hex(Buffer.from(canvasText));
   const sourceSha = prepared.sourceSha;
   const client = opts.record === false ? null : buildBackendClient();
-  const outputsDir = opts.outputsDir ? path25.resolve(opts.outputsDir) : canvasRoot;
+  const outputsDir = opts.outputsDir ? path26.resolve(opts.outputsDir) : canvasRoot;
   const { runId, resumed, source, sameSource, concurrentRunId, rendering } = await resolveRunId({
     explicitRunId: opts.runId,
     adoptedRunId: adoptRunId,
@@ -63307,11 +63403,11 @@ ${describeRewrites(prepared.rewrites)}
   }
   const viewerUsage = [];
   const viewerCheck = creativeSlug && isStaticAdCanvas(parsed) ? await viewerCheckBeforeRender({
-    creativeDir: path25.dirname(filePath),
+    creativeDir: path26.dirname(filePath),
     cacheDir,
     slug: creativeSlug,
     skip: opts.fix !== void 0 || opts.useVariant !== void 0 || relaidFrom !== void 0 ? "fix" : resumed && sameSource ? "resume" : opts.skipViewerCheck ? "asked" : null,
-    lookups: liveViewerLookups(path25.dirname(canvasRoot)),
+    lookups: liveViewerLookups(path26.dirname(canvasRoot)),
     model: VIEWER_CHECK_MODEL,
     ask: gatewayViewerModel(VIEWER_CHECK_MODEL, (usage) => viewerUsage.push(usage))
   }) : null;
@@ -63372,7 +63468,7 @@ ${describeRewrites(prepared.rewrites)}
   if (snapshot && creativeSlug) await recordSnapshot(canvasRoot, creativeSlug, snapshot);
   const recordMeta = {
     creativeSlug,
-    canvasPath: path25.relative(path25.dirname(canvasRoot), filePath) || void 0,
+    canvasPath: path26.relative(path26.dirname(canvasRoot), filePath) || void 0,
     canvasSha,
     // The fingerprint the dashboard compares against the current source to flag
     // "edited since last render": the same `computeSourceSha` the edit-sync posts,
@@ -63469,7 +63565,7 @@ ${describeRewrites(prepared.rewrites)}
     ] : [];
     const findings = staticReview ? staticReview.review : review;
     const ready = staticReview ? staticReview.verdict === "ready" || staticReview.verdict === "ready_with_notes" : review !== null && !review.some((f) => f.severity === "blocking");
-    const definitionStatus = ready && creativeSlug ? await advanceDefinitionStatus(path25.join(path25.dirname(filePath), "_definition.md"), "rendered") : null;
+    const definitionStatus = ready && creativeSlug ? await advanceDefinitionStatus(path26.join(path26.dirname(filePath), "_definition.md"), "rendered") : null;
     if (poster) {
       await flushBilled(
         poster,
@@ -63640,14 +63736,14 @@ var rerunCommand = defineCommand133({
 });
 
 // src/commands/canvas/scaffold-static-ad.ts
-import { mkdir as mkdir10, readFile as readFile24, writeFile as writeFile14 } from "fs/promises";
-import path31 from "path";
+import { mkdir as mkdir10, readFile as readFile25, writeFile as writeFile14 } from "fs/promises";
+import path32 from "path";
 import { defineCommand as defineCommand135 } from "citty";
 
 // src/commands/canvas/creative-limit.ts
 import { existsSync as existsSync7 } from "fs";
 import { mkdir as mkdir9, readdir as readdir10, writeFile as writeFile13 } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 var NEW_CREATIVES_PER_CHAT = 10;
 function claimNewCreative(made, slug) {
   if (made.includes(slug)) return { allowed: true, count: made.length };
@@ -63655,7 +63751,7 @@ function claimNewCreative(made, slug) {
   return { allowed: true, count: made.length + 1 };
 }
 function chatDir(canvasRoot, chatId) {
-  return path26.join(canvasRoot, ".creative-limit", (chatId ?? "no-chat").replace(/[^A-Za-z0-9_-]/g, "_"));
+  return path27.join(canvasRoot, ".creative-limit", (chatId ?? "no-chat").replace(/[^A-Za-z0-9_-]/g, "_"));
 }
 async function madeInChat(dir) {
   return readdir10(dir).catch(() => []);
@@ -63668,7 +63764,7 @@ async function claimNewCreativeInWorkspace(canvasRoot, slug, chatId, definitionP
   if (claim.allowed && !made.includes(slug)) {
     try {
       await mkdir9(dir, { recursive: true });
-      await writeFile13(path26.join(dir, slug), "", { flag: "wx" });
+      await writeFile13(path27.join(dir, slug), "", { flag: "wx" });
     } catch {
     }
   }
@@ -63689,7 +63785,7 @@ async function enforceNewCreativeLimit(slug, canvasPath) {
     canvasOutputsRoot(canvasPath),
     slug,
     optionalChatId() ?? null,
-    path26.join(path26.dirname(path26.resolve(canvasPath)), "_definition.md")
+    path27.join(path27.dirname(path27.resolve(canvasPath)), "_definition.md")
   );
   if (claim.allowed) return;
   process.stderr.write(`${JSON.stringify(creativeLimitRefusal(slug), null, 2)}
@@ -63698,8 +63794,8 @@ async function enforceNewCreativeLimit(slug, canvasPath) {
 }
 
 // src/engine/scaffold/static-brand.ts
-import { readdir as readdir11, readFile as readFile21 } from "fs/promises";
-import path27 from "path";
+import { readdir as readdir11, readFile as readFile22 } from "fs/promises";
+import path28 from "path";
 
 // src/engine/scaffold/static-fonts.ts
 import { marked } from "marked";
@@ -63829,16 +63925,16 @@ var REGULAR = /(regular|book|normal|roman|[^0-9]400)/i;
 function pickFace(files, want) {
   if (files.length === 0) return void 0;
   const pattern = want === "heavy" ? HEAVY : REGULAR;
-  return files.find((f) => pattern.test(path27.basename(f))) ?? files[0];
+  return files.find((f) => pattern.test(path28.basename(f))) ?? files[0];
 }
 function exists(file) {
-  return readFile21(file).then(
+  return readFile22(file).then(
     () => true,
     () => false
   );
 }
 async function fromTokens2(root) {
-  const raw = await readFile21(path27.join(root, BRAND_DIR, "tokens.json"), "utf8").catch(() => null);
+  const raw = await readFile22(path28.join(root, BRAND_DIR, "tokens.json"), "utf8").catch(() => null);
   if (!raw) return {};
   let json;
   try {
@@ -63853,7 +63949,7 @@ async function fromTokens2(root) {
     const out = [];
     for (const font of tokens.fonts.filter((f) => f.role === role)) {
       for (const file of font.files ?? []) {
-        const abs = path27.join(root, file);
+        const abs = path28.join(root, file);
         if (FONT_FILE.test(file) && await exists(abs)) out.push(abs);
       }
     }
@@ -63863,10 +63959,10 @@ async function fromTokens2(root) {
   const body = await filesFor("body");
   const logos = [];
   for (const logo of tokens.logos) {
-    if (await exists(path27.join(root, logo.path))) logos.push(logo.path);
+    if (await exists(path28.join(root, logo.path))) logos.push(logo.path);
   }
-  const mark = pickBrandMark(logos.map((l) => path27.basename(l)));
-  const markPath = mark ? logos.find((l) => path27.basename(l) === mark) : void 0;
+  const mark = pickBrandMark(logos.map((l) => path28.basename(l)));
+  const markPath = mark ? logos.find((l) => path28.basename(l) === mark) : void 0;
   return {
     headlineFont: pickFace(heading, "heavy") ?? pickFace(body, "heavy"),
     bodyFont: pickFace(body, "regular") ?? pickFace(heading, "regular"),
@@ -63878,29 +63974,29 @@ async function fromTokens2(root) {
         return hex ? [[role, hex]] : [];
       })
     ),
-    ...markPath ? { logo: path27.join(root, markPath) } : {}
+    ...markPath ? { logo: path28.join(root, markPath) } : {}
   };
 }
 async function realLogo(root, named) {
   let logo = named;
   if (!logo) {
-    const logosDir = path27.join(root, BRAND_DIR, "logos");
+    const logosDir = path28.join(root, BRAND_DIR, "logos");
     const mark = pickBrandMark(
       (await readdir11(logosDir).catch(() => [])).filter((f) => !f.startsWith("."))
     );
-    if (mark) logo = path27.join(logosDir, mark);
+    if (mark) logo = path28.join(logosDir, mark);
   }
   return logo && await markIsReal(logo, root) ? logo : void 0;
 }
 async function readStaticBrandKit(root = ".") {
   const tokens = await fromTokens2(root);
-  const fontsDir = path27.join(root, BRAND_DIR, "fonts");
-  const fontFiles = (await readdir11(fontsDir).catch(() => [])).filter((f) => FONT_FILE.test(f)).sort().map((f) => path27.join(fontsDir, f));
+  const fontsDir = path28.join(root, BRAND_DIR, "fonts");
+  const fontFiles = (await readdir11(fontsDir).catch(() => [])).filter((f) => FONT_FILE.test(f)).sort().map((f) => path28.join(fontsDir, f));
   const headlineFont = tokens.headlineFont ?? pickFace(fontFiles, "heavy");
   const bodyFont = tokens.bodyFont ?? pickFace(fontFiles, "regular") ?? headlineFont;
   let palette = tokens.palette ?? [];
   if (palette.length === 0) {
-    const doc = await readFile21(path27.join(root, BRAND_DIR, "BRAND.md"), "utf8").catch(() => null);
+    const doc = await readFile22(path28.join(root, BRAND_DIR, "BRAND.md"), "utf8").catch(() => null);
     palette = doc ? paletteFromBrandDoc(doc) : [];
   }
   const logo = await realLogo(root, tokens.logo);
@@ -63914,27 +64010,27 @@ async function readStaticBrandKit(root = ".") {
   };
 }
 async function readNamedTypefaces(root = ".") {
-  const read = (file) => readFile21(path27.join(root, BRAND_DIR, file), "utf8").catch(() => null);
+  const read = (file) => readFile22(path28.join(root, BRAND_DIR, file), "utf8").catch(() => null);
   return namedTypefaces({ tokensJson: await read("tokens.json"), brandMd: await read("BRAND.md") });
 }
 
 // src/commands/canvas/scaffold-common.ts
-import { access, readFile as readFile22 } from "fs/promises";
+import { access, readFile as readFile23 } from "fs/promises";
 
 // src/commands/canvas/composition-path.ts
 import { existsSync as existsSync8 } from "fs";
-import path28 from "path";
+import path29 from "path";
 function resolveShippedCanvasDir(name, startDir, exists3 = existsSync8, maxDepth = 8) {
-  const rel = path28.join("canvas", name);
+  const rel = path29.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
-    const candidate = path28.join(dir, rel);
-    if (exists3(path28.join(candidate, "meta.json"))) return candidate;
-    const parent = path28.dirname(dir);
+    const candidate = path29.join(dir, rel);
+    if (exists3(path29.join(candidate, "meta.json"))) return candidate;
+    const parent = path29.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path28.resolve(startDir, "../../../", rel);
+  return path29.resolve(startDir, "../../../", rel);
 }
 
 // src/commands/canvas/scaffold-common.ts
@@ -63951,7 +64047,7 @@ function resolveModel(kind, requested, fallback) {
 }
 async function loadAssetText(ref2, label) {
   const r = ref2;
-  if (typeof r?.path === "string") return readFile22(r.path, "utf8");
+  if (typeof r?.path === "string") return readFile23(r.path, "utf8");
   if (typeof r?.url === "string") {
     const res = await fetch(r.url);
     if (!res.ok) throw new Error(`failed to fetch ${label} (${res.status})`);
@@ -64069,16 +64165,16 @@ ${doc.toString()}---${raw.slice(match[0].length)}`;
 }
 
 // src/commands/canvas/scaffold-static-ad-paths.ts
-import path29 from "path";
+import path30 from "path";
 function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
   const file = rawFile.trim();
   const imageIsUrl = /^https?:\/\//i.test(file);
-  const imageSource = imageIsUrl ? file : path29.resolve(cwd, file);
-  const outPath = out ? path29.resolve(cwd, out) : slug ? path29.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path29.join(cwd, "static-ad.canvas.json") : path29.join(path29.dirname(imageSource), "static-ad.canvas.json");
-  const blueprintPath2 = path29.join(path29.dirname(outPath), "prompt.json");
-  const creativeDir = slug ? path29.dirname(outPath) : null;
-  const definitionPath = creativeDir ? path29.join(creativeDir, "_definition.md") : null;
-  const referencesDir = creativeDir ? path29.join(creativeDir, "references") : null;
+  const imageSource = imageIsUrl ? file : path30.resolve(cwd, file);
+  const outPath = out ? path30.resolve(cwd, out) : slug ? path30.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path30.join(cwd, "static-ad.canvas.json") : path30.join(path30.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath2 = path30.join(path30.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path30.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path30.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path30.join(creativeDir, "references") : null;
   return { imageIsUrl, imageSource, outPath, blueprintPath: blueprintPath2, creativeDir, definitionPath, referencesDir };
 }
 var SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
@@ -64088,8 +64184,8 @@ function isValidScaffoldSlug(slug) {
 }
 
 // src/commands/canvas/sync-definition.ts
-import { readdir as readdir12, readFile as readFile23, stat as stat5 } from "fs/promises";
-import path30 from "path";
+import { readdir as readdir12, readFile as readFile24, stat as stat5 } from "fs/promises";
+import path31 from "path";
 import { defineCommand as defineCommand134 } from "citty";
 
 // src/commands/canvas/definition-graph.ts
@@ -64146,7 +64242,7 @@ function buildDefinitionSyncPayload(input, graph, chatId) {
 }
 async function readDefinitionSourceFields(canvasPath) {
   try {
-    return parseDefinitionSourceFields(await readFile23(path30.join(path30.dirname(canvasPath), "_definition.md"), "utf8"));
+    return parseDefinitionSourceFields(await readFile24(path31.join(path31.dirname(canvasPath), "_definition.md"), "utf8"));
   } catch {
     return {};
   }
@@ -64169,15 +64265,15 @@ async function syncCreativeDefinitionBestEffort(input) {
   }
 }
 async function resolveCanvasPath(inputPath) {
-  const resolved = path30.resolve(inputPath);
+  const resolved = path31.resolve(inputPath);
   let dir = resolved;
   try {
     if ((await stat5(resolved)).isFile()) {
       if (resolved.endsWith(".canvas.json")) return resolved;
-      dir = path30.dirname(resolved);
+      dir = path31.dirname(resolved);
     }
   } catch {
-    dir = resolved.endsWith(".canvas.json") ? path30.dirname(resolved) : resolved;
+    dir = resolved.endsWith(".canvas.json") ? path31.dirname(resolved) : resolved;
   }
   let entries;
   try {
@@ -64188,7 +64284,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 ? path30.join(dir, chosen) : null;
+  return chosen ? path31.join(dir, chosen) : null;
 }
 var syncDefinitionCommand = defineCommand134({
   meta: {
@@ -64469,7 +64565,7 @@ function mergeReferenceIntoBlueprint(blueprint, reference) {
 
 // src/commands/canvas/scaffold-static-ad.ts
 function toCanvasRelative2(canvasDir, file) {
-  const rel = path31.relative(canvasDir, file).split(path31.sep).join("/");
+  const rel = path32.relative(canvasDir, file).split(path32.sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 async function uploadSourceAsReference(source, isUrl, client) {
@@ -64481,7 +64577,7 @@ async function uploadSourceAsReference(source, isUrl, client) {
       throw new Error(`failed to download source image (${e instanceof Error ? e.message : String(e)})`);
     }
   } else {
-    bytes = await readFile24(source);
+    bytes = await readFile25(source);
   }
   const safe = await toModelSafeImage(bytes);
   const sha2562 = sha256Hex(safe.bytes);
@@ -64829,10 +64925,10 @@ var scaffoldStaticAdCommand = defineCommand135({
     }
     const { imageIsUrl, imageSource, outPath, blueprintPath: blueprintPath2, definitionPath, referencesDir } = resolveScaffoldStaticAdPaths(sourceFile, args8.out ? String(args8.out) : void 0, process.cwd(), slug);
     if (slug) await enforceNewCreativeLimit(slug, outPath);
-    const existingDefinition = definitionPath && await fileExists(definitionPath) ? await readFile24(definitionPath, "utf8") : null;
+    const existingDefinition = definitionPath && await fileExists(definitionPath) ? await readFile25(definitionPath, "utf8") : null;
     const who = await scaffoldViewer(args8, existingDefinition, liveViewerLookups(process.cwd()).adSetViewer);
     if (!who.ok) return fail4("invalid_viewer", who.message);
-    await mkdir10(path31.dirname(outPath), { recursive: true });
+    await mkdir10(path32.dirname(outPath), { recursive: true });
     let models;
     try {
       models = resolveModels(args8);
@@ -64865,7 +64961,7 @@ var scaffoldStaticAdCommand = defineCommand135({
     const blueprint = mergeReferenceIntoBlueprint(vision.blueprint, reference);
     const elements = castAvatarsOnStaticElements(vision.elements, cast.avatars);
     const uncast = staticAvatarsNotCast(vision.elements, cast.handles);
-    const canvasDir = path31.dirname(outPath);
+    const canvasDir = path32.dirname(outPath);
     const workspaceRoot = await findBrandRoot(canvasDir) ?? process.cwd();
     const kit = await readStaticBrandKit(workspaceRoot);
     const brand = brandBlock(kit);
@@ -64914,7 +65010,7 @@ var scaffoldStaticAdCommand = defineCommand135({
     } catch (e) {
       return fail4("scaffold", e instanceof Error ? e.message : String(e));
     }
-    const validation = await validateScaffoldedStaticAd(canvas, path31.dirname(outPath));
+    const validation = await validateScaffoldedStaticAd(canvas, path32.dirname(outPath));
     if (validation.blocking.length > 0) {
       process.stderr.write(
         `${JSON.stringify({ ok: false, error: { code: "validation", issues: validation.blocking } }, null, 2)}
@@ -65010,7 +65106,7 @@ var scaffoldStaticAdCommand = defineCommand135({
             run_estimated_credits: validation.estimatedCredits
           },
           checklist: {
-            edit_prompt: `Edit ${path31.basename(blueprintPath2)}: it is the ad spec, read from your image, to rewrite into the ad you want. \`viewer\` (who sees it and what they already know), \`message\` (the one thing it tells them), \`copy\` (each line, \`in_scene\` or \`designed\`), \`scene\`, \`references\` (one picture each, by role), \`colors\` (each tied to an object, from the brand) and an optional \`direction\`. You never write a model prompt: every render prompt is compiled from this file and shown on its node.${reference ? " Its `reference` block is the library's read of the source ad (container, layout, mechanism, offer, text blocks): keep it as the account of why the ad won, and rebuild it for our brand." : ""}`,
+            edit_prompt: `Edit ${path32.basename(blueprintPath2)}: it is the ad spec, read from your image, to rewrite into the ad you want. \`viewer\` (who sees it and what they already know), \`message\` (the one thing it tells them), \`copy\` (each line, \`in_scene\` or \`designed\`), \`scene\`, \`references\` (one picture each, by role), \`colors\` (each tied to an object, from the brand) and an optional \`direction\`. You never write a model prompt: every render prompt is compiled from this file and shown on its node.${reference ? " Its `reference` block is the library's read of the source ad (container, layout, mechanism, offer, text blocks): keep it as the account of why the ad won, and rebuild it for our brand." : ""}`,
             mechanism: report.winning_mechanisms,
             rebuild_the_mechanism: "`mechanism` is WHY the source ad works. Rebuild each device for our brand in prompt.json's copy and scene (a rhyme stays a rhyme in our words, a before/after stays a before/after of our product); never copy the source's literal copy.",
             assets_to_supply: report.elements,
@@ -65072,8 +65168,8 @@ function clientLogoMissNote(decision, domain) {
 }
 
 // src/commands/canvas/scaffold-ad.ts
-import { copyFile, cp, mkdir as mkdir11, readFile as readFile26, stat as stat6, writeFile as writeFile16 } from "fs/promises";
-import path33 from "path";
+import { copyFile, cp, mkdir as mkdir11, readFile as readFile27, stat as stat6, writeFile as writeFile16 } from "fs/promises";
+import path34 from "path";
 import { defineCommand as defineCommand136 } from "citty";
 
 // src/engine/scaffold/ad-spec.ts
@@ -65787,8 +65883,8 @@ function injectAdBrandOverlay(indexHtml, overlayHtml, style = {}) {
 }
 
 // src/commands/canvas/composition-dims.ts
-import { readFile as readFile25, writeFile as writeFile15 } from "fs/promises";
-import path32 from "path";
+import { readFile as readFile26, writeFile as writeFile15 } from "fs/promises";
+import path33 from "path";
 function patchCompositionMeta(metaJson, dims) {
   try {
     const meta = JSON.parse(metaJson);
@@ -65803,11 +65899,11 @@ 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 = path32.join(compositionDir, "meta.json");
-  const rawMeta = await readFile25(metaPath, "utf8");
+  const metaPath = path33.join(compositionDir, "meta.json");
+  const rawMeta = await readFile26(metaPath, "utf8");
   await writeFile15(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
-  const htmlPath = path32.join(compositionDir, "index.html");
-  const rawHtml = await readFile25(htmlPath, "utf8");
+  const htmlPath = path33.join(compositionDir, "index.html");
+  const rawHtml = await readFile26(htmlPath, "utf8");
   await writeFile15(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
 }
 
@@ -65890,7 +65986,7 @@ var scaffoldAdCommand = defineCommand136({
     const specPath = args8.spec;
     let parsed;
     try {
-      parsed = JSON.parse(await readFile26(specPath, "utf-8"));
+      parsed = JSON.parse(await readFile27(specPath, "utf-8"));
     } catch (e) {
       writeJson({
         ok: false,
@@ -66051,7 +66147,7 @@ var scaffoldAdCommand = defineCommand136({
     ] : [];
     const markPath = spec.data.brand?.logo?.trim();
     if (!noBrand && markPath?.toLowerCase().endsWith(".svg")) {
-      const svg = await readFile26(markPath, "utf-8").catch(() => null);
+      const svg = await readFile27(markPath, "utf-8").catch(() => null);
       if (svg === null) {
         writeJson({
           ok: false,
@@ -66103,8 +66199,8 @@ var scaffoldAdCommand = defineCommand136({
       videoModel: chosenVideoModel,
       ...avatarVoice ? { avatarVoice } : {}
     });
-    const slug = args8.slug ?? path33.basename(specPath).replace(/\.[^.]+$/, "");
-    const outPath = args8.out ?? (args8.slug ? path33.join("src/creatives", slug, `${slug}.canvas.json`) : path33.join(path33.dirname(specPath), `${slug}.canvas.json`));
+    const slug = args8.slug ?? path34.basename(specPath).replace(/\.[^.]+$/, "");
+    const outPath = args8.out ?? (args8.slug ? path34.join("src/creatives", slug, `${slug}.canvas.json`) : path34.join(path34.dirname(specPath), `${slug}.canvas.json`));
     if (args8.slug) await enforceNewCreativeLimit(slug, outPath);
     let outAr;
     try {
@@ -66122,28 +66218,28 @@ var scaffoldAdCommand = defineCommand136({
       return;
     }
     const outDims = canvasDims(outAr);
-    const outDir = path33.dirname(outPath);
+    const outDir = path34.dirname(outPath);
     await mkdir11(outDir, { recursive: true });
-    const compositionDest = path33.join(outDir, "video-overlay-composition");
-    const captionsDest = path33.join(outDir, "tiktok-captions-composition");
+    const compositionDest = path34.join(outDir, "video-overlay-composition");
+    const captionsDest = path34.join(outDir, "tiktok-captions-composition");
     await cp(SHIPPED_OVERLAY_COMPOSITION_DIR, compositionDest, { recursive: true });
     await cp(SHIPPED_CAPTIONS_DIR, captionsDest, { recursive: true });
     await stampCompositionDims(compositionDest, outDims);
     await stampCompositionDims(captionsDest, outDims);
-    const captionsIndex = path33.join(captionsDest, "index.html");
-    await writeFile16(captionsIndex, injectAdCaptionPlacement(await readFile26(captionsIndex, "utf-8"), outAr), "utf-8");
+    const captionsIndex = path34.join(captionsDest, "index.html");
+    await writeFile16(captionsIndex, injectAdCaptionPlacement(await readFile27(captionsIndex, "utf-8"), outAr), "utf-8");
     const face = await stageBrandDisplayFace(outDir, captionsDest);
     if (face) {
-      await writeFile16(captionsIndex, injectAdDisplayFace(await readFile26(captionsIndex, "utf-8"), face.file), "utf-8");
+      await writeFile16(captionsIndex, injectAdDisplayFace(await readFile27(captionsIndex, "utf-8"), face.file), "utf-8");
     }
-    const blueprintPath2 = path33.join(outDir, "prompt.json");
-    const blueprintStylePath = path33.join(outDir, "prompt.style.json");
+    const blueprintPath2 = path34.join(outDir, "prompt.json");
+    const blueprintStylePath = path34.join(outDir, "prompt.style.json");
     await writeSceneFiles(outDir, blueprint);
     await writeFile16(blueprintStylePath, renderStyleProjectionFromValue(blueprint), "utf8");
-    await writeFile16(path33.join(outDir, AD_SPEC_FILE), `${JSON.stringify(specArtifact, null, 2)}
+    await writeFile16(path34.join(outDir, AD_SPEC_FILE), `${JSON.stringify(specArtifact, null, 2)}
 `, "utf8");
     const logoPath = noBrand ? void 0 : spec.data.brand?.logo?.trim();
-    const transcriptPath = path33.join(outDir, "transcript.json");
+    const transcriptPath = path34.join(outDir, "transcript.json");
     if (spec.data.voiceover === false) {
       await writeFile16(transcriptPath, `${JSON.stringify(staticTranscript(spec.data, chosenVideoModel), null, 2)}
 `, "utf-8");
@@ -66155,10 +66251,10 @@ var scaffoldAdCommand = defineCommand136({
       // that stops the whole canvas. The same sheet model every other scaffold uses.
       sheetModel: ACTOR_SHEET_MODEL,
       videoModel: chosenVideoModel,
-      overlayCompositionPath: path33.relative(outDir, compositionDest),
-      captionsCompositionPath: path33.relative(outDir, captionsDest),
-      blueprintPath: path33.relative(outDir, blueprintPath2),
-      blueprintStylePath: path33.relative(outDir, blueprintStylePath),
+      overlayCompositionPath: path34.relative(outDir, compositionDest),
+      captionsCompositionPath: path34.relative(outDir, captionsDest),
+      blueprintPath: path34.relative(outDir, blueprintPath2),
+      blueprintStylePath: path34.relative(outDir, blueprintStylePath),
       aspect: spec.data.format.aspect_ratio,
       resolution: spec.data.format.resolution,
       // A beat is one clause and one card, so the cap has to clear a whole clause.
@@ -66197,17 +66293,17 @@ var scaffoldAdCommand = defineCommand136({
       // the stock voice this exists to avoid. It is to convert the LATER extracts onto the
       // first beat of the same speaker, which keeps a voice the clip really produced.
       ...avatar ? { keepRenderedVoice: true } : {},
-      ...spec.data.voiceover === false ? { staticTranscriptPath: path33.relative(outDir, transcriptPath) } : {}
+      ...spec.data.voiceover === false ? { staticTranscriptPath: path34.relative(outDir, transcriptPath) } : {}
     };
     const canvas = scaffoldVideoCanvas(blueprint, adSpecCastElements(spec.data, avatar), opts);
     const renderNode5 = canvas.nodes.find((n) => n.type === "hyperframe_render");
-    const renderedDir = renderNode5 ? path33.join(outDir, String(renderNode5.params?.composition ?? "")) : null;
+    const renderedDir = renderNode5 ? path34.join(outDir, String(renderNode5.params?.composition ?? "")) : null;
     let staged = null;
     let markIsLight = false;
     if (logoPath && renderedDir) {
-      const ext = path33.extname(logoPath) || ".png";
+      const ext = path34.extname(logoPath) || ".png";
       try {
-        await copyFile(logoPath, path33.join(renderedDir, `brand-mark${ext}`));
+        await copyFile(logoPath, path34.join(renderedDir, `brand-mark${ext}`));
         staged = { file: `brand-mark${ext}`, alt: spec.data.brand?.name ?? "brand" };
         markIsLight = await markInkIsLight(logoPath);
       } catch {
@@ -66226,12 +66322,12 @@ var scaffoldAdCommand = defineCommand136({
       plateIsDark: plateIsDark(spec.data.brand?.palette)
     }) : "";
     if (overlayHtml && renderedDir) {
-      const indexPath = path33.join(renderedDir, "index.html");
-      const html = await readFile26(indexPath, "utf-8");
+      const indexPath = path34.join(renderedDir, "index.html");
+      const html = await readFile27(indexPath, "utf-8");
       await writeFile16(indexPath, injectAdBrandOverlay(html, overlayHtml, { aspect: outAr, ...face ? { face: AD_DISPLAY_FAMILY } : {} }), "utf-8");
     }
     await writeFile16(
-      path33.join(outDir, REBUILD_FILE),
+      path34.join(outDir, REBUILD_FILE),
       `${JSON.stringify({ elements: adSpecCastElements(spec.data, avatar), opts }, null, 2)}
 `,
       "utf8"
@@ -66261,7 +66357,7 @@ var scaffoldAdCommand = defineCommand136({
       return;
     }
     if (args8.slug) {
-      const definitionPath = path33.join(outDir, "_definition.md");
+      const definitionPath = path34.join(outDir, "_definition.md");
       const definitionExists = await stat6(definitionPath).then(() => true, () => false);
       if (!definitionExists) {
         await writeFile16(
@@ -66379,9 +66475,9 @@ async function fetchClientLogo() {
     if (!response.ok) return { ok: false, reason: clientLogoMissNote({ use: false, reason: "no_hits" }, domain) };
     const bytes = Buffer.from(await response.arrayBuffer());
     const extension = /\.(svg|png|jpg|jpeg|webp)(?:\?|$)/i.exec(decision.url)?.[1]?.toLowerCase() ?? "svg";
-    const dir = path33.join(BRAND_DIR, "logos");
+    const dir = path34.join(BRAND_DIR, "logos");
     await mkdir11(dir, { recursive: true });
-    const file = path33.join(dir, `brand-mark.${extension}`);
+    const file = path34.join(dir, `brand-mark.${extension}`);
     await writeFile16(file, bytes);
     return { ok: true, path: file };
   } catch {
@@ -66400,14 +66496,14 @@ async function stageBrandDisplayFace(outDir, compositionDir) {
   if (!face) return null;
   try {
     if ("path" in face.slot) {
-      const file2 = `brand-face${path33.extname(face.slot.path).toLowerCase()}`;
-      await copyFile(face.slot.path, path33.join(compositionDir, file2));
-      return { file: file2, label: `the font file \`${path33.relative(root, face.slot.path)}\`` };
+      const file2 = `brand-face${path34.extname(face.slot.path).toLowerCase()}`;
+      await copyFile(face.slot.path, path34.join(compositionDir, file2));
+      return { file: file2, label: `the font file \`${path34.relative(root, face.slot.path)}\`` };
     }
     const { buffer } = await fetchExternalBytes(face.slot.url, { maxBytes: MAX_FONT_BYTES });
     const extension = /\.(woff2|woff|ttf|otf)(?:\?|$)/i.exec(face.slot.url)?.[1]?.toLowerCase() ?? "woff2";
     const file = `brand-face.${extension}`;
-    await writeFile16(path33.join(compositionDir, file), buffer);
+    await writeFile16(path34.join(compositionDir, file), buffer);
     return { file, label: `${face.family ?? "the brand's typeface"}, loaded as a web font` };
   } catch {
     return null;
@@ -66415,9 +66511,9 @@ async function stageBrandDisplayFace(outDir, compositionDir) {
 }
 
 // src/commands/canvas/scaffold-video.ts
-import { cp as cp2, mkdir as mkdir12, readFile as readFile29, rm as rm7, writeFile as writeFile17 } from "fs/promises";
+import { cp as cp2, mkdir as mkdir12, readFile as readFile30, rm as rm7, writeFile as writeFile17 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path35 from "path";
+import path36 from "path";
 import { defineCommand as defineCommand137 } from "citty";
 
 // src/engine/scaffold/lib/model-router.ts
@@ -66457,7 +66553,7 @@ function routeVideoModel(input) {
 
 // src/engine/nodes/local/lib/sceneDetect.ts
 import { execFile as execFile2 } from "child_process";
-import { mkdtemp, readdir as readdir13, readFile as readFile27, rm as rm6 } from "fs/promises";
+import { mkdtemp, readdir as readdir13, readFile as readFile28, rm as rm6 } from "fs/promises";
 import { tmpdir } from "os";
 import { join as join3 } from "path";
 import { promisify as promisify2 } from "util";
@@ -66533,7 +66629,7 @@ async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs)
     );
     const csvName = (await readdir13(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
     if (!csvName) return [];
-    return parsePySceneDetectCsvCuts(await readFile27(join3(outDir, csvName), "utf-8"));
+    return parsePySceneDetectCsvCuts(await readFile28(join3(outDir, csvName), "utf-8"));
   } finally {
     await rm6(outDir, { recursive: true, force: true });
   }
@@ -66557,8 +66653,8 @@ async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
 }
 
 // src/commands/canvas/gitignore.ts
-import { appendFile, readFile as readFile28 } from "fs/promises";
-import path34 from "path";
+import { appendFile, readFile as readFile29 } from "fs/promises";
+import path35 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("#"))
@@ -66566,10 +66662,10 @@ function missingGitignoreEntries(existing, entries) {
   return entries.filter((e) => !present2.has(e.trim().replace(/\/+$/, "")));
 }
 async function ensureGitignore(dir, entries) {
-  const file = path34.join(dir, ".gitignore");
+  const file = path35.join(dir, ".gitignore");
   let existing;
   try {
-    existing = await readFile28(file, "utf8");
+    existing = await readFile29(file, "utf8");
   } catch {
     return;
   }
@@ -66611,7 +66707,7 @@ async function loadTranscriptBestEffort(ref2) {
 async function stageCaptions(outDir, transcript) {
   const text3 = transcript?.trim();
   if (!text3 || text3 === "[]") return {};
-  const compositionPath = path35.join(outDir, "tiktok-captions-composition");
+  const compositionPath = path36.join(outDir, "tiktok-captions-composition");
   await cp2(SHIPPED_CAPTIONS_DIR, compositionPath, { recursive: true });
   return { compositionPath };
 }
@@ -66647,7 +66743,7 @@ var VIDEO_EXT_BY_MIME = {
   "video/x-matroska": ".mkv"
 };
 function referenceVideoExt(url, contentType) {
-  const fromPath = path35.extname(new URL(url).pathname).toLowerCase();
+  const fromPath = path36.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";
@@ -66673,7 +66769,7 @@ function framesModeReport(canvas, requested) {
   return { frames_mode: mode, ...refused ? { frames_reuse_refused: refused } : {} };
 }
 async function materializeReferenceVideo(fileArg2) {
-  if (!/^https?:\/\//i.test(fileArg2)) return path35.resolve(fileArg2);
+  if (!/^https?:\/\//i.test(fileArg2)) return path36.resolve(fileArg2);
   let bytes;
   let contentType;
   try {
@@ -66685,7 +66781,7 @@ 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 = path35.join(
+  const dest = path36.join(
     tmpdir2(),
     `baker-ref-${sha256Hex(bytes).slice(0, 16)}${referenceVideoExt(fileArg2, contentType)}`
   );
@@ -66912,12 +67008,12 @@ var scaffoldVideoCommand = defineCommand137({
     } catch (e) {
       return fail4("download", e instanceof Error ? e.message : String(e));
     }
-    const base = path35.basename(videoPath, path35.extname(videoPath));
-    const outPath = args8.out ? path35.resolve(String(args8.out)) : slug ? path35.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path35.join(path35.dirname(videoPath), `${base}.video.canvas.json`);
+    const base = path36.basename(videoPath, path36.extname(videoPath));
+    const outPath = args8.out ? path36.resolve(String(args8.out)) : slug ? path36.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path36.join(path36.dirname(videoPath), `${base}.video.canvas.json`);
     if (slug) await enforceNewCreativeLimit(slug, outPath);
-    const outDir = path35.dirname(outPath);
-    const blueprintPath2 = path35.join(outDir, "prompt.json");
-    const blueprintStylePath = path35.join(outDir, "prompt.style.json");
+    const outDir = path36.dirname(outPath);
+    const blueprintPath2 = path36.join(outDir, "prompt.json");
+    const blueprintStylePath = path36.join(outDir, "prompt.style.json");
     const frames = args8.frames === "reuse" ? "reuse" : "generate";
     const maxScenes = args8["max-scenes"] ? Number(args8["max-scenes"]) : void 0;
     if (Number.isFinite(maxScenes)) {
@@ -66986,12 +67082,12 @@ var scaffoldVideoCommand = defineCommand137({
 `
       );
     }
-    const compositionDest = path35.join(outDir, "video-overlay-composition");
+    const compositionDest = path36.join(outDir, "video-overlay-composition");
     await cp2(SHIPPED_OVERLAY_COMPOSITION_DIR, compositionDest, { recursive: true });
     await stampCompositionDims(compositionDest, outDims);
-    const indexPath = path35.join(compositionDest, "index.html");
+    const indexPath = path36.join(compositionDest, "index.html");
     const overlayHtml = buildOverlayHtml(blueprint, { captionsActive: Boolean(transcript), videoModel });
-    const indexHtml = await readFile29(indexPath, "utf8");
+    const indexHtml = await readFile30(indexPath, "utf8");
     const injected = indexHtml.replace("<!--OVERLAYS-->", () => overlayHtml);
     if (injected === indexHtml && overlayHtml.trim()) {
       fail4(
@@ -67005,10 +67101,10 @@ var scaffoldVideoCommand = defineCommand137({
     const opts = {
       imageModel,
       videoModel,
-      overlayCompositionPath: path35.relative(outDir, compositionDest),
-      captionsCompositionPath: captions.compositionPath ? path35.relative(outDir, captions.compositionPath) : void 0,
-      blueprintPath: path35.relative(outDir, blueprintPath2),
-      blueprintStylePath: path35.relative(outDir, blueprintStylePath),
+      overlayCompositionPath: path36.relative(outDir, compositionDest),
+      captionsCompositionPath: captions.compositionPath ? path36.relative(outDir, captions.compositionPath) : void 0,
+      blueprintPath: path36.relative(outDir, blueprintPath2),
+      blueprintStylePath: path36.relative(outDir, blueprintStylePath),
       frames,
       ambient: Boolean(args8.ambient),
       seamDedup: resolveSeamDedup(args8["seam-dedup"]),
@@ -67036,7 +67132,7 @@ var scaffoldVideoCommand = defineCommand137({
     await writeFile17(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
     await writeFile17(
-      path35.join(outDir, REBUILD_FILE),
+      path36.join(outDir, REBUILD_FILE),
       `${JSON.stringify({ elements, opts }, null, 2)}
 `,
       "utf8"
@@ -67063,7 +67159,7 @@ var scaffoldVideoCommand = defineCommand137({
     await ensureGitignore(process.cwd(), ["canvas/", ".context/"]);
     const sourceRef = videoSourceReference(blueprint, fileArg2);
     if (slug) {
-      const definitionPath = path35.join(outDir, "_definition.md");
+      const definitionPath = path36.join(outDir, "_definition.md");
       if (!await fileExists(definitionPath)) {
         await writeFile17(
           definitionPath,
@@ -67119,7 +67215,7 @@ var scaffoldVideoCommand = defineCommand137({
             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 \`${path35.basename(blueprintPath2)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path35.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 ${path35.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 \`${path36.basename(blueprintPath2)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path36.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 ${path36.basename(blueprintStylePath)}; both are regenerated.`,
             recurring_elements_to_supply: report.elements,
             voices_to_confirm: report.dialogue.map((d) => ({
               scene: d.scene,
@@ -67156,8 +67252,8 @@ var scaffoldVideoCommand = defineCommand137({
 });
 
 // src/commands/canvas/set-prompt.ts
-import { readFile as readFile30, writeFile as writeFile18 } from "fs/promises";
-import path36 from "path";
+import { readFile as readFile31, writeFile as writeFile18 } from "fs/promises";
+import path37 from "path";
 import { defineCommand as defineCommand138 } from "citty";
 function setNodePrompt(canvas, nodeId, text3) {
   const nodes = canvas?.nodes;
@@ -67186,8 +67282,8 @@ var SetPromptError = class extends Error {
   }
 };
 async function setPromptInCanvasFile(canvasPath, nodeId, text3) {
-  const filePath = path36.resolve(canvasPath);
-  const original = await readFile30(filePath, "utf8");
+  const filePath = path37.resolve(canvasPath);
+  const original = await readFile31(filePath, "utf8");
   let canvas;
   try {
     canvas = JSON.parse(original);
@@ -67209,7 +67305,7 @@ async function setPromptInCanvasFile(canvasPath, nodeId, text3) {
       "projected_prompt",
       `The prompt of "${nodeId}" is compiled from prompt.json on every validate and run, so setting it in the canvas would be overwritten.`,
       {
-        fix: `Edit the ad in ${path36.join(path36.dirname(filePath), "prompt.json")} (its scene, copy, references or direction), then run \`baker canvas validate\` to see the compiled prompt on the node.`
+        fix: `Edit the ad in ${path37.join(path37.dirname(filePath), "prompt.json")} (its scene, copy, references or direction), then run \`baker canvas validate\` to see the compiled prompt on the node.`
       }
     );
   }
@@ -67263,7 +67359,7 @@ var setPromptCommand = defineCommand138({
   },
   async run({ args: args8 }) {
     let text3;
-    if (args8["text-file"]) text3 = await readFile30(path36.resolve(String(args8["text-file"])), "utf8");
+    if (args8["text-file"]) text3 = await readFile31(path37.resolve(String(args8["text-file"])), "utf8");
     else if (args8.text !== void 0) text3 = String(args8.text);
     else {
       process.stderr.write(
@@ -67320,7 +67416,7 @@ var staleCommand = defineCommand139({
 });
 
 // src/commands/canvas/validate.ts
-import path37 from "path";
+import path38 from "path";
 import { defineCommand as defineCommand140 } from "citty";
 var validateCommand = defineCommand140({
   meta: {
@@ -67329,7 +67425,7 @@ var validateCommand = defineCommand140({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args: args8 }) {
-    const filePath = path37.resolve(String(args8.file));
+    const filePath = path38.resolve(String(args8.file));
     let prepared;
     try {
       prepared = await prepareCanvas(filePath, { log: (line) => process.stderr.write(`${line}
@@ -67893,7 +67989,7 @@ var feedbackCommand = defineCommand145({
 
 // src/commands/creatives/performance.ts
 import { readFileSync as readFileSync16 } from "fs";
-import path38 from "path";
+import path39 from "path";
 import { defineCommand as defineCommand146 } from "citty";
 import { parse as parseYaml3 } from "yaml";
 var DESCRIPTION5 = `How each Baker creative is doing in the live Meta ads that show it: spend, impressions, CTR, CPC, results, cost per result, frequency and a fatigue verdict, next to the angle, hook, mechanism and dominant slot its definition set out to test. Video creatives add hookRate (percent of impressions that watched 3 seconds) and holdRate (percent of those that reached a ThruPlay). Use it before briefing new creatives, to learn which angle and mechanism to make next and which creatives to replace.
@@ -67946,7 +68042,7 @@ function definitionInsights(markdown) {
 }
 function readLocalDefinition(slug) {
   try {
-    return readFileSync16(path38.join(process.cwd(), "src", "creatives", slug, "_definition.md"), "utf8");
+    return readFileSync16(path39.join(process.cwd(), "src", "creatives", slug, "_definition.md"), "utf8");
   } catch {
     return null;
   }
@@ -68022,7 +68118,7 @@ import { Buffer as Buffer2 } from "buffer";
 import { defineCommand as defineCommand147 } from "citty";
 
 // src/commands/images/api.ts
-import { readFile as readFile31 } from "fs/promises";
+import { readFile as readFile32 } from "fs/promises";
 import { basename, extname } from "path";
 var imageProcessingTimeoutMs = 18e4;
 var imageReadyPollIntervalMs = 2e3;
@@ -68036,7 +68132,7 @@ var mimeMap = {
   ".avif": "image/avif"
 };
 var defaultImageApiDeps = {
-  readFile: readFile31,
+  readFile: readFile32,
   post: apiPost,
   get: apiGet,
   sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms))
@@ -68102,7 +68198,7 @@ async function waitForReadyImage(deps, imageId, opts = {}) {
 }
 
 // src/commands/videos/api.ts
-import { readFile as readFile32 } from "fs/promises";
+import { readFile as readFile33 } from "fs/promises";
 import { basename as basename2, extname as extname2 } from "path";
 var videoProcessingTimeoutMs = 18e4;
 var videoReadyPollIntervalMs = 3e3;
@@ -68114,7 +68210,7 @@ var mimeMap2 = {
   ".mkv": "video/x-matroska"
 };
 var defaultVideoApiDeps = {
-  readFile: readFile32,
+  readFile: readFile33,
   post: apiPost,
   get: apiGet,
   sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms)),
@@ -69709,12 +69805,12 @@ Full guide: ${DOC}`
 import { defineCommand as defineCommand151 } from "citty";
 
 // src/commands/experiment/composition.ts
-import { readdir as readdir15, readFile as readFile34 } from "fs/promises";
-import path40 from "path";
+import { readdir as readdir15, readFile as readFile35 } from "fs/promises";
+import path41 from "path";
 
 // src/commands/landing/import-graph.ts
-import { readdir as readdir14, readFile as readFile33, stat as stat7 } from "fs/promises";
-import path39 from "path";
+import { readdir as readdir14, readFile as readFile34, stat as stat7 } from "fs/promises";
+import path40 from "path";
 var SOURCE_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte)$/;
 var RESOLVE_CANDIDATES = [
   "",
@@ -69747,7 +69843,7 @@ async function walkFiles(dir) {
   }
   const out = [];
   for (const entry of entries) {
-    const full = path39.join(dir, entry.name);
+    const full = path40.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === "dist") continue;
       out.push(...await walkFiles(full));
@@ -69761,8 +69857,8 @@ async function resolveSpecifier(specifier, fromFile, root) {
   const bare = specifier.split("?")[0] ?? "";
   if (bare.includes("*")) return null;
   let base;
-  if (bare.startsWith("/")) base = path39.join(root, bare.slice(1));
-  else if (bare.startsWith(".")) base = path39.resolve(path39.dirname(fromFile), bare);
+  if (bare.startsWith("/")) base = path40.join(root, bare.slice(1));
+  else if (bare.startsWith(".")) base = path40.resolve(path40.dirname(fromFile), bare);
   else return null;
   for (const suffix of RESOLVE_CANDIDATES) {
     const candidate = base + suffix;
@@ -69784,13 +69880,13 @@ async function importedFiles(text3, file, root) {
 }
 async function landingGraphFiles(root, slug) {
   const seen = /* @__PURE__ */ new Set();
-  const queue = await walkFiles(path39.join(root, "src/pages", slug));
+  const queue = await walkFiles(path40.join(root, "src/pages", slug));
   while (queue.length > 0) {
     const file = queue.pop();
     if (file === void 0 || seen.has(file)) continue;
     let text3;
     try {
-      text3 = await readFile33(file, "utf8");
+      text3 = await readFile34(file, "utf8");
     } catch {
       continue;
     }
@@ -69799,7 +69895,7 @@ async function landingGraphFiles(root, slug) {
       if (!seen.has(target)) queue.push(target);
     }
   }
-  return new Set([...seen].map((abs) => path39.relative(root, abs).split(path39.sep).join("/")));
+  return new Set([...seen].map((abs) => path40.relative(root, abs).split(path40.sep).join("/")));
 }
 
 // src/commands/experiment/composition.ts
@@ -69844,7 +69940,7 @@ function formsOnlyIn(these, those) {
 }
 async function knownFlows(root) {
   try {
-    const entries = await readdir15(path40.join(root, "src/lib/flow-engine/flows"), { withFileTypes: true });
+    const entries = await readdir15(path41.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();
@@ -69855,7 +69951,7 @@ async function readForms(root, slug) {
     const [files, flows] = await Promise.all([landingGraphFiles(root, slug), knownFlows(root)]);
     if (flows.size === 0) return [];
     const texts = await Promise.all(
-      [...files].filter((file) => /\.(astro|ts|tsx|js|mjs)$/.test(file)).map((file) => readFile34(path40.join(root, file), "utf8"))
+      [...files].filter((file) => /\.(astro|ts|tsx|js|mjs)$/.test(file)).map((file) => readFile35(path41.join(root, file), "utf8"))
     );
     return formsReferenced(texts, flows);
   } catch {
@@ -69865,8 +69961,8 @@ async function readForms(root, slug) {
 
 // src/commands/experiment/fold.ts
 import { statSync } from "fs";
-import { cp as cp3, mkdir as mkdir13, readdir as readdir16, readFile as readFile35, rm as rm8, stat as stat8, writeFile as writeFile19 } from "fs/promises";
-import path42 from "path";
+import { cp as cp3, mkdir as mkdir13, readdir as readdir16, readFile as readFile36, rm as rm8, stat as stat8, writeFile as writeFile19 } from "fs/promises";
+import path43 from "path";
 
 // ../api/src/experiments/variants.ts
 var VARIANT_SEPARATOR = "--";
@@ -69891,21 +69987,21 @@ function nextVariantNumber(page, existingSlugs, archived) {
 }
 
 // src/commands/landing/repoint.ts
-import path41 from "path";
+import path42 from "path";
 var QUOTED_RELATIVE = /(['"])(\.\.?\/[^'"]*)\1/g;
 function isInside3(abs, dir) {
-  return abs === dir || abs.startsWith(dir + path41.sep);
+  return abs === dir || abs.startsWith(dir + path42.sep);
 }
 function toSpecifier(from, to) {
-  const rel = path41.relative(from, to).split(path41.sep).join("/");
+  const rel = path42.relative(from, to).split(path42.sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 function repointSpecifier(spec, opts) {
   if (!spec.startsWith(".")) return spec;
-  const abs = path41.resolve(opts.fromDir, spec);
+  const abs = path42.resolve(opts.fromDir, spec);
   if (opts.forkedTargets?.has(abs)) {
-    const withinControl = path41.relative(opts.controlDir, abs);
-    return toSpecifier(opts.toDir, path41.resolve(opts.variantDir, withinControl));
+    const withinControl = path42.relative(opts.controlDir, abs);
+    return toSpecifier(opts.toDir, path42.resolve(opts.variantDir, withinControl));
   }
   if (!isInside3(abs, opts.controlDir)) return spec;
   return toSpecifier(opts.toDir, abs);
@@ -69917,9 +70013,9 @@ function repointFile(text3, opts) {
 }
 function repointMoved(text3, opts) {
   return text3.replace(QUOTED_RELATIVE, (_match, quote, spec) => {
-    const abs = path41.resolve(opts.fromDir, spec);
-    const within = path41.relative(opts.movedFrom, abs);
-    const target = within.startsWith("..") || path41.isAbsolute(within) ? abs : path41.resolve(opts.movedTo, within);
+    const abs = path42.resolve(opts.fromDir, spec);
+    const within = path42.relative(opts.movedFrom, abs);
+    const target = within.startsWith("..") || path42.isAbsolute(within) ? abs : path42.resolve(opts.movedTo, within);
     return `${quote}${toSpecifier(opts.toDir, target)}${quote}`;
   });
 }
@@ -69928,7 +70024,7 @@ function repointMoved(text3, opts) {
 var ARCHIVE_ROOT = "src/_variants";
 var QUOTED_RELATIVE2 = /(['"])(\.\.?\/[^'"]*)\1/g;
 function posix2(p) {
-  return p.split(path42.sep).join("/");
+  return p.split(path43.sep).join("/");
 }
 async function isDir(p) {
   try {
@@ -69947,39 +70043,39 @@ async function filesUnder(dir, prefix = "") {
   const out = [];
   for (const entry of entries) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) out.push(...await filesUnder(path42.join(dir, entry.name), rel));
+    if (entry.isDirectory()) out.push(...await filesUnder(path43.join(dir, entry.name), rel));
     else out.push(rel);
   }
   return out.sort();
 }
 var TEXT_EXT = /\.(astro|ts|tsx|js|jsx|mjs|cjs|vue|svelte|md|json|css)$/;
 function archiveRelPath(abs, base) {
-  if (!abs.startsWith(base + path42.sep)) return null;
-  return posix2(path42.relative(base, abs));
+  if (!abs.startsWith(base + path43.sep)) return null;
+  return posix2(path43.relative(base, abs));
 }
 async function archiveArm(opts) {
   const { root, armDir, pageDir, archiveDir, armSlug } = opts;
   const targets = await archiveContents({ root, armDir, pageDir, armSlug });
-  const archivedBySource = new Map([...targets].map(([rel, abs]) => [abs, path42.join(archiveDir, rel)]));
+  const archivedBySource = new Map([...targets].map(([rel, abs]) => [abs, path43.join(archiveDir, rel)]));
   const written = [];
   for (const [rel, abs] of [...targets].sort()) {
-    const dest = path42.join(archiveDir, rel);
-    await mkdir13(path42.dirname(dest), { recursive: true });
+    const dest = path43.join(archiveDir, rel);
+    await mkdir13(path43.dirname(dest), { recursive: true });
     if (!TEXT_EXT.test(rel)) {
       await cp3(abs, dest);
     } else {
-      const text3 = await readFile35(abs, "utf8");
+      const text3 = await readFile36(abs, "utf8");
       await writeFile19(dest, repointIntoArchive(text3, abs, dest, archivedBySource), "utf8");
     }
-    written.push(posix2(path42.relative(root, dest)));
+    written.push(posix2(path43.relative(root, dest)));
   }
   return written;
 }
 async function archiveContents(opts) {
   const { root, armDir, pageDir, armSlug } = opts;
   const graph = await landingGraphFiles(root, armSlug);
-  const reachable = new Set([...graph].map((rel) => path42.resolve(root, rel)));
-  for (const rel of await filesUnder(armDir)) reachable.add(path42.join(armDir, rel));
+  const reachable = new Set([...graph].map((rel) => path43.resolve(root, rel)));
+  for (const rel of await filesUnder(armDir)) reachable.add(path43.join(armDir, rel));
   const sorted = [...reachable].sort();
   const targets = /* @__PURE__ */ new Map();
   for (const base of [pageDir, armDir]) {
@@ -69992,14 +70088,14 @@ async function archiveContents(opts) {
   return targets;
 }
 function repointIntoArchive(text3, sourceAbs, destAbs, archivedBySource) {
-  const fromDir = path42.dirname(sourceAbs);
-  const toDir = path42.dirname(destAbs);
+  const fromDir = path43.dirname(sourceAbs);
+  const toDir = path43.dirname(destAbs);
   return text3.replace(QUOTED_RELATIVE2, (match, quote, spec, offset) => {
     const [specPath, suffix] = splitSuffix(spec);
-    const target = path42.resolve(fromDir, specPath);
+    const target = path43.resolve(fromDir, specPath);
     const resolved = resolveInArchive(target, archivedBySource) ?? resolveOnDisk(target, isImportPosition(text3, offset));
     if (resolved === null) return match;
-    const rel = posix2(path42.relative(toDir, resolved));
+    const rel = posix2(path43.relative(toDir, resolved));
     return `${quote}${rel.startsWith(".") ? rel : `./${rel}`}${suffix}${quote}`;
   });
 }
@@ -70033,25 +70129,25 @@ async function promoteVariantFiles(opts) {
   const written = [];
   for (const rel of await filesUnder(variantDir)) {
     if (rel === "_definition.md") continue;
-    const from = path42.join(variantDir, rel);
-    const to = path42.join(pageDir, rel);
-    await mkdir13(path42.dirname(to), { recursive: true });
+    const from = path43.join(variantDir, rel);
+    const to = path43.join(pageDir, rel);
+    await mkdir13(path43.dirname(to), { recursive: true });
     if (!TEXT_EXT.test(rel)) {
       await cp3(from, to);
     } else {
-      const text3 = await readFile35(from, "utf8");
+      const text3 = await readFile36(from, "utf8");
       await writeFile19(
         to,
         repointMoved(text3, {
-          fromDir: path42.dirname(from),
-          toDir: path42.dirname(to),
+          fromDir: path43.dirname(from),
+          toDir: path43.dirname(to),
           movedFrom: variantDir,
           movedTo: pageDir
         }),
         "utf8"
       );
     }
-    written.push(posix2(path42.relative(root, to)));
+    written.push(posix2(path43.relative(root, to)));
   }
   return written;
 }
@@ -70075,8 +70171,8 @@ function archiveRecord(target, variantNumber) {
 `;
 }
 async function foldExperiment(root, target) {
-  const pageDir = path42.resolve(root, "src/pages", target.landingSlug);
-  const variantDir = path42.resolve(root, "src/pages", target.variantSlug);
+  const pageDir = path43.resolve(root, "src/pages", target.landingSlug);
+  const variantDir = path43.resolve(root, "src/pages", target.variantSlug);
   const variantNumber = variantNumberOf(target.variantSlug);
   if (variantNumber === null) {
     return {
@@ -70090,7 +70186,7 @@ async function foldExperiment(root, target) {
     return { error: `src/pages/${target.variantSlug}/ is already gone \u2014 this test looks folded in already` };
   }
   const archiveKey = target.landingInternalId ?? target.landingSlug;
-  const archiveDir = path42.resolve(root, ARCHIVE_ROOT, archiveKey, String(variantNumber));
+  const archiveDir = path43.resolve(root, ARCHIVE_ROOT, archiveKey, String(variantNumber));
   await rm8(archiveDir, { recursive: true, force: true });
   await mkdir13(archiveDir, { recursive: true });
   const written = await archiveArm({
@@ -70100,8 +70196,8 @@ async function foldExperiment(root, target) {
     archiveDir,
     armSlug: target.survivor === "variant" ? target.landingSlug : target.variantSlug
   });
-  await writeFile19(path42.join(archiveDir, "_variant.json"), archiveRecord(target, variantNumber), "utf8");
-  written.push(posix2(path42.join(ARCHIVE_ROOT, archiveKey, String(variantNumber), "_variant.json")));
+  await writeFile19(path43.join(archiveDir, "_variant.json"), archiveRecord(target, variantNumber), "utf8");
+  written.push(posix2(path43.join(ARCHIVE_ROOT, archiveKey, String(variantNumber), "_variant.json")));
   if (target.survivor === "variant") {
     written.push(...await promoteVariantFiles({ root, pageDir, variantDir }));
   }
@@ -70109,7 +70205,7 @@ async function foldExperiment(root, target) {
   return {
     experimentId: target.experimentId,
     page: target.landingSlug,
-    archivedTo: posix2(path42.join(ARCHIVE_ROOT, archiveKey, String(variantNumber))),
+    archivedTo: posix2(path43.join(ARCHIVE_ROOT, archiveKey, String(variantNumber))),
     written,
     removed: [`src/pages/${target.variantSlug}`]
   };
@@ -70881,11 +70977,11 @@ function parseEvidence(raw, rawArgs) {
 }
 
 // src/commands/experiment/identity.ts
-import { readFile as readFile36 } from "fs/promises";
-import path43 from "path";
+import { readFile as readFile37 } from "fs/promises";
+import path44 from "path";
 async function readPageInternalId(root, slug) {
   try {
-    const text3 = await readFile36(path43.resolve(root, "src", "pages", slug, "_definition.md"), "utf8");
+    const text3 = await readFile37(path44.resolve(root, "src", "pages", slug, "_definition.md"), "utf8");
     return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text3)?.[1];
   } catch {
     return void 0;
@@ -70893,8 +70989,8 @@ async function readPageInternalId(root, slug) {
 }
 
 // src/commands/experiment/measurement.ts
-import { readFile as readFile37 } from "fs/promises";
-import path44 from "path";
+import { readFile as readFile38 } from "fs/promises";
+import path45 from "path";
 function eventDeclarationsIn(source) {
   const found = [];
   const pattern = /\b(data-baker-(?:view|event))\s*=\s*["']([^"']+)["']/g;
@@ -70954,7 +71050,7 @@ function sectionsOf(files, slug) {
   return files.filter((file) => file.startsWith(prefix) && !file.slice(prefix.length).startsWith("index."));
 }
 async function declarationsOf(root, files) {
-  const sources = await Promise.all(files.map((file) => readFile37(path44.join(root, file), "utf8").catch(() => "")));
+  const sources = await Promise.all(files.map((file) => readFile38(path45.join(root, file), "utf8").catch(() => "")));
   return sources.flatMap(eventDeclarationsIn);
 }
 
@@ -72376,10 +72472,10 @@ function parseValueExpression(raw) {
   return parts.map(parsePart);
 }
 function trackingFieldIds() {
-  const path59 = join4(flowsDir(), "..", "tracking.ts");
-  if (!existsSync9(path59)) return null;
+  const path60 = join4(flowsDir(), "..", "tracking.ts");
+  if (!existsSync9(path60)) return null;
   try {
-    const source = readFileSync17(path59, "utf-8");
+    const source = readFileSync17(path60, "utf-8");
     const block2 = source.match(/TRACKING_FIELD_IDS\s*=\s*\[([\s\S]*?)\]\s*as const/)?.[1];
     if (!block2) return null;
     const ids2 = [...block2.matchAll(/"(tracking\.[a-z0-9_]+)"/g)].map((match) => match[1]);
@@ -72961,13 +73057,13 @@ function specsFromFile(parsed) {
     return `${destField}${type}=${entry?.value ?? ""}`;
   });
 }
-function readSpecFile(path59) {
+function readSpecFile(path60) {
   let raw;
   try {
-    raw = path59 === "-" ? readFileSync18(0, "utf-8") : readFileSync18(path59, "utf-8");
+    raw = path60 === "-" ? readFileSync18(0, "utf-8") : readFileSync18(path60, "utf-8");
   } catch (error) {
     refuse2(
-      `Could not read ${path59 === "-" ? "the mapping from stdin" : `"${path59}"`}: ${error instanceof Error ? error.message : String(error)}`
+      `Could not read ${path60 === "-" ? "the mapping from stdin" : `"${path60}"`}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   let parsed;
@@ -72975,7 +73071,7 @@ function readSpecFile(path59) {
     parsed = JSON.parse(raw);
   } catch (error) {
     refuse2(
-      `${path59 === "-" ? "stdin" : `"${path59}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      `${path60 === "-" ? "stdin" : `"${path60}"`} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
       'Expected { "map": { "<destField>": "<value>", \u2026 } }'
     );
   }
@@ -73274,21 +73370,21 @@ var ARRAY_FIELDS = [
   "tagIds"
 ];
 var ARRAY_OWNERS = ["", "body"];
-function dropUnsetOptionals(sideEffect, path59) {
+function dropUnsetOptionals(sideEffect, path60) {
   return OPTIONAL_STRINGS.flatMap((key) => {
     if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
     delete sideEffect[key];
-    return [{ path: path59, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+    return [{ path: path60, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
   });
 }
-function fillNulledArrays(target, prefix, path59) {
+function fillNulledArrays(target, prefix, path60) {
   return ARRAY_FIELDS.flatMap((key) => {
     if (!(key in target) || target[key] !== null) return [];
     target[key] = [];
-    return [{ path: path59, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+    return [{ path: path60, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
   });
 }
-function tidyEmailRecipients(sideEffect, path59) {
+function tidyEmailRecipients(sideEffect, path60) {
   if (sideEffect.type !== "email") return [];
   const config = sideEffect.encryptedConfig;
   if (!config || typeof config !== "object" || Array.isArray(config)) return [];
@@ -73299,7 +73395,7 @@ function tidyEmailRecipients(sideEffect, path59) {
   const tidied = to.join(", ");
   if (tidied === raw) return [];
   config.email = tidied;
-  return [{ path: path59, change: "tidied the recipient list's spacing and separators" }];
+  return [{ path: path60, change: "tidied the recipient list's spacing and separators" }];
 }
 function sideEffectsOf(node) {
   if (!Array.isArray(node.sideEffects)) return [];
@@ -73308,13 +73404,13 @@ function sideEffectsOf(node) {
   );
 }
 function normalizeSideEffect(sideEffect, where) {
-  const path59 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const path60 = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
   const arrays = ARRAY_OWNERS.flatMap((owner) => {
     const target = owner ? sideEffect[owner] : sideEffect;
     if (!target || typeof target !== "object") return [];
-    return fillNulledArrays(target, owner ? `${owner}.` : "", path59);
+    return fillNulledArrays(target, owner ? `${owner}.` : "", path60);
   });
-  return [...dropUnsetOptionals(sideEffect, path59), ...arrays, ...tidyEmailRecipients(sideEffect, path59)];
+  return [...dropUnsetOptionals(sideEffect, path60), ...arrays, ...tidyEmailRecipients(sideEffect, path60)];
 }
 function normalizeFlowTree(tree) {
   const changes = [];
@@ -74820,10 +74916,10 @@ async function stageOps(ops) {
     handleError5(err);
   }
 }
-async function draftAction2(path59, body, chat) {
+async function draftAction2(path60, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const { data, hints: hints2 } = splitHints(await apiPost(path59, { chatId, ...body }));
+    const { data, hints: hints2 } = splitHints(await apiPost(path60, { chatId, ...body }));
     writeJsonEnvelope({ ok: true, data, ...hints2.length > 0 ? { hints: hints2 } : {} });
     return data;
   } catch (err) {
@@ -77318,7 +77414,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile38, rename as rename2, stat as stat9, writeFile as writeFile20 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile39, rename as rename2, stat as stat9, writeFile as writeFile20 } from "fs/promises";
 import { dirname as dirname2, extname as extname3, join as join5, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
@@ -77351,11 +77447,11 @@ async function readImageBuffer(pathOrUrl) {
     const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
     return buffer;
   }
-  return readFile38(pathOrUrl);
+  return readFile39(pathOrUrl);
 }
-async function isDirectory(path59) {
+async function isDirectory(path60) {
   try {
-    const s = await stat9(path59);
+    const s = await stat9(path60);
     return s.isDirectory();
   } catch {
     return false;
@@ -77783,13 +77879,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path59) => {
-    if (!taken.has(path59)) {
-      taken.add(path59);
-      return path59;
+  return paths.map((path60) => {
+    if (!taken.has(path60)) {
+      taken.add(path60);
+      return path60;
     }
-    const ext = extname4(path59);
-    const stem = path59.slice(0, path59.length - ext.length);
+    const ext = extname4(path60);
+    const stem = path60.slice(0, path60.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -77915,10 +78011,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path59 = paths[index] ?? item.path;
+    const path60 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path59, item.buffer);
-      downloaded.push({ input: item.input, output: path59, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path60, item.buffer);
+      downloaded.push({ input: item.input, output: path60, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -80900,8 +80996,8 @@ Full guide: __tooling__/docs/tools/baker/images.md`
 import { defineCommand as defineCommand211 } from "citty";
 
 // src/commands/landing/critique.ts
-import { readdir as readdir18, readFile as readFile40, stat as stat11 } from "fs/promises";
-import path47 from "path";
+import { readdir as readdir18, readFile as readFile41, stat as stat11 } from "fs/promises";
+import path48 from "path";
 import { defineCommand as defineCommand200 } from "citty";
 
 // src/engine/landing/lib/constants.ts
@@ -82093,13 +82189,13 @@ function describeCounts(findings) {
 
 // src/commands/landing/snapshot.ts
 import { mkdir as mkdir14, rename as rename3, writeFile as writeFile21 } from "fs/promises";
-import path45 from "path";
+import path46 from "path";
 var CRITIC_VERSION = "4";
 function critiqueCacheDir(projectRoot) {
-  return path45.join(projectRoot, ".cache", "landing-critique");
+  return path46.join(projectRoot, ".cache", "landing-critique");
 }
 function snapshotPath(projectRoot, slug) {
-  return path45.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+  return path46.join(critiqueCacheDir(projectRoot), `${slug}.json`);
 }
 async function writeCritiqueSnapshot(projectRoot, snapshot) {
   await mkdir14(critiqueCacheDir(projectRoot), { recursive: true });
@@ -82111,8 +82207,8 @@ async function writeCritiqueSnapshot(projectRoot, snapshot) {
 }
 
 // src/commands/landing/source-version.ts
-import { readdir as readdir17, readFile as readFile39, stat as stat10 } from "fs/promises";
-import path46 from "path";
+import { readdir as readdir17, readFile as readFile40, stat as stat10 } from "fs/promises";
+import path47 from "path";
 var CRITIQUED_ROOTS = ["src/pages/", "src/components/"];
 async function landingSourceRelPaths(root, slug) {
   const files = await landingGraphFiles(root, slug);
@@ -82121,7 +82217,7 @@ async function landingSourceRelPaths(root, slug) {
 async function readLandingSources(root, slug) {
   const rel = await landingSourceRelPaths(root, slug);
   const out = [];
-  for (const r of rel) out.push({ path: r, text: await readFile39(path46.join(root, r), "utf8") });
+  for (const r of rel) out.push({ path: r, text: await readFile40(path47.join(root, r), "utf8") });
   return out;
 }
 async function computeLandingSourceSha(root, slug) {
@@ -82130,7 +82226,7 @@ async function computeLandingSourceSha(root, slug) {
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile39(path46.join(root, r));
+      bytes = await readFile40(path47.join(root, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -82140,16 +82236,16 @@ async function computeLandingSourceSha(root, slug) {
 }
 async function computeLegacyLandingSourceSha(landingDir) {
   const rel = [];
-  if (await isFile2(path46.join(landingDir, "index.astro"))) rel.push("index.astro");
-  for (const abs of await walkAstro(path46.join(landingDir, "_components"))) {
-    rel.push(path46.relative(landingDir, abs).split(path46.sep).join("/"));
+  if (await isFile2(path47.join(landingDir, "index.astro"))) rel.push("index.astro");
+  for (const abs of await walkAstro(path47.join(landingDir, "_components"))) {
+    rel.push(path47.relative(landingDir, abs).split(path47.sep).join("/"));
   }
   rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   const parts = [];
   for (const r of rel) {
     let bytes;
     try {
-      bytes = await readFile39(path46.join(landingDir, r));
+      bytes = await readFile40(path47.join(landingDir, r));
     } catch {
       bytes = Buffer.alloc(0);
     }
@@ -82173,7 +82269,7 @@ async function walkAstro(dir) {
   }
   const out = [];
   for (const entry of entries) {
-    const abs = path46.join(dir, entry.name);
+    const abs = path47.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkAstro(abs));
     else if (entry.isFile() && entry.name.endsWith(".astro")) out.push(abs);
   }
@@ -82234,7 +82330,7 @@ var critiqueCommand2 = defineCommand200({
           { availableSlugs: await listLandingSlugs(projectRoot) }
         );
       }
-      if (!await isDir2(path47.resolve(projectRoot, "src", "pages", slug))) {
+      if (!await isDir2(path48.resolve(projectRoot, "src", "pages", slug))) {
         fail8("NOT_FOUND", `No landing at src/pages/${slug}/`, {
           availableSlugs: await listLandingSlugs(projectRoot)
         });
@@ -82277,7 +82373,7 @@ async function critiqueOne(projectRoot, slug, brand, competitors) {
   const [sources, compositionSha, sourceSha] = await Promise.all([
     readLandingSources(projectRoot, slug),
     computeLandingSourceSha(projectRoot, slug),
-    computeLegacyLandingSourceSha(path47.resolve(projectRoot, "src", "pages", slug))
+    computeLegacyLandingSourceSha(path48.resolve(projectRoot, "src", "pages", slug))
   ]);
   const report = critiqueLanding({ slug, sources, brand, competitors });
   let snapshotFailed = false;
@@ -82297,7 +82393,7 @@ async function critiqueOne(projectRoot, slug, brand, competitors) {
   return { slug, report, snapshotFailed };
 }
 async function readCompetitorNames(projectRoot) {
-  const dir = path47.join(projectRoot, "src", "content", "competitors");
+  const dir = path48.join(projectRoot, "src", "content", "competitors");
   let entries;
   try {
     entries = (await readdir18(dir)).filter((f) => f.endsWith(".md"));
@@ -82306,9 +82402,9 @@ async function readCompetitorNames(projectRoot) {
   }
   const names = [];
   for (const entry of entries) {
-    names.push(path47.basename(entry, ".md").replace(/[-_]+/g, " "));
+    names.push(path48.basename(entry, ".md").replace(/[-_]+/g, " "));
     try {
-      const head = (await readFile40(path47.join(dir, entry), "utf8")).slice(0, 2e3);
+      const head = (await readFile41(path48.join(dir, entry), "utf8")).slice(0, 2e3);
       const titled = /^\s*(?:title|name)\s*:\s*["']?([^"'\n]+)["']?\s*$/im.exec(head);
       if (titled?.[1]) names.push(titled[1].trim());
     } catch {
@@ -82318,7 +82414,7 @@ async function readCompetitorNames(projectRoot) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir18(path47.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir18(path48.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 [];
@@ -82470,7 +82566,7 @@ var addCommand = defineCommand201({
 
 // src/commands/landing/inspiration/code.ts
 import { mkdir as mkdir15, writeFile as writeFile22 } from "fs/promises";
-import path48 from "path";
+import path49 from "path";
 import { defineCommand as defineCommand202 } from "citty";
 registerSchema({
   command: "landing.inspiration.code",
@@ -82493,9 +82589,9 @@ var codeCommand = defineCommand202({
     try {
       const id = args8.id;
       const data = await apiGet("/api/landing-inspiration/section-code", { id });
-      const dir = path48.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path49.join(process.cwd(), ".baker", "inspiration", id);
       await mkdir15(dir, { recursive: true });
-      const file = path48.join(dir, "section.html");
+      const file = path49.join(dir, "section.html");
       await writeFile22(file, data.html);
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
       const fidelity = fidelityHint(data.fidelity);
@@ -82505,7 +82601,7 @@ var codeCommand = defineCommand202({
         ok: true,
         data: {
           id,
-          file: path48.relative(process.cwd(), file),
+          file: path49.relative(process.cwd(), file),
           bytes: data.html.length,
           fidelity: data.fidelity,
           reproduction_notes: data.reproductionNotes,
@@ -82937,7 +83033,7 @@ function classifyCaptureFailure(error) {
 
 // src/engine/landing-library/run.ts
 import { mkdir as mkdir16, writeFile as writeFile24 } from "fs/promises";
-import path50 from "path";
+import path51 from "path";
 
 // ../proxy/src/preflight.ts
 import http from "http";
@@ -84355,9 +84451,9 @@ async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
 
 // src/engine/landing-library/report.ts
 import { writeFile as writeFile23 } from "fs/promises";
-import path49 from "path";
+import path50 from "path";
 async function writeCaptureReport(manifest, outDir) {
-  const file = path49.join(outDir, "report.html");
+  const file = path50.join(outDir, "report.html");
   await writeFile23(file, renderReport(manifest));
   return file;
 }
@@ -84536,32 +84632,32 @@ async function reproducePage(args8) {
   const { browser, page, outDir, pageUrl, livePageShot } = args8;
   const built = await buildSectionBundle(page, "body", pageUrl).catch(() => null);
   if (!built) return { bundle: null, fidelity: null };
-  await writeFile24(path50.join(outDir, "page.html"), built.html);
+  await writeFile24(path51.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 writeFile24(path50.join(outDir, "page-rendered.png"), rendered);
+  await writeFile24(path51.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(args8) {
   const { browser, page, candidate, sectionsDir, outDir, pageUrl, withCode } = args8;
-  const dir = path50.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  const dir = path51.join(sectionsDir, String(candidate.index).padStart(2, "0"));
   await mkdir16(dir, { recursive: true });
   const desktop = await captureSection(page, candidate);
-  if (desktop) await writeFile24(path50.join(dir, "desktop.png"), desktop);
+  if (desktop) await writeFile24(path51.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 writeFile24(path50.join(dir, "section.html"), built.html);
+    await writeFile24(path51.join(dir, "section.html"), built.html);
     const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
     if (rendered && desktop) {
-      await writeFile24(path50.join(dir, "section-rendered.png"), rendered);
+      await writeFile24(path51.join(dir, "section-rendered.png"), rendered);
       const result = await scoreFidelity(desktop, rendered);
       fidelity = result.score;
       fidelityNote = result.note;
@@ -84569,9 +84665,9 @@ async function captureOneSection(args8) {
   }
   return {
     ...candidate,
-    desktopShot: desktop ? path50.relative(outDir, path50.join(dir, "desktop.png")) : null,
+    desktopShot: desktop ? path51.relative(outDir, path51.join(dir, "desktop.png")) : null,
     mobileShot: null,
-    bundle: built ? path50.relative(outDir, path50.join(dir, "section.html")) : null,
+    bundle: built ? path51.relative(outDir, path51.join(dir, "section.html")) : null,
     fidelity,
     ...fidelityNote ? { fidelityNote } : {},
     ...built ? { cssStats: built.stats } : {},
@@ -84590,9 +84686,9 @@ async function captureMobileShots(args8) {
     for (const section of sections) {
       const shot = await captureSectionOnMobile(mobile.page, section);
       if (!shot) continue;
-      const file = path50.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      const file = path51.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
       await writeFile24(file, shot);
-      section.mobileShot = path50.relative(outDir, file);
+      section.mobileShot = path51.relative(outDir, file);
     }
   } finally {
     await mobile.context.close();
@@ -84607,10 +84703,10 @@ async function captureMotionTakes(args8) {
   const filmOne = async (section) => {
     const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
     if (!take) return;
-    const dir = path50.join(sectionsDir, String(section.index).padStart(2, "0"));
-    const file = path50.join(dir, "motion-filmstrip.png");
+    const dir = path51.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path51.join(dir, "motion-filmstrip.png");
     await writeFile24(file, take.filmstrip);
-    section.motionFilmstrip = path50.relative(outDir, file);
+    section.motionFilmstrip = path51.relative(outDir, file);
     log(`  [${section.index}] ${section.motion.summary}`);
   };
   const queue = [...moving];
@@ -84667,7 +84763,7 @@ async function captureAlternateViews(args8) {
 async function reproduceWholePage(args8) {
   const { browser, page, outDir, pageUrl, withCode, log } = args8;
   const fullPage = await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
-  if (fullPage) await writeFile24(path50.join(outDir, "full-page.png"), fullPage);
+  if (fullPage) await writeFile24(path51.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)}`);
@@ -84738,7 +84834,7 @@ async function openViaLadder(args8) {
 async function scrapeLanding(options) {
   const timeoutMs = options.timeoutMs ?? 45e3;
   const log = options.onProgress ?? (() => void 0);
-  const sectionsDir = path50.join(options.outDir, "sections");
+  const sectionsDir = path51.join(options.outDir, "sections");
   const nonPublic = refuseNonPublicUrl(options.url);
   if (nonPublic) {
     throw new BlockedPageError({
@@ -84800,7 +84896,7 @@ async function scrapeLanding(options) {
       security: prepared.security,
       captureTier: tier
     };
-    await writeFile24(path50.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile24(path51.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
     if (options.report !== false) {
       const reportPath = await writeCaptureReport(manifest, options.outDir);
@@ -84815,28 +84911,28 @@ async function scrapeLanding(options) {
 
 // src/commands/landing/inspiration/captureOut.ts
 import { existsSync as existsSync12 } from "fs";
-import path51 from "path";
+import path52 from "path";
 var SCRATCH_DIR = ".baker";
 function isWithin(parent, target) {
-  const relative = path51.relative(parent, target);
-  return relative === "" || !relative.startsWith("..") && !path51.isAbsolute(relative);
+  const relative = path52.relative(parent, target);
+  return relative === "" || !relative.startsWith("..") && !path52.isAbsolute(relative);
 }
 function findRepoRoot(from) {
-  let dir = path51.resolve(from);
+  let dir = path52.resolve(from);
   for (; ; ) {
-    if (existsSync12(path51.join(dir, ".git"))) return dir;
-    const parent = path51.dirname(dir);
+    if (existsSync12(path52.join(dir, ".git"))) return dir;
+    const parent = path52.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function checkCaptureOut(out, options) {
   const { cwd, repoRoot } = options;
-  const resolved = path51.resolve(cwd, out);
+  const resolved = path52.resolve(cwd, out);
   if (repoRoot === null || !isWithin(repoRoot, resolved)) return { ok: true };
-  const scratch = path51.join(repoRoot, SCRATCH_DIR);
+  const scratch = path52.join(repoRoot, SCRATCH_DIR);
   if (isWithin(scratch, resolved)) return { ok: true };
-  const suggestion = path51.posix.join(SCRATCH_DIR, "teardowns", path51.basename(resolved) || "capture");
+  const suggestion = path52.posix.join(SCRATCH_DIR, "teardowns", path52.basename(resolved) || "capture");
   return {
     ok: false,
     error: {
@@ -85010,12 +85106,12 @@ var scrapeCommand = defineCommand205({
 });
 
 // src/commands/landing/inspiration/search.ts
-import path53 from "path";
+import path54 from "path";
 import { defineCommand as defineCommand206 } from "citty";
 
 // src/commands/landing/inspiration/shot.ts
 import { mkdir as mkdir17, writeFile as writeFile25 } from "fs/promises";
-import path52 from "path";
+import path53 from "path";
 import sharp7 from "sharp";
 var READABLE_SHOT = {
   maxWidth: 1440,
@@ -85041,9 +85137,9 @@ async function downloadReadableShot(url, file) {
     const response = await fetch(url);
     if (!response.ok) return null;
     const shot = await toReadableShot(Buffer.from(await response.arrayBuffer()));
-    await mkdir17(path52.dirname(file), { recursive: true });
+    await mkdir17(path53.dirname(file), { recursive: true });
     await writeFile25(file, shot);
-    return path52.relative(process.cwd(), file);
+    return path53.relative(process.cwd(), file);
   } catch {
     return null;
   }
@@ -85135,13 +85231,13 @@ function buildSearchBody(args8) {
   return body;
 }
 async function downloadShots(results) {
-  const dir = path53.join(process.cwd(), ".baker", "inspiration");
+  const dir = path54.join(process.cwd(), ".baker", "inspiration");
   const saved = /* @__PURE__ */ new Map();
   await Promise.all(
     results.map(async (result) => {
       const file = await downloadReadableShot(
         result.desktopShotUrl,
-        path53.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
+        path54.join(dir, `${result.id}.${READABLE_SHOT.extension}`)
       );
       if (file) saved.set(result.id, file);
     })
@@ -85369,7 +85465,7 @@ var sequencesCommand = defineCommand207({
 });
 
 // src/commands/landing/inspiration/view.ts
-import path54 from "path";
+import path55 from "path";
 import { defineCommand as defineCommand208 } from "citty";
 registerSchema({
   command: "landing.inspiration.view",
@@ -85402,12 +85498,12 @@ var viewCommand2 = defineCommand208({
       const id = args8.id;
       const data = await apiGet("/api/landing-inspiration/section", { id });
       const section = data.section;
-      const dir = path54.join(process.cwd(), ".baker", "inspiration", id);
+      const dir = path55.join(process.cwd(), ".baker", "inspiration", id);
       const ext = READABLE_SHOT.extension;
       const [desktop, mobile, filmstrip] = await Promise.all([
-        downloadReadableShot(section.desktopShotUrl, path54.join(dir, `desktop.${ext}`)),
-        downloadReadableShot(section.mobileShotUrl, path54.join(dir, `mobile.${ext}`)),
-        downloadReadableShot(section.motionFilmstripUrl, path54.join(dir, `motion-filmstrip.${ext}`))
+        downloadReadableShot(section.desktopShotUrl, path55.join(dir, `desktop.${ext}`)),
+        downloadReadableShot(section.mobileShotUrl, path55.join(dir, `mobile.${ext}`)),
+        downloadReadableShot(section.motionFilmstripUrl, path55.join(dir, `motion-filmstrip.${ext}`))
       ]);
       const full = args8.full;
       const hints2 = [INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt];
@@ -85513,8 +85609,8 @@ Full guide: __tooling__/docs/tools/baker/landing.md`
 
 // src/commands/landing/variant.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir18, readdir as readdir19, readFile as readFile41, stat as stat12, writeFile as writeFile26 } from "fs/promises";
-import path55 from "path";
+import { mkdir as mkdir18, readdir as readdir19, readFile as readFile42, stat as stat12, writeFile as writeFile26 } from "fs/promises";
+import path56 from "path";
 import { defineCommand as defineCommand210 } from "citty";
 registerSchema({
   command: "landing.variant",
@@ -85541,7 +85637,7 @@ registerSchema({
 var SLUG_RE2 = /^[a-z0-9][a-z0-9-]*$/;
 async function readInternalId(definitionPath) {
   try {
-    const text3 = await readFile41(definitionPath, "utf8");
+    const text3 = await readFile42(definitionPath, "utf8");
     return /^internalId:\s*"?([^"\s]+)"?\s*$/m.exec(text3)?.[1] ?? null;
   } catch {
     return null;
@@ -85550,7 +85646,7 @@ async function readInternalId(definitionPath) {
 async function archivedVariantNumbers(root, internalId) {
   if (!internalId) return [];
   try {
-    const entries = await readdir19(path55.resolve(root, "src/_variants", internalId), { withFileTypes: true });
+    const entries = await readdir19(path56.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 [];
@@ -85580,7 +85676,7 @@ async function exists2(p) {
 }
 async function listLandingSlugs2(root) {
   try {
-    const entries = await readdir19(path55.resolve(root, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir19(path56.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 [];
@@ -85596,7 +85692,7 @@ async function listComponents(componentsDir, prefix = "") {
   const out = [];
   for (const entry of entries) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) out.push(...await listComponents(path55.join(componentsDir, entry.name), rel));
+    if (entry.isDirectory()) out.push(...await listComponents(path56.join(componentsDir, entry.name), rel));
     else if (entry.name.endsWith(".astro")) out.push(rel);
   }
   return out.sort();
@@ -85663,16 +85759,16 @@ async function resolveTargets(projectRoot, opts) {
       `"${controlSlug}" is already a variant of "${variantOfSlug(controlSlug)}". Make the next variant of the page itself: \`baker landing variant ${variantOfSlug(controlSlug)}\`.`
     );
   }
-  const controlDir = path55.resolve(projectRoot, "src", "pages", controlSlug);
+  const controlDir = path56.resolve(projectRoot, "src", "pages", controlSlug);
   if (!await isDir3(controlDir)) {
     fail9("NOT_FOUND", `No page at src/pages/${controlSlug}/`, {
       availableSlugs: await listLandingSlugs2(projectRoot)
     });
   }
-  if (!await exists2(path55.join(controlDir, "index.astro"))) {
+  if (!await exists2(path56.join(controlDir, "index.astro"))) {
     fail9("NOT_FOUND", `src/pages/${controlSlug}/index.astro is missing, so there is no page to make a variant of.`);
   }
-  const internalId = await readInternalId(path55.join(controlDir, "_definition.md"));
+  const internalId = await readInternalId(path56.join(controlDir, "_definition.md"));
   const variantSlugValue = variantSlug(
     controlSlug,
     nextVariantNumber(
@@ -85681,8 +85777,8 @@ async function resolveTargets(projectRoot, opts) {
       await archivedVariantNumbers(projectRoot, internalId)
     )
   );
-  const variantDir = path55.resolve(projectRoot, "src", "pages", variantSlugValue);
-  const available = await listComponents(path55.join(controlDir, "_components"));
+  const variantDir = path56.resolve(projectRoot, "src", "pages", variantSlugValue);
+  const available = await listComponents(path56.join(controlDir, "_components"));
   const forks = [];
   for (const name of parseForks(opts.fork, opts.rawArgs)) {
     const resolved = resolveForkName(name, available);
@@ -85698,26 +85794,26 @@ async function resolveTargets(projectRoot, opts) {
 }
 async function writeVariant(opts) {
   const { controlDir, variantDir, controlSlug, variantSlug: variantSlug2, forks } = opts;
-  const forkedTargets = new Set(forks.map((f) => path55.join(controlDir, "_components", f)));
+  const forkedTargets = new Set(forks.map((f) => path56.join(controlDir, "_components", f)));
   const written = [];
-  const indexText = await readFile41(path55.join(controlDir, "index.astro"), "utf8");
+  const indexText = await readFile42(path56.join(controlDir, "index.astro"), "utf8");
   await mkdir18(variantDir, { recursive: true });
   await writeFile26(
-    path55.join(variantDir, "index.astro"),
+    path56.join(variantDir, "index.astro"),
     repointFile(indexText, { fromDir: controlDir, toDir: variantDir, controlDir, variantDir, forkedTargets }),
     "utf8"
   );
   written.push(`src/pages/${variantSlug2}/index.astro`);
   for (const fork of forks) {
-    const fromFile = path55.join(controlDir, "_components", fork);
-    const toFile = path55.join(variantDir, "_components", fork);
-    const text3 = await readFile41(fromFile, "utf8");
-    await mkdir18(path55.dirname(toFile), { recursive: true });
+    const fromFile = path56.join(controlDir, "_components", fork);
+    const toFile = path56.join(variantDir, "_components", fork);
+    const text3 = await readFile42(fromFile, "utf8");
+    await mkdir18(path56.dirname(toFile), { recursive: true });
     await writeFile26(
       toFile,
       repointFile(text3, {
-        fromDir: path55.dirname(fromFile),
-        toDir: path55.dirname(toFile),
+        fromDir: path56.dirname(fromFile),
+        toDir: path56.dirname(toFile),
         controlDir,
         variantDir,
         forkedTargets
@@ -85726,9 +85822,9 @@ async function writeVariant(opts) {
     );
     written.push(`src/pages/${variantSlug2}/_components/${fork}`);
   }
-  const controlDefinitionPath = path55.join(controlDir, "_definition.md");
+  const controlDefinitionPath = path56.join(controlDir, "_definition.md");
   if (await exists2(controlDefinitionPath)) {
-    const definition = buildVariantDefinition(await readFile41(controlDefinitionPath, "utf8"), {
+    const definition = buildVariantDefinition(await readFile42(controlDefinitionPath, "utf8"), {
       internalId: randomUUID4().replace(/-/g, "").slice(0, 8),
       variantSlug: variantSlug2,
       controlSlug,
@@ -85736,11 +85832,11 @@ async function writeVariant(opts) {
       ...opts.because ? { because: opts.because } : {},
       ...opts.change ? { change: opts.change } : {}
     });
-    await writeFile26(path55.join(variantDir, "_definition.md"), definition, "utf8");
+    await writeFile26(path56.join(variantDir, "_definition.md"), definition, "utf8");
     written.push(`src/pages/${variantSlug2}/_definition.md`);
   }
-  await mkdir18(path55.join(variantDir, "_images"), { recursive: true });
-  await writeFile26(path55.join(variantDir, "_images", ".gitkeep"), "", "utf8");
+  await mkdir18(path56.join(variantDir, "_images"), { recursive: true });
+  await writeFile26(path56.join(variantDir, "_images", ".gitkeep"), "", "utf8");
   return written;
 }
 var variantCommand = defineCommand210({
@@ -88887,8 +88983,8 @@ Full guide: __tooling__/docs/tools/baker/scheduled-agents.md`
 });
 
 // src/commands/scheduled-agents/templates.ts
-import { readFile as readFile42 } from "fs/promises";
-import path56 from "path";
+import { readFile as readFile43 } from "fs/promises";
+import path57 from "path";
 import { defineCommand as defineCommand239 } from "citty";
 registerSchema({
   command: "scheduled-agents.templates",
@@ -88995,7 +89091,7 @@ Full guide: __tooling__/docs/tools/baker/scheduled-agents.md`
       }
       if (save.length > 0) {
         const briefFile = flag("brief-file");
-        const brief2 = briefFile.length > 0 ? await readFile42(path56.resolve(briefFile), "utf8") : flag("brief");
+        const brief2 = briefFile.length > 0 ? await readFile43(path57.resolve(briefFile), "utf8") : flag("brief");
         if (brief2.trim().length === 0) {
           failValidation5("--brief-file (preferred) or --brief is required: the brief is the recipe.");
         }
@@ -89635,7 +89731,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path59) => uploadLocalImage({ file: path59, contentType: detectImageContentType(path59), source: "uploaded" })
+  upload: (path60) => uploadLocalImage({ file: path60, contentType: detectImageContentType(path60), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -89655,10 +89751,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path59) {
+function uploadFailure(path60) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path59}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path60}" as an image.`);
   };
 }
 
@@ -90758,10 +90854,10 @@ async function stageOp4(op) {
     handleError8(err);
   }
 }
-async function draftAction3(path59, body, chat) {
+async function draftAction3(path60, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const { data, hints: hints2 } = splitHints(await apiPost(path59, { chatId, ...body }));
+    const { data, hints: hints2 } = splitHints(await apiPost(path60, { chatId, ...body }));
     writeJsonEnvelope({ ok: true, data, ...hints2.length > 0 ? { hints: hints2 } : {} });
     return data;
   } catch (err) {
@@ -92191,7 +92287,7 @@ Example: baker videos describe j571abc123 --description "Customer explaining how
 import { constants } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir19, mkdtemp as mkdtemp2, rm as rm9 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path57 from "path";
+import path58 from "path";
 import { defineCommand as defineCommand271 } from "citty";
 
 // src/commands/videos/videoPlatforms.ts
@@ -92359,8 +92455,8 @@ var fetchCommand2 = defineCommand271({
   }
 });
 async function fetchVideo(args8) {
-  const outDir = path57.resolve(args8.out);
-  const workDir = await mkdtemp2(path57.join(tmpdir3(), "videos-fetch-"));
+  const outDir = path58.resolve(args8.out);
+  const workDir = await mkdtemp2(path58.join(tmpdir3(), "videos-fetch-"));
   try {
     await mkdir19(outDir, { recursive: true });
     const vimeoCookie = captureVimeoCookie();
@@ -92405,7 +92501,7 @@ function fileStem(info) {
 }
 async function placeInto(outDir, source, stem) {
   for (let n = 1; ; n++) {
-    const target = path57.join(outDir, `${stem}${n === 1 ? "" : `-${n}`}${path57.extname(source)}`);
+    const target = path58.join(outDir, `${stem}${n === 1 ? "" : `-${n}`}${path58.extname(source)}`);
     try {
       await copyFile2(source, target, constants.COPYFILE_EXCL);
       return target;
@@ -92492,7 +92588,7 @@ var groupCommand2 = defineCommand273({
 // src/commands/videos/ingest.ts
 import { mkdtemp as mkdtemp3, rm as rm10, stat as stat13 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import path58 from "path";
+import path59 from "path";
 import { defineCommand as defineCommand274 } from "citty";
 
 // src/lib/streamUpload.ts
@@ -92732,7 +92828,7 @@ function ingestUrl(args8) {
 }
 async function downloadThenIngest(args8, country) {
   const vimeoCookie = captureVimeoCookie();
-  const workDir = await mkdtemp3(path58.join(tmpdir4(), "videos-ingest-"));
+  const workDir = await mkdtemp3(path59.join(tmpdir4(), "videos-ingest-"));
   try {
     const probe = await probeYtDlp({ url: args8.url, country, vimeoCookie, cookieDir: workDir });
     if (isAudioOnly(probe.info)) {
@@ -93808,8 +93904,8 @@ var FLAG_FOR_FIELD = {
   first_seen_after: "--first-seen-after",
   first_seen_before: "--first-seen-before"
 };
-function flagFor(path59) {
-  const field = String(path59[0] === "hard_filters" ? path59[1] : path59[0]);
+function flagFor(path60) {
+  const field = String(path60[0] === "hard_filters" ? path60[1] : path60[0]);
   return FLAG_FOR_FIELD[field] ?? field;
 }
 function schemaRejection(body) {