@koda-sl/baker-cli 0.217.0 → 0.223.0

package/dist/cli.js

@@ -58,7 +58,7 @@ import {
   ulid,
   validateCanvasDeep,
   ytDlpBlockSignal
-} from "./chunk-EKLAHWSF.js";
+} from "./chunk-CMPAHYLB.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -21006,10 +21006,225 @@ Full guide: __tooling__/docs/tools/baker/avatars.md`
 import { defineCommand as defineCommand94 } from "citty";
 
 // src/commands/brand/fonts.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
+import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
 import { defineCommand as defineCommand93 } from "citty";
 
+// src/engine/brand/fonts.ts
+import { posix } from "path";
+
+// src/engine/landing/lib/brand-tokens.ts
+import { readFile } from "fs/promises";
+import path from "path";
+
+// src/engine/landing/lib/color.ts
+var NEUTRAL_COLOR_KEYWORDS = /* @__PURE__ */ new Set([
+  "transparent",
+  "currentcolor",
+  "black",
+  "white",
+  "gray",
+  "grey",
+  "silver",
+  "dimgray",
+  "dimgrey",
+  "darkgray",
+  "darkgrey",
+  "lightgray",
+  "lightgrey",
+  "gainsboro",
+  "whitesmoke"
+]);
+function hexChannels(color) {
+  const long = color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})(?:[0-9a-f]{2})?$/i);
+  if (long)
+    return [
+      Number.parseInt(long[1] ?? "0", 16),
+      Number.parseInt(long[2] ?? "0", 16),
+      Number.parseInt(long[3] ?? "0", 16)
+    ];
+  const short = color.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])(?:[0-9a-f])?$/i);
+  if (short) {
+    const dup = (s) => Number.parseInt(`${s ?? "0"}${s ?? "0"}`, 16);
+    return [dup(short[1]), dup(short[2]), dup(short[3])];
+  }
+  return null;
+}
+function parseColor(raw) {
+  const c = String(raw || "").trim().toLowerCase();
+  if (!c || c === "transparent") return null;
+  const rgb = c.match(/rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)(?:[\s,/]+([\d.]+%?))?\s*\)/i);
+  if (rgb) {
+    const alpha = rgb[4];
+    const a = alpha === void 0 ? 1 : alpha.endsWith("%") ? Number.parseFloat(alpha) / 100 : Number.parseFloat(alpha);
+    return { r: Number(rgb[1]), g: Number(rgb[2]), b: Number(rgb[3]), a };
+  }
+  const oklch = parseOklch(c);
+  if (oklch) return oklch;
+  const hex = hexChannels(c);
+  if (hex) return { r: hex[0], g: hex[1], b: hex[2], a: 1 };
+  return null;
+}
+function parseOklch(c) {
+  const m = c.match(/oklch\(\s*([\d.]+%?)\s+([\d.]+%?)\s+([\d.]+)(?:deg)?(?:\s*\/\s*([\d.]+%?))?\s*\)/i);
+  if (!m) return null;
+  const pct = (s, scale) => s.endsWith("%") ? Number.parseFloat(s) / 100 * scale : Number.parseFloat(s);
+  const alpha = m[4];
+  const a = alpha === void 0 ? 1 : pct(alpha, 1);
+  return { ...oklchToRgb(pct(m[1] ?? "0", 1), pct(m[2] ?? "0", 0.4), Number.parseFloat(m[3] ?? "0")), a };
+}
+function oklchToRgb(L, C, H) {
+  const hRad = H * Math.PI / 180;
+  const a = C * Math.cos(hRad);
+  const b = C * Math.sin(hRad);
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  const lin = [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ].map((v) => {
+    const g = v <= 31308e-7 ? 12.92 * v : 1.055 * Math.sign(v) * Math.abs(v) ** (1 / 2.4) - 0.055;
+    return Math.round(Math.max(0, Math.min(1, g)) * 255);
+  });
+  return { r: lin[0] ?? 0, g: lin[1] ?? 0, b: lin[2] ?? 0 };
+}
+function isNeutralAuthoredColor(rawColor) {
+  const c = String(rawColor || "").trim().toLowerCase();
+  if (!c) return false;
+  if (NEUTRAL_COLOR_KEYWORDS.has(c)) return true;
+  if (/^rgba?\(/i.test(c)) {
+    const channels2 = c.match(/^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/i);
+    if (channels2) {
+      const values = [1, 2, 3].map((i) => Number(channels2[i]));
+      return Math.max(...values) - Math.min(...values) < 30;
+    }
+    return false;
+  }
+  const oklch = c.match(/oklch\(\s*[\d.]+%?\s+([\d.-]+)/i);
+  if (oklch) return Number.parseFloat(oklch[1] ?? "0") < 0.02;
+  const lch = c.match(/lch\(\s*[\d.]+%?\s+([\d.-]+)/i);
+  if (lch) return Number.parseFloat(lch[1] ?? "0") < 3;
+  const hsl = c.match(/hsla?\(\s*[\d.-]+\s*,?\s*([\d.]+)%/i);
+  if (hsl) return Number.parseFloat(hsl[1] ?? "0") < 10;
+  const channels = hexChannels(c);
+  if (channels) return Math.max(...channels) - Math.min(...channels) < 30;
+  return false;
+}
+function hasChroma(c, threshold = 30) {
+  if (!c) return false;
+  return Math.max(c.r, c.g, c.b) - Math.min(c.r, c.g, c.b) >= threshold;
+}
+function getHue(c) {
+  if (!c) return 0;
+  const r = c.r / 255;
+  const g = c.g / 255;
+  const b = c.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  if (max === min) return 0;
+  const d = max - min;
+  let h;
+  if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+  else if (max === g) h = ((b - r) / d + 2) / 6;
+  else h = ((r - g) / d + 4) / 6;
+  return Math.round(h * 360);
+}
+function isAiPurpleHue(hue) {
+  return hue >= 225 && hue <= 310;
+}
+function isCreamColor(c) {
+  if (Math.min(c.r, c.g, c.b) < 209) return false;
+  if (!(c.r >= c.g && c.g >= c.b)) return false;
+  const warmth = c.r - c.b;
+  return warmth >= 6 && warmth <= 48;
+}
+
+// src/engine/landing/lib/brand-tokens.ts
+var EMPTY = { fonts: /* @__PURE__ */ new Set(), colors: [], hasTokens: false };
+function isNotAFamily(value) {
+  return /^[1-9]00$/.test(value) || /^\d+(?:\.\d+)?(?:px|rem|em|%|pt|vw|vh|ch|ex)$/i.test(value) || /^(?:normal|bold|bolder|lighter|italic|oblique|none|auto|inherit|initial|unset)$/i.test(value);
+}
+function parseBrandTokens(globalCss, brandMd) {
+  const fonts = /* @__PURE__ */ new Set();
+  const colors = [];
+  parseGlobalCss(globalCss, fonts, colors);
+  parseBrandMd(brandMd, fonts, colors);
+  return { fonts, colors, hasTokens: fonts.size > 0 || colors.length > 0 };
+}
+function parseGlobalCss(rawCss, fonts, colors) {
+  const globalCss = rawCss.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " "));
+  for (const m of globalCss.matchAll(/(?<![\w-])--font-([\w-]*)\s*:\s*([^;]+);/gi)) {
+    const slug = m[1] ?? "";
+    if (slug.includes("--") || /^weight(?:$|[-\s])/i.test(slug)) continue;
+    const first = (m[2] ?? "").split(",")[0]?.trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+    if (!first || isNotAFamily(first)) continue;
+    fonts.add(first);
+  }
+  for (const m of globalCss.matchAll(
+    /--color-[\w-]*\s*:\s*(#[0-9a-f]{3,8}\b|rgba?\([^)]+\)|oklch\([^)]+\)|hsla?\([^)]+\))/gi
+  )) {
+    const c = parseColor(m[1] ?? "");
+    if (c) colors.push(c);
+  }
+}
+function parseBrandMd(brandMd, fonts, colors) {
+  const isProhibition = (line) => /\b(?:never|don'?t|do not|avoid|not|instead of|ban(?:ned)?)\b/i.test(line);
+  for (const line of brandMd.split("\n")) {
+    if (isProhibition(line)) continue;
+    for (const m of line.matchAll(/#[0-9a-f]{6}\b/gi)) {
+      const c = parseColor(m[0]);
+      if (c) colors.push(c);
+    }
+    if (!/\b(?:font|typeface|family)\b/i.test(line)) continue;
+    const named = line.match(/["'`]([A-Za-z][\w ]{1,30})["'`]/g);
+    if (named) for (const n of named) fonts.add(n.slice(1, -1).trim().toLowerCase());
+  }
+}
+function brandTokensFromCanonical(tokens) {
+  const fonts = new Set(tokens.fonts.map((f) => f.family.toLowerCase()));
+  const colors = [];
+  for (const color of tokens.colors) {
+    const parsed = parseColor(color.value);
+    if (parsed) colors.push(parsed);
+  }
+  return { fonts, colors, hasTokens: fonts.size > 0 || colors.length > 0 };
+}
+async function loadBrandTokens(projectRoot) {
+  const tokensRaw = await safeRead(path.join(projectRoot, "src", "brand", "tokens.json"));
+  if (tokensRaw) {
+    try {
+      const canonical2 = brandTokensSchema.safeParse(JSON.parse(tokensRaw));
+      if (canonical2.success) return brandTokensFromCanonical(canonical2.data);
+    } catch {
+    }
+  }
+  const globalCss = await safeRead(path.join(projectRoot, "src", "styles", "global.css"));
+  const brandMd = await safeRead(path.join(projectRoot, "src", "brand", "BRAND.md"));
+  if (!globalCss && !brandMd) return EMPTY;
+  return parseBrandTokens(globalCss, brandMd);
+}
+async function safeRead(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+function brandCommitsFont(brand, snippet) {
+  if (brand.fonts.size === 0) return false;
+  const lower = snippet.toLowerCase();
+  for (const f of brand.fonts) if (f.length >= 3 && lower.includes(f)) return true;
+  return false;
+}
+function brandCommitsAiHue(brand) {
+  return brand.colors.some((c) => hasChroma(c, 40) && isAiPurpleHue(getHue(c)));
+}
+function brandCommitsCream(brand) {
+  return brand.colors.some((c) => isCreamColor(c));
+}
+
 // src/engine/brand/fonts.ts
 var GOOGLE_CSS2 = "https://fonts.googleapis.com/css2";
 function parseGoogleFontFaces(css) {
@@ -21055,6 +21270,157 @@ function renderFontFaceCss(faces) {
     ].join("\n")
   ).join("\n");
 }
+var FONT_PROVIDERS = ["google", "fontsource"];
+var FONTSOURCE_API = "https://api.fontsource.org/v1";
+function fontsourceId(family) {
+  return family.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function fontsourceFaces(meta, weights, subsets) {
+  const faces = [];
+  for (const subset of subsets.filter((s) => meta.subsets.includes(s))) {
+    for (const weight of weights.filter((w) => meta.weights.includes(w))) {
+      const url = meta.variants[String(weight)]?.normal?.[subset]?.url?.woff2;
+      if (!url) continue;
+      faces.push({
+        subset,
+        family: meta.family,
+        style: "normal",
+        weight,
+        url,
+        unicodeRange: meta.unicodeRange?.[subset] ?? "",
+        provider: "fontsource"
+      });
+    }
+  }
+  return faces;
+}
+function undisambiguatedSubsets(faces) {
+  if (new Set(faces.map((face) => face.subset)).size < 2) return [];
+  return [...new Set(faces.filter((face) => !face.unicodeRange).map((face) => face.subset))];
+}
+function suggestFamilies(wanted, catalogue, limit = 5) {
+  const key = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const target = key(wanted);
+  if (!target) return [];
+  const words3 = target.split(" ");
+  const scored = catalogue.map((family) => {
+    const candidate = key(family);
+    if (candidate === target) return { family, score: 0 };
+    if (candidate.startsWith(target)) return { family, score: 1 };
+    if (candidate.includes(target)) return { family, score: 2 };
+    const shared = words3.filter((w) => w.length > 2 && candidate.includes(w)).length;
+    return { family, score: shared > 0 ? 3 + (words3.length - shared) : Number.POSITIVE_INFINITY };
+  }).filter((c) => Number.isFinite(c.score)).sort((a, b) => a.score - b.score || a.family.localeCompare(b.family));
+  return scored.slice(0, limit).map((c) => c.family);
+}
+function asFontsourceMeta(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const meta = body;
+  const ok = typeof meta.family === "string" && Array.isArray(meta.weights) && Array.isArray(meta.styles) && Array.isArray(meta.subsets) && typeof meta.variants === "object" && meta.variants !== null;
+  return ok ? meta : null;
+}
+async function probeGoogleWeights(family, lookup) {
+  const probes = await Promise.all(
+    STANDARD_WEIGHTS.map(async (weight) => ({ weight, got: await lookup(googleFontCssUrl(family, [weight])) }))
+  );
+  if (probes.some((probe) => probe.got.status === "unreachable")) return null;
+  return probes.filter((probe) => probe.got.status === "served").map((probe) => probe.weight);
+}
+async function resolveFromGoogle(family, weights, subsets, deps) {
+  const google = await deps.lookupGoogleCss(googleFontCssUrl(family, weights));
+  if (google.status === "unreachable") return { ok: false, reason: "unreachable", provider: "google" };
+  if (google.status === "absent") {
+    const served2 = await probeGoogleWeights(family, deps.lookupGoogleCss);
+    if (served2 === null) return { ok: false, reason: "unreachable", provider: "google" };
+    return served2.length > 0 ? { ok: false, reason: "weight", provider: "google", available: served2 } : null;
+  }
+  const served = parseGoogleFontFaces(google.css);
+  if (served.length === 0) return null;
+  const faces = served.filter((face) => subsets.includes(face.subset)).map((face) => ({ ...face, provider: "google" }));
+  if (faces.length > 0) return { ok: true, provider: "google", faces };
+  return { ok: false, reason: "subset", provider: "google", available: [...new Set(served.map((f) => f.subset))] };
+}
+async function resolveBrandFaces(family, weights, subsets, deps) {
+  const google = await resolveFromGoogle(family, weights, subsets, deps);
+  if (google) return google;
+  let body;
+  try {
+    body = await deps.fetchJson(`${FONTSOURCE_API}/fonts/${fontsourceId(family)}`);
+  } catch {
+    return { ok: false, reason: "unreachable", provider: "fontsource" };
+  }
+  const meta = asFontsourceMeta(body);
+  if (meta) {
+    const faces = fontsourceFaces(meta, weights, subsets);
+    const ambiguous = undisambiguatedSubsets(faces);
+    if (ambiguous.length > 0) {
+      return { ok: false, reason: "ambiguous-subsets", provider: "fontsource", available: meta.subsets };
+    }
+    if (faces.length > 0) return { ok: true, provider: "fontsource", faces };
+    if (!subsets.some((subset) => meta.subsets.includes(subset))) {
+      return { ok: false, reason: "subset", provider: "fontsource", available: meta.subsets };
+    }
+    return { ok: false, reason: "weight", provider: "fontsource", available: meta.weights };
+  }
+  return { ok: false, reason: "unknown-family" };
+}
+function rebaseFontFaceSrc(block, fromDir, toDir = "src/styles") {
+  return block.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (whole, _quote, href) => {
+    if (!isRepoFontHref(href)) return whole;
+    const target = posix.normalize(posix.join(fromDir, href));
+    return `url('${posix.relative(toDir, target)}')`;
+  });
+}
+function declaredFontFaces(source) {
+  const out = [];
+  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{[^}]*\}/gi)) {
+    const family = rule[0].match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!family || rule.index === void 0) continue;
+    out.push({ family: normalizeFamily(family), block: source.slice(rule.index, rule.index + rule[0].length) });
+  }
+  return out;
+}
+function isRepoFontHref(href) {
+  return !/^(?:data:|https?:|\/)/i.test(href);
+}
+function missingFontFiles(urls, available) {
+  return urls.filter(isRepoFontHref).map((url) => posix.basename(url.split("?")[0] ?? "")).filter((file) => !available.has(file));
+}
+function planFontAdoption(sources, families) {
+  const wanted = new Map(families.map((family) => [normalizeFamily(family), family]));
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const { path: path39, source } of sources) {
+    const dir = posix.dirname(path39);
+    for (const face of declaredFontFaces(source)) {
+      if (!wanted.has(face.family)) continue;
+      const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
+      perFile.set(path39, [...perFile.get(path39) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      byFamily.set(face.family, perFile);
+    }
+  }
+  const plans = [];
+  const conflicts = [];
+  for (const [family, perFile] of byFamily) {
+    const display = wanted.get(family) ?? family;
+    const files = [...perFile.keys()];
+    const shapes = new Set([...perFile.values()].map((blocks2) => blocks2.join("\n")));
+    if (shapes.size > 1) {
+      conflicts.push({ family: display, files });
+      continue;
+    }
+    const blocks = perFile.get(files[0] ?? "") ?? [];
+    const urls = blocks.flatMap(
+      (block) => [...block.matchAll(/url\(\s*['"]?([^'")]+)['"]?\s*\)/gi)].map((m) => m[1] ?? "")
+    );
+    plans.push({ family: display, blocks, files, urls });
+  }
+  return { plans, conflicts };
+}
+async function fontsourceCatalogue(deps) {
+  const body = await deps.fetchJson(`${FONTSOURCE_API}/fonts`).catch(() => null);
+  if (!Array.isArray(body)) return [];
+  return body.map((entry) => typeof entry === "object" && entry !== null ? entry.family : null).filter((family) => typeof family === "string");
+}
 function parseWeightAxis(spec) {
   const axis = spec.match(/wght@([^&]+)/i)?.[1] ?? "";
   const weights = /* @__PURE__ */ new Set();
@@ -21128,25 +21494,132 @@ async function checkFontRequests(requests, fetchCss) {
   }
   return results;
 }
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "arial",
+  "helvetica",
+  "georgia",
+  "times",
+  "courier",
+  "inherit",
+  "initial",
+  "unset"
+]);
+function stripCssComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " "));
+}
+function normalizeFamily(raw) {
+  return raw.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
+}
+function fontFaceFamilies(css) {
+  const out = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const family = (rule[1] ?? "").match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (family) out.add(normalizeFamily(family));
+  }
+  return out;
+}
+function declaredWeights(body) {
+  const spec = (body.match(/font-weight\s*:\s*([^;}]+)/i)?.[1] ?? "").match(/\d{3}/g) ?? [];
+  if (spec.length !== 2) return spec.map(Number);
+  const range = [];
+  for (let w = Number(spec[0]); w <= Number(spec[1]); w += 100) range.push(w);
+  return range;
+}
+function selfHostedWeights(css, family) {
+  const target = normalizeFamily(family);
+  const weights = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target) continue;
+    for (const weight of declaredWeights(body)) weights.add(weight);
+  }
+  return [...weights].sort((a, b) => a - b);
+}
+function fontsourceFamilies(css) {
+  const out = /* @__PURE__ */ new Set();
+  for (const imported of stripCssComments(css).matchAll(/@fontsource(-variable)?\/([\w-]+)/gi)) {
+    const slug = imported[2];
+    if (!slug) continue;
+    out.add(`${slug.replaceAll("-", " ")}${imported[1] ? " variable" : ""}`.toLowerCase());
+  }
+  return out;
+}
+function asAuthored(css, normalized) {
+  const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const text2 = stripCssComments(css);
+  return text2.match(new RegExp(`["']${escaped}["']`, "i"))?.[0]?.slice(1, -1) ?? text2.match(new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i"))?.[0] ?? normalized;
+}
+function unresolvedBrandFamilies(css) {
+  const declared = [...parseBrandTokens(css, "").fonts].filter((family) => !GENERIC_FAMILIES.has(family));
+  const loaded = fontFaceFamilies(css);
+  for (const request of googleFontRequests(stripCssComments(css))) loaded.add(normalizeFamily(request.family));
+  return declared.filter((family) => !loaded.has(family)).map((family) => asAuthored(css, family));
+}
+function stripFontFaceBlocks(source, family) {
+  const target = normalizeFamily(family);
+  const ranges = [];
+  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{[^}]*\}/gi)) {
+    const declared = rule[0].match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (declared && normalizeFamily(declared) === target && rule.index !== void 0) {
+      ranges.push([rule.index, rule.index + rule[0].length]);
+    }
+  }
+  let out = source;
+  for (const [start, end] of ranges.reverse()) out = `${out.slice(0, start)}${out.slice(end)}`;
+  return out.replace(/\n{3,}/g, "\n\n");
+}
+function upsertFontFaceCss(css, family, block) {
+  const out = stripFontFaceBlocks(css, family);
+  const themeAt = stripCssComments(out).search(/@theme\b/);
+  if (themeAt < 0) return `${out.trimEnd()}
+
+${block}
+`;
+  const head = out.slice(0, themeAt).trimEnd();
+  const tail = out.slice(themeAt);
+  return head ? `${head}
+
+${block}
+
+${tail}` : `${block}
+
+${tail}`;
+}
 
 // src/commands/brand/fonts.ts
-var GLOBAL_CSS = path.join("src", "styles", "global.css");
-var FONTS_DIR = path.join("src", "brand", "fonts");
+var GLOBAL_CSS = path2.join("src", "styles", "global.css");
+var FONTS_DIR = path2.join("src", "brand", "fonts");
 var DEFAULT_SUBSETS = "latin";
 var BROWSER_UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0 Safari/537.36";
 registerSchema({
   command: "brand.fonts.check",
-  description: "Start here when a brand's fonts are 'confirmed' but nobody verified it. Asks Google Fonts what it ACTUALLY serves for every family/weight src/styles/global.css requests, and reports any the brand promises but Google will not serve.",
+  description: "Start here when a brand's fonts are 'confirmed' but nobody verified it. Fails if any --font-* family in src/styles/global.css has nothing loading it (no @font-face, no Google import) \u2014 the silent fallback that also fails the client's verify \u2014 then asks Google Fonts what it ACTUALLY serves for every family/weight the stylesheet requests.",
+  args: {}
+});
+registerSchema({
+  command: "brand.fonts.adopt",
+  description: "Move brand faces a page already self-hosts into src/styles/global.css, so every page loads them rather than only the page that declared them. Use when `check` reports a family as not loaded but its files are already in src/brand/fonts/. Never downloads: re-fetching would hand that page a different build of the same face.",
   args: {}
 });
 registerSchema({
   command: "brand.fonts.fetch",
-  description: "Download a Google font into src/brand/fonts/ so the brand stops depending on a third party at page load, and print the @font-face block to paste above @theme in src/styles/global.css.",
+  description: "Download a font into src/brand/fonts/ so the brand stops depending on a third party at page load, and write its @font-face into src/styles/global.css above @theme. Resolves against Google Fonts first, then Fontsource \u2014 which carries ~2000 open-licence families Google does not, so a name Google 400s is often still fetchable. Idempotent: re-running replaces that family's faces rather than stacking duplicates.",
   args: {
     family: { type: "string", description: 'Font family, e.g. "DM Sans"', required: true },
     weights: {
       type: "string",
-      description: "Comma-separated weights (default: what global.css requests, else 400)",
+      description: "Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)",
       required: false
     },
     subsets: {
@@ -21161,39 +21634,169 @@ function fail(code, message, fix) {
   process.exit(2);
 }
 var REQUEST_TIMEOUT_MS = 15e3;
-async function fetchGoogleCss(url) {
+async function fetchJson(url) {
+  const res = await fetch(url, {
+    headers: { "User-Agent": BROWSER_UA },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`Fontsource answered ${res.status}`);
+  return await res.json();
+}
+async function lookupGoogleCss(url) {
   try {
     const res = await fetch(url, {
       headers: { "User-Agent": BROWSER_UA },
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
     });
-    if (!res.ok) return null;
-    return await res.text();
+    if (res.ok) return { status: "served", css: await res.text() };
+    return { status: res.status === 400 ? "absent" : "unreachable" };
   } catch {
-    return null;
+    return { status: "unreachable" };
+  }
+}
+var fetchGoogleCss = async (url) => {
+  const got = await lookupGoogleCss(url);
+  return got.status === "served" ? got.css : null;
+};
+var WIRING_HINT = {
+  written: (family) => `Wrote the @font-face for "${family}" into ${GLOBAL_CSS}, above @theme. Remove "${family}" from the Google @import if one is still there, so the page stops fetching it at load.`,
+  // Told apart from "no stylesheet" on purpose: they used to share one hint, so
+  // an idempotent re-run instructed the agent to paste a block that was already
+  // in the file, and doing as it was told duplicated the face.
+  "already-wired": (family) => `${GLOBAL_CSS} already loads exactly these faces for "${family}" \u2014 nothing to change.`,
+  "no-stylesheet": () => `No ${GLOBAL_CSS} to write to \u2014 paste the \`fontFace\` block above the @theme block once the stylesheet exists, or the files just downloaded will never load.`
+};
+var PROVIDER_DEPS = { lookupGoogleCss, fetchJson };
+var PROVIDER_LABEL = { google: "Google Fonts", fontsource: "Fontsource" };
+function fetchHints({
+  family,
+  downloadedWeights,
+  incomplete,
+  wiring,
+  provider
+}) {
+  return [
+    WIRING_HINT[wiring](family),
+    `Record the exact weights (${downloadedWeights.join(", ")}) in src/brand/BRAND.md \u2014 a weight listed there but not downloaded renders as a synthesized fallback.`,
+    ...incomplete.length > 0 ? [
+      // The remedy is provider-specific: only a Google family has an @import
+      // to fall back on, and telling an agent to keep one for a Fontsource
+      // family sends it to write an import Google will 400.
+      provider === "google" ? `PARTIAL: ${incomplete.join(", ")} did not download and is NOT in the \`fontFace\` block. Keep "${family}" in the Google @import for those weights, or re-run \`baker brand fonts fetch "${family}" --weights ${incomplete.join(",")}\`.` : `PARTIAL: ${incomplete.join(", ")} did not download and is NOT in the \`fontFace\` block. ${PROVIDER_LABEL[provider]} does not serve them, so re-run \`baker brand fonts fetch "${family}" --weights ${downloadedWeights.join(",")}\` and record only those weights in src/brand/BRAND.md.`
+    ] : [],
+    `Licensing: ${PROVIDER_LABEL[provider]} carries open-licensed families, which are safe to self-host. A client's own commercial face is not \u2014 confirm before re-hosting one.`
+  ];
+}
+async function wireFontFaceIntoStylesheet(css, family, fontFace) {
+  if (!css) return "no-stylesheet";
+  const wired = upsertFontFaceCss(css, family, fontFace);
+  if (wired === css) return "already-wired";
+  await writeFile(path2.resolve(process.cwd(), GLOBAL_CSS), wired);
+  return "written";
+}
+function failResolution(family, weights, outcome) {
+  if (outcome.reason === "unreachable") {
+    return fail(
+      "CATALOGUE_UNREACHABLE",
+      `Could not reach ${PROVIDER_LABEL[outcome.provider]} to ask about "${family}".`,
+      {
+        action: "Run the same command again.",
+        explanation: `${PROVIDER_LABEL[outcome.provider]} did not answer, which is not the same as not having the family \u2014 so nothing was concluded from it. Guessing either way would self-host the wrong build, or report a real family as missing.`,
+        provider: outcome.provider
+      }
+    );
+  }
+  if (outcome.reason === "ambiguous-subsets") {
+    return fail(
+      "SUBSET_AMBIGUOUS",
+      `${PROVIDER_LABEL[outcome.provider]} serves "${family}" in several subsets but reports no unicode-range to tell them apart.`,
+      {
+        action: `Retry with a single --subsets value, e.g. --subsets ${outcome.available[0] ?? "latin"}.`,
+        explanation: "Two @font-face rules with the same family, style and weight and no unicode-range both claim every character, so the last one silently wins and the other file is downloaded and never read.",
+        available: outcome.available
+      }
+    );
+  }
+  if (outcome.reason === "subset") {
+    return fail("SUBSET_NOT_SERVED", `${PROVIDER_LABEL[outcome.provider]} has "${family}", but not in that subset.`, {
+      action: `Retry with --subsets set to one it serves: ${outcome.available.join(",")}.`,
+      explanation: "A family is split into unicode subsets and not every family ships every one. The weights you asked for are fine \u2014 only the subset is wrong.",
+      available: outcome.available
+    });
+  }
+  if (outcome.reason === "weight") {
+    return fail(
+      "FONT_NOT_SERVED",
+      `${PROVIDER_LABEL[outcome.provider]} has "${family}", but not at weight ${weights.join("/")}.`,
+      {
+        action: `Retry with --weights set to one of these: ${outcome.available.join(",")}.`,
+        explanation: "The family exists; the weight you asked for is not one it ships.",
+        served: outcome.available
+      }
+    );
+  }
+  return failUnknownFamily(family);
+}
+async function failUnknownFamily(family) {
+  const didYouMean = suggestFamilies(family, await fontsourceCatalogue(PROVIDER_DEPS));
+  return fail("FONT_NOT_SERVED", `No font catalogue carries a family called "${family}".`, {
+    action: didYouMean.length ? `Did you mean one of these? ${didYouMean.join(", ")}. Retry with the exact name, and update the --font-* token in ${GLOBAL_CSS} to match whichever you pick.` : `Check the exact spelling, then retry. If it is a commercial typeface, add the file to ${FONTS_DIR} and write the @font-face by hand \u2014 it cannot be downloaded.`,
+    explanation: `Tried ${FONT_PROVIDERS.join(" then ")}. Family names are case- and space-sensitive in every catalogue.`,
+    tried: [...FONT_PROVIDERS],
+    ...didYouMean.length ? { didYouMean } : {}
+  });
+}
+async function listFontFiles() {
+  try {
+    const entries = await readdir(path2.resolve(process.cwd(), FONTS_DIR), { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
   }
 }
 async function readGlobalCss() {
   try {
-    return await readFile(path.resolve(process.cwd(), GLOBAL_CSS), "utf8");
+    return await readFile2(path2.resolve(process.cwd(), GLOBAL_CSS), "utf8");
   } catch {
     return "";
   }
 }
+async function unresolvedAction(css, unresolved) {
+  const { plans } = planFontAdoption(await astroSources(), unresolved);
+  if (plans.length > 0) {
+    const names = plans.map((p) => `"${p.family}"`).join(", ");
+    return `Run \`baker brand fonts adopt\` \u2014 ${names} is already self-hosted by ${plans[0]?.files.join(", ")}, so it only needs moving into ${GLOBAL_CSS} to load on every page. Do NOT fetch it: that downloads a different build of the same face.`;
+  }
+  const viaFontsource = [...fontsourceFamilies(css)];
+  const stranded = unresolved.filter((family) => viaFontsource.includes(family.toLowerCase()));
+  if (stranded.length > 0) {
+    return `Run \`baker brand fonts fetch "${stranded[0]}"\` to self-host it. Its only provider is an @fontsource import, and that package does not survive a workspace sync \u2014 the import is left pointing at nothing, which fails the build before the font check even runs.`;
+  }
+  return `Run \`baker brand fonts fetch "${unresolved[0]}"\` to self-host it, which writes the @font-face for you. For a face no catalogue carries, add an @font-face pointing at a file in ${FONTS_DIR}.`;
+}
 var fontsCheckCommand = defineCommand93({
   meta: {
     name: "check",
-    description: "Verify the brand's fonts really exist. For every family/weight src/styles/global.css requests from Google Fonts, ask Google what it actually serves and report anything missing \u2014 a weight nobody serves renders as a synthesized fallback and looks off-brand everywhere."
+    description: "Verify the brand's fonts really exist. First: every --font-* family in src/styles/global.css must be provided by an @font-face or a Google import, or it renders as a fallback on every page. Then, for families requested from Google, ask Google what it actually serves \u2014 a weight nobody serves is silently synthesized."
   },
   async run() {
     const css = await readGlobalCss();
     const requests = googleFontRequests(css);
+    const unresolved = unresolvedBrandFamilies(css);
+    if (unresolved.length > 0) {
+      fail("FONT_NOT_LOADED", `Nothing loads ${unresolved.map((f) => `"${f}"`).join(", ")} in ${GLOBAL_CSS}.`, {
+        action: await unresolvedAction(css, unresolved),
+        explanation: "The family is declared as a brand font but no @font-face and no Google import provides it, so every page silently renders a fallback. The client's verify fails on this too.",
+        unresolved
+      });
+    }
     if (requests.length === 0) {
       writeJson({
         ok: true,
         data: { families: [], selfHosted: true },
         hints: [
-          `No Google Fonts requested in ${GLOBAL_CSS}. If the brand self-hosts, the offline validator already checks those files; nothing to verify against Google.`
+          `No Google Fonts requested in ${GLOBAL_CSS}, and every brand face is provided by an @font-face \u2014 nothing to verify against Google.`
         ]
       });
       return;
@@ -21227,11 +21830,14 @@ var fontsCheckCommand = defineCommand93({
 var fontsFetchCommand = defineCommand93({
   meta: {
     name: "fetch",
-    description: "Download a Google font into src/brand/fonts/ and print the @font-face block to paste above @theme in src/styles/global.css. Use when a brand font should be self-hosted rather than requested from Google on every page load."
+    description: "Download a font from Google Fonts or Fontsource into src/brand/fonts/ and write its @font-face into src/styles/global.css above @theme, so the family actually loads. Use when a brand font should be self-hosted rather than requested from a third party on every page load."
   },
   args: {
     family: { type: "positional", required: true, description: 'Font family, e.g. "DM Sans"' },
-    weights: { type: "string", description: "Comma-separated weights (default: what global.css requests, else 400)" },
+    weights: {
+      type: "string",
+      description: "Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)"
+    },
     subsets: { type: "string", description: `Comma-separated unicode subsets (default: ${DEFAULT_SUBSETS})` }
   },
   async run({ args }) {
@@ -21239,38 +21845,18 @@ var fontsFetchCommand = defineCommand93({
     if (!family) fail("INVALID_FAMILY", 'Pass a font family, e.g. `baker brand fonts fetch "DM Sans"`.');
     const css = await readGlobalCss();
     const declared = googleFontRequests(css).find((r) => r.family.toLowerCase() === family.toLowerCase());
-    const weights = resolveFetchWeights(args.weights, declared?.weights);
+    const provided = declared?.weights.length ? declared.weights : selfHostedWeights(css, family);
+    const weights = resolveFetchWeights(args.weights, provided);
     if (weights.length === 0) {
       fail("INVALID_WEIGHTS", `"${args.weights}" has no usable weight \u2014 pass whole hundreds, e.g. --weights 400,700.`);
     }
     const wanted = new Set(
       String(args.subsets ?? DEFAULT_SUBSETS).split(",").map((s) => s.trim()).filter(Boolean)
     );
-    const servedCss = await fetchGoogleCss(googleFontCssUrl(family, weights));
-    if (servedCss === null) {
-      const [diagnosis] = await checkFontRequests([{ family, weights }], fetchGoogleCss);
-      const served = diagnosis?.served ?? [];
-      fail(
-        "FONT_NOT_SERVED",
-        served.length === 0 ? `Google Fonts has no family called "${family}".` : `"${family}" exists on Google Fonts but not at weight ${weights.join("/")}.`,
-        served.length === 0 ? {
-          action: "Check the exact family name at fonts.google.com, then retry.",
-          explanation: "Family names are case- and space-sensitive in the Google Fonts API."
-        } : {
-          action: `Retry with --weights set to one of these: ${served.join(",")}.`,
-          explanation: "Google rejects the whole request when one requested weight does not exist.",
-          served
-        }
-      );
-    }
-    const faces = parseGoogleFontFaces(servedCss).filter((f) => wanted.has(f.subset));
-    if (faces.length === 0) {
-      fail("SUBSET_NOT_SERVED", `"${family}" has no ${[...wanted].join("/")} subset.`, {
-        action: `Retry with --subsets set to one Google actually serves for this family.`,
-        explanation: "Google splits each family into unicode subsets; not every family ships every subset."
-      });
-    }
-    const fontsDir = path.resolve(process.cwd(), FONTS_DIR);
+    const resolved = await resolveBrandFaces(family, weights, [...wanted], PROVIDER_DEPS);
+    if (!resolved.ok) return failResolution(family, weights, resolved);
+    const faces = resolved.faces;
+    const fontsDir = path2.resolve(process.cwd(), FONTS_DIR);
     await mkdir(fontsDir, { recursive: true });
     const downloaded = [];
     for (const face of faces) {
@@ -21279,7 +21865,7 @@ var fontsFetchCommand = defineCommand93({
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
       });
       if (!res.ok) continue;
-      await writeFile(path.join(fontsDir, fontFileName(face)), Buffer.from(await res.arrayBuffer()));
+      await writeFile(path2.join(fontsDir, fontFileName(face)), Buffer.from(await res.arrayBuffer()));
       downloaded.push(face);
     }
     const written = downloaded.map(fontFileName);
@@ -21292,16 +21878,115 @@ var fontsFetchCommand = defineCommand93({
     const fontFace = renderFontFaceCss(downloaded);
     const downloadedWeights = [...new Set(downloaded.map((f) => f.weight))].sort((a, b) => a - b);
     const incomplete = weights.filter((w) => !downloadedWeights.includes(w));
+    const wiring = await wireFontFaceIntoStylesheet(css, family, fontFace);
     writeJson({
       ok: true,
-      data: { family, weights: downloadedWeights, files: written, fontFace },
+      data: {
+        family,
+        provider: resolved.provider,
+        weights: downloadedWeights,
+        files: written,
+        fontFace,
+        stylesheet: wiring
+      },
+      hints: fetchHints({ family, downloadedWeights, incomplete, wiring, provider: resolved.provider })
+    });
+  }
+});
+async function astroSources() {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir("src", { recursive: true, withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".astro")) continue;
+    const file = path2.posix.join(entry.parentPath ?? "src", entry.name);
+    try {
+      out.push({ path: file, source: await readFile2(file, "utf8") });
+    } catch {
+    }
+  }
+  return out;
+}
+var fontsAdoptCommand = defineCommand93({
+  meta: {
+    name: "adopt",
+    description: "Move brand faces a page already self-hosts into src/styles/global.css, so every page loads them instead of just that one. Use when `check` reports a family as not loaded but the font files are already in src/brand/fonts/ \u2014 downloading it again would hand that page a different build of the same face."
+  },
+  async run() {
+    const css = await readGlobalCss();
+    if (!css) fail("NO_STYLESHEET", `There is no ${GLOBAL_CSS} to adopt faces into.`);
+    const unresolved = unresolvedBrandFamilies(css);
+    if (unresolved.length === 0) {
+      writeJson({
+        ok: true,
+        data: { adopted: [], conflicts: [] },
+        hints: [`Every --font-* family in ${GLOBAL_CSS} is already loaded by it \u2014 nothing to adopt.`]
+      });
+      return;
+    }
+    const { plans, conflicts } = planFontAdoption(await astroSources(), unresolved);
+    const available = new Set(await listFontFiles());
+    const adopted = [];
+    const skipped = [];
+    let next = css;
+    for (const plan of plans) {
+      const missing = missingFontFiles(plan.urls, available);
+      if (missing.length > 0) {
+        skipped.push({ family: plan.family, reason: `${missing.join(", ")} is not in ${FONTS_DIR}` });
+        continue;
+      }
+      next = upsertFontFaceCss(next, plan.family, plan.blocks.join("\n"));
+      adopted.push({
+        family: plan.family,
+        files: plan.files,
+        weights: plan.blocks.map((b) => b.match(/font-weight\s*:\s*([^;]+)/i)?.[1]?.trim() ?? "400")
+      });
+    }
+    if (adopted.length === 0) {
+      if (conflicts.length > 0) {
+        fail(
+          "ADOPTION_CONFLICT",
+          `${conflicts.map((c) => `"${c.family}" is declared differently in ${c.files.join(" and ")}`).join("; ")}.`,
+          {
+            action: "Make the declarations match \u2014 same weights, same files \u2014 then re-run. Pick the one whose page renders correctly.",
+            explanation: "One global scope holds one mapping per family, so adopting would silently repaint whichever page lost.",
+            conflicts
+          }
+        );
+      }
+      if (skipped.length > 0) {
+        fail("FONT_FILE_MISSING", `${skipped.map((s) => `${s.family} \u2014 ${s.reason}`).join("; ")}.`, {
+          action: `Add the missing file to ${FONTS_DIR}, or fix the src: url() in the page that declares it, then re-run.`,
+          explanation: "The page declares the face but points at a file that is not in the repo, so the rule renders as a fallback. Moving it into the stylesheet would spread that fallback to every page.",
+          skipped
+        });
+      }
+      fail("NOTHING_TO_ADOPT", `No page declares a face for ${unresolved.map((f) => `"${f}"`).join(", ")}.`, {
+        action: `Self-host it instead: \`baker brand fonts fetch "${unresolved[0]}"\`.`,
+        explanation: "Adopting only moves faces the repo already ships; it never downloads one."
+      });
+    }
+    await writeFile(path2.resolve(process.cwd(), GLOBAL_CSS), next);
+    for (const plan of plans.filter((p) => adopted.some((a) => a.family === p.family))) {
+      for (const file of plan.files) {
+        const source = await readFile2(file, "utf8");
+        await writeFile(file, stripFontFaceBlocks(source, plan.family));
+      }
+    }
+    writeJson({
+      ok: true,
+      data: { adopted, conflicts, skipped },
       hints: [
-        `Paste the \`fontFace\` block ABOVE the @theme block in ${GLOBAL_CSS}, then remove "${family}" from the Google @import so the page stops fetching it at load.`,
-        `Record the exact weights (${downloadedWeights.join(", ")}) in src/brand/BRAND.md \u2014 a weight listed there but not downloaded renders as a synthesized fallback.`,
-        ...incomplete.length > 0 ? [
-          `PARTIAL: ${incomplete.join(", ")} did not download and is NOT in the \`fontFace\` block. Keep "${family}" in the Google @import for those weights, or re-run \`baker brand fonts fetch "${family}" --weights ${incomplete.join(",")}\`.`
+        `Moved ${adopted.map((a) => `"${a.family}" (${a.weights.join("/")})`).join(", ")} into ${GLOBAL_CSS} and removed the page copies, so every page loads them \u2014 not just the one that declared them.`,
+        ...conflicts.length > 0 ? [
+          `CONFLICT: ${conflicts.map((c) => `"${c.family}" is declared differently in ${c.files.join(" and ")}`).join("; ")}. One global scope can hold only one mapping, so pick which files the family should use and make the declarations match before re-running.`
         ] : [],
-        "Licensing: Google Fonts are open-licensed and safe to self-host. A client's own commercial face is not \u2014 confirm before re-hosting one."
+        ...skipped.length > 0 ? [`SKIPPED: ${skipped.map((s) => `${s.family} \u2014 ${s.reason}`).join("; ")}.`] : [],
+        `Run \`baker brand fonts check\` to confirm nothing is left unresolved.`
       ]
     });
   }
@@ -21311,15 +21996,17 @@ var fontsCommand = defineCommand93({
     name: "fonts",
     description: `Verify and self-host the brand's typefaces.
 
-Start here: \`baker brand fonts check\` \u2014 confirms the fonts the brand claims are really served.
+Start here: \`baker brand fonts check\` \u2014 confirms the fonts the brand claims really load.
 
 Subcommands:
-  baker brand fonts check           \u2014 ask Google what it actually serves for every family/weight global.css requests
-  baker brand fonts fetch <family>  \u2014 download a family into src/brand/fonts/ and print its @font-face block`
+  baker brand fonts check           \u2014 fail if any --font-* family has nothing loading it, then ask Google what it actually serves for the ones global.css requests
+  baker brand fonts fetch <family>  \u2014 download a family into src/brand/fonts/ and wire its @font-face into src/styles/global.css
+  baker brand fonts adopt           \u2014 move faces a page already self-hosts into global.css, so every page loads them. Try this BEFORE fetch when the font files are already in src/brand/fonts/`
   },
   subCommands: {
     check: fontsCheckCommand,
-    fetch: fontsFetchCommand
+    fetch: fontsFetchCommand,
+    adopt: fontsAdoptCommand
   }
 });
 
@@ -21357,8 +22044,8 @@ var catalogCommand = defineCommand95({
 });
 
 // src/commands/canvas/critique.ts
-import { readFile as readFile2 } from "fs/promises";
-import path2 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
 import { defineCommand as defineCommand96 } from "citty";
 
 // src/engine/scaffold/lib/critique.ts
@@ -21486,8 +22173,8 @@ var critiqueCommand = defineCommand96({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args }) {
-    const filePath = path2.resolve(String(args.file));
-    const raw = await readFile2(filePath, "utf8");
+    const filePath = path3.resolve(String(args.file));
+    const raw = await readFile3(filePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -21518,8 +22205,8 @@ var critiqueCommand = defineCommand96({
 
 // src/commands/canvas/inspect.ts
 import { execFile } from "child_process";
-import { readdir, readFile as readFile3, stat } from "fs/promises";
-import path3 from "path";
+import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
+import path4 from "path";
 import { promisify } from "util";
 import { defineCommand as defineCommand97 } from "citty";
 var execFileAsync = promisify(execFile);
@@ -21537,7 +22224,7 @@ var inspectCommand = defineCommand97({
     }
   },
   async run({ args }) {
-    const outputsDir = path3.resolve(String(args["outputs-dir"] ?? "canvas"));
+    const outputsDir = path4.resolve(String(args["outputs-dir"] ?? "canvas"));
     const runArg = String(args.run);
     const runDir = await resolveRunDir(runArg, outputsDir);
     const manifest = await loadManifest(runDir);
@@ -21549,7 +22236,7 @@ var inspectCommand = defineCommand97({
     }
     const summary = {
       ok: true,
-      run_id: manifest.run_id ?? path3.basename(runDir),
+      run_id: manifest.run_id ?? path4.basename(runDir),
       run_dir: runDir,
       stats: manifest.stats ?? null,
       output: manifest.output ?? null,
@@ -21562,20 +22249,20 @@ var inspectCommand = defineCommand97({
   }
 });
 async function resolveRunDir(run, outputsDir) {
-  if (path3.isAbsolute(run)) {
+  if (path4.isAbsolute(run)) {
     const s2 = await stat(run).catch(() => null);
     if (s2?.isDirectory()) return run;
     throw new Error(`inspect: ${run} is not a directory`);
   }
-  const candidate = path3.join(outputsDir, run);
+  const candidate = path4.join(outputsDir, run);
   const s = await stat(candidate).catch(() => null);
   if (s?.isDirectory()) return candidate;
   throw new Error(`inspect: no run directory at ${candidate}`);
 }
 async function loadManifest(runDir) {
-  const manifestPath = path3.join(runDir, "manifest.json");
+  const manifestPath = path4.join(runDir, "manifest.json");
   try {
-    const raw = await readFile3(manifestPath, "utf-8");
+    const raw = await readFile4(manifestPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -21583,9 +22270,9 @@ async function loadManifest(runDir) {
 }
 async function listRunFiles(runDir) {
   const out = [];
-  const names = await readdir(runDir);
+  const names = await readdir2(runDir);
   for (const name of names) {
-    const abs = path3.join(runDir, name);
+    const abs = path4.join(runDir, name);
     const s = await stat(abs).catch(() => null);
     if (!s?.isFile()) continue;
     out.push({ name, path: abs, size: s.size });
@@ -21630,58 +22317,58 @@ async function probeDuration(filePath) {
 }
 
 // src/commands/canvas/rerun.ts
-import path15 from "path";
+import path16 from "path";
 import { defineCommand as defineCommand99 } from "citty";
 
 // src/commands/canvas/run.ts
-import { readFile as readFile10 } from "fs/promises";
-import path14 from "path";
+import { readFile as readFile11 } from "fs/promises";
+import path15 from "path";
 import { defineCommand as defineCommand98 } from "citty";
 
 // src/commands/canvas/normalize-paths.ts
 import { existsSync as existsSync3, realpathSync } from "fs";
 import { writeFile as writeFile2 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 function findWorkspaceRoot(startDir, exists = existsSync3, maxDepth = 12) {
-  let dir = path4.resolve(startDir);
+  let dir = path5.resolve(startDir);
   for (let i = 0; i < maxDepth; i++) {
-    if (exists(path4.join(dir, "package.json"))) return dir;
-    const parent = path4.dirname(dir);
+    if (exists(path5.join(dir, "package.json"))) return dir;
+    const parent = path5.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function canonicalize(target) {
-  const abs = path4.resolve(target);
+  const abs = path5.resolve(target);
   let dir = abs;
   for (; ; ) {
     try {
       const real = realpathSync(dir);
-      return dir === abs ? real : path4.join(real, path4.relative(dir, abs));
+      return dir === abs ? real : path5.join(real, path5.relative(dir, abs));
     } catch {
-      const parent = path4.dirname(dir);
+      const parent = path5.dirname(dir);
       if (parent === dir) return abs;
       dir = parent;
     }
   }
 }
 function isInside(root, target) {
-  const rel = path4.relative(root, target);
-  return rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel);
+  const rel = path5.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
 }
 function toCanvasRelative(canvasDir, target) {
-  return path4.relative(canvasDir, target).split(path4.sep).join("/");
+  return path5.relative(canvasDir, target).split(path5.sep).join("/");
 }
 var RUNTIME_WORKSPACE_ROOT = "/home/user/repo";
 function rewriteTarget(value, workspaceRoot) {
   if (typeof value !== "string" || value.length === 0) return null;
-  if (value.includes("[TODO") || looksLikeHttpUrl(value) || !path4.isAbsolute(value)) return null;
+  if (value.includes("[TODO") || looksLikeHttpUrl(value) || !path5.isAbsolute(value)) return null;
   const target = canonicalize(value);
   if (isInside(workspaceRoot, target)) return target;
-  const fromRuntime = path4.relative(RUNTIME_WORKSPACE_ROOT, path4.normalize(value));
-  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path4.isAbsolute(fromRuntime)) {
-    return path4.join(workspaceRoot, fromRuntime);
+  const fromRuntime = path5.relative(RUNTIME_WORKSPACE_ROOT, path5.normalize(value));
+  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path5.isAbsolute(fromRuntime)) {
+    return path5.join(workspaceRoot, fromRuntime);
   }
   return null;
 }
@@ -21709,7 +22396,7 @@ function normalizeAbsoluteCanvasPaths(canvas, canvasDir, workspaceRoot) {
   return rewrites.length === 0 ? { canvas, rewrites } : { canvas: { ...canvas, nodes }, rewrites };
 }
 async function healAbsoluteCanvasPaths(filePath, canvas) {
-  const canvasDir = path4.dirname(filePath);
+  const canvasDir = path5.dirname(filePath);
   const workspaceRoot = findWorkspaceRoot(canvasDir);
   if (!workspaceRoot) return { canvas, rewrites: [], text: null };
   const normalized = normalizeAbsoluteCanvasPaths(canvas, canvasDir, workspaceRoot);
@@ -21740,7 +22427,7 @@ function unsuppliedPlaceholderAssets(canvas) {
 }
 
 // src/commands/canvas/resolve-paths.ts
-import path5 from "path";
+import path6 from "path";
 function resolveRelativeCanvasPaths(canvas, baseDir) {
   if (!canvas || typeof canvas !== "object") return canvas;
   const c = canvas;
@@ -21753,24 +22440,24 @@ function resolveNode(node, baseDir) {
   const params = n.params;
   if (!params || typeof params !== "object") return node;
   if (n.type === "ingest" && params.source === "path" && isResolvableRelative(params.path)) {
-    return { ...node, params: { ...params, path: path5.resolve(baseDir, params.path) } };
+    return { ...node, params: { ...params, path: path6.resolve(baseDir, params.path) } };
   }
   if (n.type === "hyperframe_render" && isResolvableRelative(params.composition)) {
-    return { ...node, params: { ...params, composition: path5.resolve(baseDir, params.composition) } };
+    return { ...node, params: { ...params, composition: path6.resolve(baseDir, params.composition) } };
   }
   return node;
 }
 function isResolvableRelative(value) {
-  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path5.isAbsolute(value);
+  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path6.isAbsolute(value);
 }
 
 // src/commands/canvas/source-version.ts
-import { readFile as readFile5 } from "fs/promises";
-import path7 from "path";
+import { readFile as readFile6 } from "fs/promises";
+import path8 from "path";
 
 // src/commands/canvas/scene-files.ts
-import { mkdir as mkdir2, readFile as readFile4, readdir as readdir2, rm, writeFile as writeFile3 } from "fs/promises";
-import path6 from "path";
+import { mkdir as mkdir2, readFile as readFile5, readdir as readdir3, rm, writeFile as writeFile3 } from "fs/promises";
+import path7 from "path";
 var SCENES_DIR = "scenes";
 var GLOBAL_PROMPT_FILE = "prompt.json";
 var REBUILD_FILE = "prompt.rebuild.json";
@@ -21787,42 +22474,42 @@ function splitBlueprint(blueprint) {
 }
 async function writeSceneFiles(outDir, blueprint) {
   const { global, scenes } = splitBlueprint(blueprint);
-  await writeFile3(path6.join(outDir, GLOBAL_PROMPT_FILE), `${JSON.stringify(global, null, 2)}
+  await writeFile3(path7.join(outDir, GLOBAL_PROMPT_FILE), `${JSON.stringify(global, null, 2)}
 `, "utf8");
-  const scenesDir = path6.join(outDir, SCENES_DIR);
+  const scenesDir = path7.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(path6.join(scenesDir, name), `${JSON.stringify(scenes[i], null, 2)}
+    await writeFile3(path7.join(scenesDir, name), `${JSON.stringify(scenes[i], null, 2)}
 `, "utf8");
   }
   for (const name of await listSceneFileNames(scenesDir)) {
-    if (!written.has(name)) await rm(path6.join(scenesDir, name), { force: true });
+    if (!written.has(name)) await rm(path7.join(scenesDir, name), { force: true });
   }
 }
 async function listSceneFileNames(scenesDir) {
   let entries;
   try {
-    entries = await readdir2(scenesDir);
+    entries = await readdir3(scenesDir);
   } catch {
     return [];
   }
   return entries.filter((n) => /^s\d+\.json$/.test(n)).sort(bySceneIndex);
 }
 async function listSceneFiles(creativeDir) {
-  const scenesDir = path6.join(creativeDir, SCENES_DIR);
-  return (await listSceneFileNames(scenesDir)).map((n) => path6.join(scenesDir, n));
+  const scenesDir = path7.join(creativeDir, SCENES_DIR);
+  return (await listSceneFileNames(scenesDir)).map((n) => path7.join(scenesDir, n));
 }
 async function reassembleBlueprint(creativeDir) {
   const files = await listSceneFiles(creativeDir);
   if (files.length === 0) return null;
-  const globalRaw = await readFile4(path6.join(creativeDir, GLOBAL_PROMPT_FILE), "utf8");
+  const globalRaw = await readFile5(path7.join(creativeDir, GLOBAL_PROMPT_FILE), "utf8");
   const global = JSON.parse(globalRaw);
   const scenes = [];
   for (const file of files) {
-    scenes.push(JSON.parse(await readFile4(file, "utf8")));
+    scenes.push(JSON.parse(await readFile5(file, "utf8")));
   }
   return { ...global, scenes };
 }
@@ -21836,15 +22523,15 @@ function bySceneIndex(a, b) {
 async function computeSourceSha(canvasPath) {
   let canvasBytes;
   try {
-    canvasBytes = await readFile5(canvasPath);
+    canvasBytes = await readFile6(canvasPath);
   } catch {
     return void 0;
   }
-  const canvasDir = path7.dirname(canvasPath);
-  const promptPath = path7.join(canvasDir, "prompt.json");
+  const canvasDir = path8.dirname(canvasPath);
+  const promptPath = path8.join(canvasDir, "prompt.json");
   let promptBytes;
   try {
-    promptBytes = await readFile5(promptPath);
+    promptBytes = await readFile6(promptPath);
   } catch {
     promptBytes = Buffer.alloc(0);
   }
@@ -21857,7 +22544,7 @@ async function computeSourceSha(canvasPath) {
   for (const sceneFile of await listSceneFiles(canvasDir)) {
     let sceneBytes;
     try {
-      sceneBytes = await readFile5(sceneFile);
+      sceneBytes = await readFile6(sceneFile);
     } catch {
       sceneBytes = Buffer.alloc(0);
     }
@@ -21867,8 +22554,8 @@ async function computeSourceSha(canvasPath) {
 }
 
 // src/commands/canvas/scene-projection.ts
-import { readFile as readFile6 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile7 } from "fs/promises";
+import path9 from "path";
 
 // src/engine/scaffold/video.ts
 import { toCardinal as nwAr } from "n2words/ar-SA";
@@ -25154,12 +25841,12 @@ function nonPromptParamsDiverge(live = {}, rebuilt = {}) {
   return false;
 }
 async function syncSceneNodeParams(canvas, canvasPath, log) {
-  const creativeDir = path8.dirname(canvasPath);
+  const creativeDir = path9.dirname(canvasPath);
   const blueprint = await reassembleBlueprint(creativeDir);
   if (!blueprint) return "not_applicable";
   let rebuildRaw;
   try {
-    rebuildRaw = await readFile6(path8.join(creativeDir, REBUILD_FILE), "utf8");
+    rebuildRaw = await readFile7(path9.join(creativeDir, REBUILD_FILE), "utf8");
   } catch {
     return "not_applicable";
   }
@@ -25200,7 +25887,7 @@ async function syncSceneNodeParams(canvas, canvasPath, log) {
 }
 
 // src/commands/canvas/style-projection.ts
-import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
 function findBlueprintProjection(canvas) {
   if (!canvas || typeof canvas !== "object") return null;
   const nodes = canvas.nodes;
@@ -25228,8 +25915,8 @@ function renderStyleProjectionFromValue(blueprint) {
 async function syncStyleProjection(canvas, log) {
   const pair = findBlueprintProjection(canvas);
   if (!pair) return "not_applicable";
-  const rendered = renderStyleProjection(await readFile7(pair.promptPath, "utf8"));
-  const current = await readFile7(pair.stylePath, "utf8").catch(() => null);
+  const rendered = renderStyleProjection(await readFile8(pair.promptPath, "utf8"));
+  const current = await readFile8(pair.stylePath, "utf8").catch(() => null);
   if (current === rendered) return "up_to_date";
   await writeFile4(pair.stylePath, rendered, "utf8");
   log(
@@ -25291,13 +25978,13 @@ ${body}` : header || body || compactJson(record);
 }
 
 // src/commands/canvas/run-record.ts
-import path9 from "path";
+import path10 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(path9.sep).join("/");
+  const normalized = filePath.split(path10.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;
@@ -25585,24 +26272,24 @@ var RunRecordPoster = class {
 
 // src/commands/canvas/run-retention.ts
 import { rm as rm2 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 function runDirsToPrune(entries, keep, currentRunId) {
   const runs = entries.filter((e) => /^r_[0-9A-Za-z]+$/.test(e) && e !== currentRunId).sort();
   if (keep <= 0) return runs;
   return runs.slice(0, Math.max(0, runs.length - keep));
 }
 async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
-  const { readdir: readdir9 } = await import("fs/promises");
+  const { readdir: readdir10 } = await import("fs/promises");
   let entries;
   try {
-    entries = await readdir9(outputsDir);
+    entries = await readdir10(outputsDir);
   } catch {
     return;
   }
   const toPrune = runDirsToPrune(entries, keep, currentRunId);
   if (toPrune.length === 0) return;
   for (const dir of toPrune) {
-    await rm2(path10.join(outputsDir, dir), { recursive: true, force: true }).catch(
+    await rm2(path11.join(outputsDir, dir), { recursive: true, force: true }).catch(
       (e) => log(`[prune   ] could not remove ${dir}: ${e.message}`)
     );
   }
@@ -25610,13 +26297,13 @@ async function pruneOldRuns(outputsDir, keep, currentRunId, log) {
 }
 
 // src/commands/canvas/dirty-marker.ts
-import { mkdir as mkdir3, readdir as readdir3, rm as rm3, writeFile as writeFile5 } from "fs/promises";
-import path11 from "path";
+import { mkdir as mkdir3, readdir as readdir4, rm as rm3, writeFile as writeFile5 } from "fs/promises";
+import path12 from "path";
 function creativeDirtyDir(base) {
-  return base ?? path11.resolve("canvas", ".dirty");
+  return base ?? path12.resolve("canvas", ".dirty");
 }
 function dirtyMarkerFile(slug, base) {
-  return path11.join(creativeDirtyDir(base), `${slug}.json`);
+  return path12.join(creativeDirtyDir(base), `${slug}.json`);
 }
 async function clearCreativeDirty(slug, base) {
   try {
@@ -25626,18 +26313,18 @@ async function clearCreativeDirty(slug, base) {
 }
 
 // src/commands/canvas/run-resume.ts
-import { mkdir as mkdir4, readFile as readFile8, rm as rm4, writeFile as writeFile6 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir4, readFile as readFile9, rm as rm4, writeFile as writeFile6 } from "fs/promises";
+import path13 from "path";
 function markerKey(canvasPath) {
   const slug = creativeSlugFromCanvasPath(canvasPath);
-  const identity = slug ?? path12.relative(process.cwd(), path12.resolve(canvasPath));
+  const identity = slug ?? path13.relative(process.cwd(), path13.resolve(canvasPath));
   return sha256Hex(Buffer.from(identity)).slice(0, 32);
 }
 function legacyMarkerKey(canvasPath) {
-  return sha256Hex(Buffer.from(path12.resolve(canvasPath))).slice(0, 32);
+  return sha256Hex(Buffer.from(path13.resolve(canvasPath))).slice(0, 32);
 }
 function markerFile(outputsDir, key) {
-  return path12.join(outputsDir, ".inflight", `${key}.json`);
+  return path13.join(outputsDir, ".inflight", `${key}.json`);
 }
 var REMOTE_ADOPT_STALE_MS = 12e4;
 function classifyRemoteRun(run, now) {
@@ -25673,7 +26360,7 @@ async function resolveRunId(opts) {
 async function readMarkerRunId(outputsDir, canvasPath) {
   for (const key of [markerKey(canvasPath), legacyMarkerKey(canvasPath)]) {
     try {
-      const raw = await readFile8(markerFile(outputsDir, key), "utf8");
+      const raw = await readFile9(markerFile(outputsDir, key), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.runId === "string" && parsed.runId.length > 0) return parsed.runId;
     } catch {
@@ -25684,8 +26371,8 @@ async function readMarkerRunId(outputsDir, canvasPath) {
 async function markRunInFlight(outputsDir, canvasPath, runId) {
   try {
     const file = markerFile(outputsDir, markerKey(canvasPath));
-    await mkdir4(path12.dirname(file), { recursive: true });
-    await writeFile6(file, JSON.stringify({ runId, canvasPath: path12.resolve(canvasPath), startedAt: Date.now() }));
+    await mkdir4(path13.dirname(file), { recursive: true });
+    await writeFile6(file, JSON.stringify({ runId, canvasPath: path13.resolve(canvasPath), startedAt: Date.now() }));
   } catch {
   }
 }
@@ -25699,8 +26386,8 @@ async function clearRunMarker(outputsDir, canvasPath) {
 }
 
 // src/commands/canvas/run-snapshot.ts
-import { mkdir as mkdir5, readdir as readdir4, readFile as readFile9, stat as stat2, writeFile as writeFile7 } from "fs/promises";
-import path13 from "path";
+import { mkdir as mkdir5, readdir as readdir5, readFile as readFile10, stat as stat2, writeFile as writeFile7 } from "fs/promises";
+import path14 from "path";
 var SNAPSHOT_SCHEMA = "baker-canvas-snapshot/1";
 var MAX_SNAPSHOT_FILE_BYTES = 32 * 1024 * 1024;
 var EXT_TO_MIME = {
@@ -25727,15 +26414,15 @@ var EXT_TO_MIME = {
   woff2: "font/woff2"
 };
 function mimeForFile(filePath) {
-  const ext = path13.extname(filePath).slice(1).toLowerCase();
+  const ext = path14.extname(filePath).slice(1).toLowerCase();
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
 function toPosix(p) {
-  return p.split(path13.sep).join("/");
+  return p.split(path14.sep).join("/");
 }
 function isInside2(dir, target) {
-  const rel = path13.relative(dir, target);
-  return !rel.startsWith("..") && !path13.isAbsolute(rel);
+  const rel = path14.relative(dir, target);
+  return !rel.startsWith("..") && !path14.isAbsolute(rel);
 }
 function localPathRefsFromCanvas(parsed) {
   const nodes = parsed?.nodes;
@@ -25760,24 +26447,24 @@ function isSnapshotablePath(value) {
 async function sourceRefsToSnapshot(canvasDir, parsed) {
   const refs = new Set(localPathRefsFromCanvas(parsed));
   for (const sceneFile of await listSceneFiles(canvasDir)) {
-    refs.add(toPosix(path13.relative(canvasDir, sceneFile)));
+    refs.add(toPosix(path14.relative(canvasDir, sceneFile)));
   }
   refs.add(REBUILD_FILE);
   return [...refs];
 }
 async function uploadRunSnapshot(client, opts) {
   try {
-    const canvasDir = path13.dirname(opts.canvasPath);
+    const canvasDir = path14.dirname(opts.canvasPath);
     const put = (bytes, mime) => putContentAddressed(client, bytes, mime, opts.signal);
     const canvasBytes = Buffer.from(opts.raw);
     const canvasUpload = await put(canvasBytes, "application/json");
     const files = [];
     const skipped = [];
     for (const refPath of await sourceRefsToSnapshot(canvasDir, opts.parsed)) {
-      const abs = path13.isAbsolute(refPath) ? refPath : path13.resolve(canvasDir, refPath);
+      const abs = path14.isAbsolute(refPath) ? refPath : path14.resolve(canvasDir, refPath);
       if (!isInside2(canvasDir, abs)) {
         skipped.push({
-          path: toPosix(path13.relative(canvasDir, abs)),
+          path: toPosix(path14.relative(canvasDir, abs)),
           reason: "outside the creative folder \u2014 read from the workspace on rerun"
         });
         continue;
@@ -25786,18 +26473,18 @@ async function uploadRunSnapshot(client, opts) {
       try {
         st = await stat2(abs);
       } catch {
-        skipped.push({ path: toPosix(path13.relative(canvasDir, abs)), reason: "missing" });
+        skipped.push({ path: toPosix(path14.relative(canvasDir, abs)), reason: "missing" });
         continue;
       }
       const fileList = st.isDirectory() ? await listFilesRecursive(abs) : [abs];
       for (const file of fileList) {
-        const rel = toPosix(path13.relative(canvasDir, file));
+        const rel = toPosix(path14.relative(canvasDir, file));
         const size = (await stat2(file)).size;
         if (size > MAX_SNAPSHOT_FILE_BYTES) {
           skipped.push({ path: rel, reason: `too large (${size} bytes)` });
           continue;
         }
-        const bytes = await readFile9(file);
+        const bytes = await readFile10(file);
         const upload = await put(bytes, mimeForFile(file));
         files.push({ path: rel, sha256: upload.sha256, url: upload.url });
       }
@@ -25806,7 +26493,7 @@ async function uploadRunSnapshot(client, opts) {
       schema: SNAPSHOT_SCHEMA,
       creativeSlug: opts.creativeSlug,
       canvasSha: canvasUpload.sha256,
-      canvas: { path: path13.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
+      canvas: { path: path14.basename(opts.canvasPath), sha256: canvasUpload.sha256, url: canvasUpload.url },
       files,
       skipped: skipped.length > 0 ? skipped : void 0
     };
@@ -25832,8 +26519,8 @@ async function putContentAddressed(client, bytes, mime, signal) {
   return { sha256, url: publicUrl };
 }
 async function listFilesRecursive(dir) {
-  const entries = await readdir4(dir, { recursive: true, withFileTypes: true });
-  return entries.filter((d) => d.isFile()).map((d) => path13.join(d.parentPath, d.name));
+  const entries = await readdir5(dir, { recursive: true, withFileTypes: true });
+  return entries.filter((d) => d.isFile()).map((d) => path14.join(d.parentPath, d.name));
 }
 var SnapshotConflictError = class extends Error {
   conflicts;
@@ -25845,19 +26532,19 @@ var SnapshotConflictError = class extends Error {
 };
 async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
   const entries = [manifest.canvas, ...manifest.files];
-  const resolvedTarget = path13.resolve(targetDir);
+  const resolvedTarget = path14.resolve(targetDir);
   const planned = [];
   const conflicts = [];
   const upToDate = [];
   for (const entry of entries) {
-    if (path13.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
+    if (path14.isAbsolute(entry.path) || entry.path.split("/").includes("..")) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const target = path13.resolve(resolvedTarget, entry.path);
-    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path13.sep)) {
+    const target = path14.resolve(resolvedTarget, entry.path);
+    if (target !== resolvedTarget && !target.startsWith(resolvedTarget + path14.sep)) {
       throw new Error(`snapshot entry escapes the creative directory: ${entry.path}`);
     }
-    const existing = await readFile9(target).catch(() => null);
+    const existing = await readFile10(target).catch(() => null);
     if (existing) {
       if (sha256Hex(existing) === entry.sha256) {
         upToDate.push(entry.path);
@@ -25879,11 +26566,11 @@ async function restoreRunSnapshot(manifest, targetDir, opts = {}) {
     if (sha256Hex(bytes) !== entry.sha256) {
       throw new Error(`snapshot download for ${entry.path} does not match its recorded sha256`);
     }
-    await mkdir5(path13.dirname(target), { recursive: true });
+    await mkdir5(path14.dirname(target), { recursive: true });
     await writeFile7(target, bytes);
     restored.push(entry.path);
   }
-  return { canvasPath: path13.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
+  return { canvasPath: path14.resolve(resolvedTarget, manifest.canvas.path), restored, upToDate };
 }
 
 // src/commands/canvas/run.ts
@@ -25963,8 +26650,8 @@ function resolveMaxCredits(...candidates) {
   return void 0;
 }
 async function executeCanvasRun(opts) {
-  const filePath = path14.resolve(opts.file);
-  const raw = await readFile10(filePath, "utf8");
+  const filePath = path15.resolve(opts.file);
+  const raw = await readFile11(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -25986,7 +26673,7 @@ ${describeRewrites(healed.rewrites)}
 `
     );
   }
-  parsed = resolveRelativeCanvasPaths(parsed, path14.dirname(filePath));
+  parsed = resolveRelativeCanvasPaths(parsed, path15.dirname(filePath));
   try {
     await syncStyleProjection(parsed, (line) => process.stderr.write(`${line}
 `));
@@ -26092,7 +26779,7 @@ ${describeRewrites(healed.rewrites)}
   const canvasSha = sha256Hex(Buffer.from(canvasText));
   const creativeSlug = creativeSlugFromCanvasPath(filePath) ?? void 0;
   const client = opts.record === false ? null : buildBackendClient();
-  const outputsDir = opts.outputsDir ? path14.resolve(opts.outputsDir) : path14.resolve("canvas");
+  const outputsDir = opts.outputsDir ? path15.resolve(opts.outputsDir) : path15.resolve("canvas");
   const { runId, resumed, source, concurrentRunId } = await resolveRunId({
     explicitRunId: opts.runId,
     fresh: opts.fresh === true,
@@ -26126,7 +26813,7 @@ ${describeRewrites(healed.rewrites)}
   const canvasSnapshotUrl = client && creativeSlug ? await uploadRunSnapshot(client, { canvasPath: filePath, raw: canvasText, creativeSlug, parsed }) ?? void 0 : void 0;
   const recordMeta = {
     creativeSlug,
-    canvasPath: path14.relative(process.cwd(), filePath) || void 0,
+    canvasPath: path15.relative(process.cwd(), filePath) || void 0,
     canvasSha,
     // The fingerprint the dashboard compares against the current source to flag
     // "edited since last render". Computed from the on-disk canvas.json +
@@ -26313,7 +27000,7 @@ var rerunCommand = defineCommand99({
     if (latest.canvasSha && manifest.canvasSha !== latest.canvasSha) {
       fail2("snapshot_mismatch", `snapshot manifest for run ${latest.runId} does not match its recorded canvas sha`);
     }
-    const targetDir = path15.resolve("src", "creatives", slug);
+    const targetDir = path16.resolve("src", "creatives", slug);
     let restoredCanvasPath;
     try {
       const restore = await restoreRunSnapshot(manifest, targetDir, { force: args["force-remote"] === true });
@@ -26362,8 +27049,8 @@ async function fetchManifest(url) {
 }
 
 // src/commands/canvas/scaffold-static-ad.ts
-import { access, mkdir as mkdir6, readFile as readFile12, writeFile as writeFile8 } from "fs/promises";
-import path19 from "path";
+import { access, mkdir as mkdir6, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
+import path20 from "path";
 import { defineCommand as defineCommand101 } from "citty";
 
 // src/engine/scaffold/staticAd.ts
@@ -26645,7 +27332,7 @@ function staticAdReport(input, elementsInput, opts) {
 }
 
 // src/commands/canvas/creative-definition.ts
-import path16 from "path";
+import path17 from "path";
 var PLATFORM_VALUES = ["meta", "google", "linkedin", "tiktok", "youtube", "x", "other"];
 var FORMAT_VALUES = ["1:1", "4:5", "9:16", "16:9", "1.91:1"];
 function titleFromSlug(slug) {
@@ -26693,16 +27380,16 @@ function buildCreativeDefinition(input) {
 }
 
 // src/commands/canvas/scaffold-static-ad-paths.ts
-import path17 from "path";
+import path18 from "path";
 function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
   const file = rawFile.trim();
   const imageIsUrl = /^https?:\/\//i.test(file);
-  const imageSource = imageIsUrl ? file : path17.resolve(cwd, file);
-  const outPath = out ? path17.resolve(cwd, out) : slug ? path17.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path17.join(cwd, "static-ad.canvas.json") : path17.join(path17.dirname(imageSource), "static-ad.canvas.json");
-  const blueprintPath = path17.join(path17.dirname(outPath), "prompt.json");
-  const creativeDir = slug ? path17.dirname(outPath) : null;
-  const definitionPath = creativeDir ? path17.join(creativeDir, "_definition.md") : null;
-  const referencesDir = creativeDir ? path17.join(creativeDir, "references") : null;
+  const imageSource = imageIsUrl ? file : path18.resolve(cwd, file);
+  const outPath = out ? path18.resolve(cwd, out) : slug ? path18.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path18.join(cwd, "static-ad.canvas.json") : path18.join(path18.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath = path18.join(path18.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path18.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path18.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path18.join(creativeDir, "references") : null;
   return { imageIsUrl, imageSource, outPath, blueprintPath, creativeDir, definitionPath, referencesDir };
 }
 var SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
@@ -26712,8 +27399,8 @@ function isValidScaffoldSlug(slug) {
 }
 
 // src/commands/canvas/sync-definition.ts
-import { readdir as readdir5, readFile as readFile11, stat as stat3 } from "fs/promises";
-import path18 from "path";
+import { readdir as readdir6, readFile as readFile12, stat as stat3 } from "fs/promises";
+import path19 from "path";
 import { defineCommand as defineCommand100 } from "citty";
 
 // src/commands/canvas/definition-graph.ts
@@ -26806,26 +27493,26 @@ async function syncCreativeDefinitionBestEffort(input) {
   }
 }
 async function resolveCanvasPath(inputPath) {
-  const resolved = path18.resolve(inputPath);
+  const resolved = path19.resolve(inputPath);
   let dir = resolved;
   try {
     if ((await stat3(resolved)).isFile()) {
       if (resolved.endsWith(".canvas.json")) return resolved;
-      dir = path18.dirname(resolved);
+      dir = path19.dirname(resolved);
     }
   } catch {
-    dir = resolved.endsWith(".canvas.json") ? path18.dirname(resolved) : resolved;
+    dir = resolved.endsWith(".canvas.json") ? path19.dirname(resolved) : resolved;
   }
   let entries;
   try {
-    entries = await readdir5(dir);
+    entries = await readdir6(dir);
   } catch {
     return null;
   }
   const canvases = entries.filter((name) => name.endsWith(".canvas.json"));
   const slug = creativeSlugFromCanvasPath(`${dir}/x/`);
   const chosen = (slug ? canvases.find((name) => name === `${slug}.canvas.json`) : void 0) ?? canvases[0];
-  return chosen ? path18.join(dir, chosen) : null;
+  return chosen ? path19.join(dir, chosen) : null;
 }
 var syncDefinitionCommand = defineCommand100({
   meta: {
@@ -26848,7 +27535,7 @@ var syncDefinitionCommand = defineCommand100({
     if (!slug) return;
     let canvas;
     try {
-      canvas = JSON.parse(await readFile11(canvasPath, "utf8"));
+      canvas = JSON.parse(await readFile12(canvasPath, "utf8"));
     } catch {
       return;
     }
@@ -26875,7 +27562,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 readFile12(source);
+    bytes = await readFile13(source);
   }
   const safe = await toModelSafeImage(bytes);
   const sha256 = sha256Hex(safe.bytes);
@@ -26930,7 +27617,7 @@ DROP background extras, decorative props, generic scenery, and anything small or
 For each kept element return: { "type": one of logo|product|person|animal|badge, "label": a short UPPER_SNAKE_CASE name (e.g. LOGO, PRODUCT, HERO_DOG, TRUSTPILOT), "description": a concrete reusable description to source/shoot the real asset (include the exact expression for a living subject, and its castable attributes \u2014 breed/species for an animal, apparent age band, apparent origin/ethnicity, and wardrobe/setting for a person \u2014 so it can be recast to fit OUR audience/market), "expression": the facial expression for a living subject or null, "reason": why it is identity-critical, "locator": the blueprint entry this element came from as { "collection": one of "subjects" | "people" | "brands_logos", "index": its 0-based position in that array } (people -> people; logos/badges -> brands_logos; products/animals/objects -> subjects). Output ONLY the JSON object.`;
 async function loadAssetText(ref, label) {
   const r = ref;
-  if (typeof r?.path === "string") return readFile12(r.path, "utf8");
+  if (typeof r?.path === "string") return readFile13(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})`);
@@ -27106,7 +27793,7 @@ var scaffoldStaticAdCommand = defineCommand101({
       process.cwd(),
       slug
     );
-    await mkdir6(path19.dirname(outPath), { recursive: true });
+    await mkdir6(path20.dirname(outPath), { recursive: true });
     const { describeModel, selectModel, layoutModel, genModel } = resolveModels(args);
     let durableSourceUrl;
     if (referencesDir) {
@@ -27226,7 +27913,7 @@ var scaffoldStaticAdCommand = defineCommand101({
             run_estimated_credits: validation.estimatedCredits
           },
           checklist: {
-            edit_prompt: `Edit ${path19.basename(blueprintPath)} \u2014 it is the blueprint generated from your image; rewrite it into the ad you want (palette, copy, claims, subjects). It feeds the generator directly.`,
+            edit_prompt: `Edit ${path20.basename(blueprintPath)} \u2014 it is the blueprint generated from your image; rewrite it into the ad you want (palette, copy, claims, subjects). It feeds the generator directly.`,
             assets_to_supply: report.elements,
             font_slot: report.includes_font ? "Drop a brand font at the [TODO] brandfont path (the describe pass recorded the ad's typefaces under `fonts` in prompt.json \u2014 match those). The font is wired into the render as a TYPE SPECIMEN reference so generated text takes the brand letterforms. Delete the brandfont + type_ref nodes to skip it." : "skipped (--skip-font)",
             actor_sheets: report.actor_sheets.length > 0 ? `Each living hero (${report.actor_sheets.join(", ")}) is fused into a generated multi-view reference sheet (image_reference_sheet) that the render grounds on \u2014 so drop ONE clean photo at that hero's ingest and the sheet builds the consistent turnaround. Pass --skip-actor-sheets to ground on the lone photo instead.` : "none (no person/animal heroes detected, or --skip-actor-sheets)",
@@ -27243,9 +27930,9 @@ var scaffoldStaticAdCommand = defineCommand101({
 });
 
 // src/commands/canvas/scaffold-video.ts
-import { access as access2, cp, mkdir as mkdir7, readFile as readFile15, rm as rm6, writeFile as writeFile9 } from "fs/promises";
+import { access as access2, cp, mkdir as mkdir7, readFile as readFile16, rm as rm6, writeFile as writeFile9 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path22 from "path";
+import path23 from "path";
 import { defineCommand as defineCommand102 } from "citty";
 
 // src/engine/scaffold/lib/model-router.ts
@@ -27285,7 +27972,7 @@ function routeVideoModel(input) {
 
 // src/engine/nodes/local/lib/sceneDetect.ts
 import { execFile as execFile2 } from "child_process";
-import { mkdtemp, readdir as readdir6, readFile as readFile13, rm as rm5 } from "fs/promises";
+import { mkdtemp, readdir as readdir7, readFile as readFile14, rm as rm5 } from "fs/promises";
 import { tmpdir } from "os";
 import { join as join2 } from "path";
 import { promisify as promisify2 } from "util";
@@ -27359,9 +28046,9 @@ async function runSceneDetectOnce(filePath, threshold, minSceneLenS, timeoutMs)
       ],
       { encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, timeout: timeoutMs }
     );
-    const csvName = (await readdir6(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
+    const csvName = (await readdir7(outDir)).find((f) => f.toLowerCase().endsWith(".csv"));
     if (!csvName) return [];
-    return parsePySceneDetectCsvCuts(await readFile13(join2(outDir, csvName), "utf-8"));
+    return parsePySceneDetectCsvCuts(await readFile14(join2(outDir, csvName), "utf-8"));
   } finally {
     await rm5(outDir, { recursive: true, force: true });
   }
@@ -27386,23 +28073,23 @@ async function detectSceneCutsPySceneDetect(filePath, opts = {}) {
 
 // src/commands/canvas/composition-path.ts
 import { existsSync as existsSync4 } from "fs";
-import path20 from "path";
+import path21 from "path";
 function resolveShippedCanvasDir(name, startDir, exists = existsSync4, maxDepth = 8) {
-  const rel = path20.join("canvas", name);
+  const rel = path21.join("canvas", name);
   let dir = startDir;
   for (let i = 0; i < maxDepth; i++) {
-    const candidate = path20.join(dir, rel);
-    if (exists(path20.join(candidate, "meta.json"))) return candidate;
-    const parent = path20.dirname(dir);
+    const candidate = path21.join(dir, rel);
+    if (exists(path21.join(candidate, "meta.json"))) return candidate;
+    const parent = path21.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path20.resolve(startDir, "../../../", rel);
+  return path21.resolve(startDir, "../../../", rel);
 }
 
 // src/commands/canvas/gitignore.ts
-import { appendFile, readFile as readFile14 } from "fs/promises";
-import path21 from "path";
+import { appendFile, readFile as readFile15 } from "fs/promises";
+import path22 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("#"))
@@ -27410,10 +28097,10 @@ function missingGitignoreEntries(existing, entries) {
   return entries.filter((e) => !present2.has(e.trim().replace(/\/+$/, "")));
 }
 async function ensureGitignore(dir, entries) {
-  const file = path21.join(dir, ".gitignore");
+  const file = path22.join(dir, ".gitignore");
   let existing;
   try {
-    existing = await readFile14(file, "utf8");
+    existing = await readFile15(file, "utf8");
   } catch {
     return;
   }
@@ -27452,7 +28139,7 @@ ONE PERSON, MULTIPLE LOOKS: if a single individual plays MULTIPLE personas or wa
 For each kept element return: { "type": one of person|animal|product|logo|badge|location, "label": a short UPPER_SNAKE_CASE name (e.g. HERO, CREATOR_SKEPTIC, INSURANCE_CARD, LOGO), "description": a concrete reusable description to source/shoot the real asset \u2014 for a person/animal give a NEUTRAL castable role (e.g. "hero pet-owner, woman in her 30s" or "a small beagle"), NOT the original individual's literal face/identity: we RECAST with a FRESH person/animal, so never tell the agent to reuse the original. "expression": a living subject's typical expression or null, "cast_id": the global.cast id if it maps to one else null, "same_as": the label of another element this is the SAME individual as (different wardrobe/persona) else null, "scenes": the 0-based indices of ONLY the scenes where the element is ACTUALLY VISIBLE ON SCREEN \u2014 judged from that scene's start_frame_prompt / end_frame_prompt subjects and its action_detail, NOT from who is merely speaking. A narrator heard over b-roll is NOT present in that b-roll scene; a dog-running cutaway does NOT contain the couch creator just because she talks across it. Do NOT pad the list \u2014 an element wrongly listed in a scene makes the reproduction render the wrong subject there (e.g. the creator appearing in a pure-dog b-roll). When in doubt, leave a scene OUT. Output ONLY the JSON object.`;
 async function loadAssetText2(ref, label) {
   const r = ref;
-  if (typeof r?.path === "string") return readFile15(r.path, "utf8");
+  if (typeof r?.path === "string") return readFile16(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})`);
@@ -27471,7 +28158,7 @@ async function loadTranscriptBestEffort(ref) {
 async function stageCaptions(outDir, transcript) {
   const text2 = transcript?.trim();
   if (!text2 || text2 === "[]") return {};
-  const compositionPath = path22.join(outDir, "tiktok-captions-composition");
+  const compositionPath = path23.join(outDir, "tiktok-captions-composition");
   await cp(SHIPPED_CAPTIONS_DIR, compositionPath, { recursive: true });
   return { compositionPath };
 }
@@ -27489,11 +28176,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 = path22.join(compositionDir, "meta.json");
-  const rawMeta = await readFile15(metaPath, "utf8");
+  const metaPath = path23.join(compositionDir, "meta.json");
+  const rawMeta = await readFile16(metaPath, "utf8");
   await writeFile9(metaPath, patchCompositionMeta(rawMeta, dims), "utf8");
-  const htmlPath = path22.join(compositionDir, "index.html");
-  const rawHtml = await readFile15(htmlPath, "utf8");
+  const htmlPath = path23.join(compositionDir, "index.html");
+  const rawHtml = await readFile16(htmlPath, "utf8");
   await writeFile9(htmlPath, patchCompositionHtml(rawHtml, dims), "utf8");
 }
 function parseElements2(raw) {
@@ -27541,7 +28228,7 @@ var VIDEO_EXT_BY_MIME = {
   "video/x-matroska": ".mkv"
 };
 function referenceVideoExt(url, contentType) {
-  const fromPath = path22.extname(new URL(url).pathname).toLowerCase();
+  const fromPath = path23.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";
@@ -27567,7 +28254,7 @@ function videoDefinitionDescription(blueprint) {
   return typeof product === "string" && product.trim() ? product.trim() : void 0;
 }
 async function materializeReferenceVideo(fileArg2) {
-  if (!/^https?:\/\//i.test(fileArg2)) return path22.resolve(fileArg2);
+  if (!/^https?:\/\//i.test(fileArg2)) return path23.resolve(fileArg2);
   let bytes;
   let contentType;
   try {
@@ -27579,7 +28266,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 = path22.join(
+  const dest = path23.join(
     tmpdir2(),
     `baker-ref-${sha256Hex(bytes).slice(0, 16)}${referenceVideoExt(fileArg2, contentType)}`
   );
@@ -27799,11 +28486,11 @@ var scaffoldVideoCommand = defineCommand102({
     } catch (e) {
       return fail4("download", e instanceof Error ? e.message : String(e));
     }
-    const base = path22.basename(videoPath, path22.extname(videoPath));
-    const outPath = args.out ? path22.resolve(String(args.out)) : slug ? path22.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path22.join(path22.dirname(videoPath), `${base}.video.canvas.json`);
-    const outDir = path22.dirname(outPath);
-    const blueprintPath = path22.join(outDir, "prompt.json");
-    const blueprintStylePath = path22.join(outDir, "prompt.style.json");
+    const base = path23.basename(videoPath, path23.extname(videoPath));
+    const outPath = args.out ? path23.resolve(String(args.out)) : slug ? path23.join(process.cwd(), "src", "creatives", slug, `${slug}.canvas.json`) : path23.join(path23.dirname(videoPath), `${base}.video.canvas.json`);
+    const outDir = path23.dirname(outPath);
+    const blueprintPath = path23.join(outDir, "prompt.json");
+    const blueprintStylePath = path23.join(outDir, "prompt.style.json");
     const frames = args.frames === "reuse" ? "reuse" : "generate";
     const maxScenes = args["max-scenes"] ? Number(args["max-scenes"]) : void 0;
     if (Number.isFinite(maxScenes)) {
@@ -27848,12 +28535,12 @@ var scaffoldVideoCommand = defineCommand102({
 `
       );
     }
-    const compositionDest = path22.join(outDir, "video-overlay-composition");
+    const compositionDest = path23.join(outDir, "video-overlay-composition");
     await cp(SHIPPED_COMPOSITION_DIR, compositionDest, { recursive: true });
     await stampCompositionDims(compositionDest, outDims);
-    const indexPath = path22.join(compositionDest, "index.html");
+    const indexPath = path23.join(compositionDest, "index.html");
     const overlayHtml = buildOverlayHtml(blueprint, { captionsActive: Boolean(transcript) });
-    const indexHtml = await readFile15(indexPath, "utf8");
+    const indexHtml = await readFile16(indexPath, "utf8");
     const injected = indexHtml.replace("<!--OVERLAYS-->", () => overlayHtml);
     if (injected === indexHtml && overlayHtml.trim()) {
       fail4(
@@ -27867,10 +28554,10 @@ var scaffoldVideoCommand = defineCommand102({
     const opts = {
       imageModel,
       videoModel,
-      overlayCompositionPath: path22.relative(outDir, compositionDest),
-      captionsCompositionPath: captions.compositionPath ? path22.relative(outDir, captions.compositionPath) : void 0,
-      blueprintPath: path22.relative(outDir, blueprintPath),
-      blueprintStylePath: path22.relative(outDir, blueprintStylePath),
+      overlayCompositionPath: path23.relative(outDir, compositionDest),
+      captionsCompositionPath: captions.compositionPath ? path23.relative(outDir, captions.compositionPath) : void 0,
+      blueprintPath: path23.relative(outDir, blueprintPath),
+      blueprintStylePath: path23.relative(outDir, blueprintStylePath),
       frames,
       ambient: Boolean(args.ambient),
       seamDedup: resolveSeamDedup(args["seam-dedup"]),
@@ -27898,7 +28585,7 @@ var scaffoldVideoCommand = defineCommand102({
     await writeFile9(outPath, `${JSON.stringify(canvas, null, 2)}
 `, "utf8");
     await writeFile9(
-      path22.join(outDir, REBUILD_FILE),
+      path23.join(outDir, REBUILD_FILE),
       `${JSON.stringify({ elements, opts }, null, 2)}
 `,
       "utf8"
@@ -27923,7 +28610,7 @@ var scaffoldVideoCommand = defineCommand102({
     await ensureGitignore(process.cwd(), ["canvas/", ".context/"]);
     const sourceRef = videoSourceReference(blueprint, fileArg2);
     if (slug) {
-      const definitionPath = path22.join(outDir, "_definition.md");
+      const definitionPath = path23.join(outDir, "_definition.md");
       if (!await fileExists2(definitionPath)) {
         await writeFile9(
           definitionPath,
@@ -27978,7 +28665,7 @@ var scaffoldVideoCommand = defineCommand102({
             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 \`${path22.basename(blueprintPath)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path22.basename(blueprintStylePath)}, the projection each frame's target_blueprint reads) \u2014 so your scene edits reach the render automatically. Never hand-edit the inlined node prompts in the canvas or the derived ${path22.basename(blueprintStylePath)}; both are regenerated.`,
+            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 \`${path23.basename(blueprintPath)}\`. \`baker canvas validate\`/\`run\` re-assemble the blueprint and re-flow every edited scene back into the render (and regenerate ${path23.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 ${path23.basename(blueprintStylePath)}; both are regenerated.`,
             recurring_elements_to_supply: report.elements,
             voices_to_confirm: report.dialogue.map((d) => ({
               scene: d.scene,
@@ -28015,8 +28702,8 @@ var scaffoldVideoCommand = defineCommand102({
 });
 
 // src/commands/canvas/set-prompt.ts
-import { readFile as readFile16, writeFile as writeFile10 } from "fs/promises";
-import path23 from "path";
+import { readFile as readFile17, writeFile as writeFile10 } from "fs/promises";
+import path24 from "path";
 import { defineCommand as defineCommand103 } from "citty";
 function setNodePrompt(canvas, nodeId, text2) {
   const nodes = canvas?.nodes;
@@ -28044,17 +28731,17 @@ var setPromptCommand = defineCommand103({
     "text-file": { type: "string", description: "Read the new prompt from a UTF-8 file (preserves accents/newlines)" }
   },
   async run({ args }) {
-    const filePath = path23.resolve(String(args.file));
+    const filePath = path24.resolve(String(args.file));
     let canvas;
     try {
-      canvas = JSON.parse(await readFile16(filePath, "utf8"));
+      canvas = JSON.parse(await readFile17(filePath, "utf8"));
     } catch (e) {
       process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "parse", message: String(e) } }, null, 2)}
 `);
       process.exit(2);
     }
     let text2;
-    if (args["text-file"]) text2 = await readFile16(path23.resolve(String(args["text-file"])), "utf8");
+    if (args["text-file"]) text2 = await readFile17(path24.resolve(String(args["text-file"])), "utf8");
     else if (args.text !== void 0) text2 = String(args.text);
     else {
       process.stderr.write(
@@ -28075,7 +28762,7 @@ var setPromptCommand = defineCommand103({
       process.exit(2);
       return;
     }
-    const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(updated, path23.dirname(filePath)), defaultRegistry());
+    const validation = await validateCanvasDeep(resolveRelativeCanvasPaths(updated, path24.dirname(filePath)), defaultRegistry());
     if (!validation.ok) {
       process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "validation", issues: validation.issues } }, null, 2)}
 `);
@@ -28090,8 +28777,8 @@ var setPromptCommand = defineCommand103({
 });
 
 // src/commands/canvas/validate.ts
-import { readFile as readFile17 } from "fs/promises";
-import path24 from "path";
+import { readFile as readFile18 } from "fs/promises";
+import path25 from "path";
 import { defineCommand as defineCommand104 } from "citty";
 var validateCommand = defineCommand104({
   meta: {
@@ -28100,8 +28787,8 @@ var validateCommand = defineCommand104({
   },
   args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
   async run({ args }) {
-    const filePath = path24.resolve(String(args.file));
-    const raw = await readFile17(filePath, "utf8");
+    const filePath = path25.resolve(String(args.file));
+    const raw = await readFile18(filePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -28113,7 +28800,7 @@ var validateCommand = defineCommand104({
     }
     const healed = await healAbsoluteCanvasPaths(filePath, parsed);
     parsed = healed.canvas;
-    parsed = resolveRelativeCanvasPaths(parsed, path24.dirname(filePath));
+    parsed = resolveRelativeCanvasPaths(parsed, path25.dirname(filePath));
     let styleProjection = "not_applicable";
     try {
       styleProjection = await syncStyleProjection(parsed, (line) => process.stderr.write(`${line}
@@ -28537,7 +29224,7 @@ import { defineCommand as defineCommand109 } from "citty";
 import { defineCommand as defineCommand108 } from "citty";
 
 // src/commands/images/api.ts
-import { readFile as readFile18 } from "fs/promises";
+import { readFile as readFile19 } from "fs/promises";
 import { basename, extname } from "path";
 var imageProcessingTimeoutMs = 18e4;
 var imageReadyPollIntervalMs = 2e3;
@@ -28551,7 +29238,7 @@ var mimeMap = {
   ".avif": "image/avif"
 };
 var defaultImageApiDeps = {
-  readFile: readFile18,
+  readFile: readFile19,
   post: apiPost,
   get: apiGet,
   sleep: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms))
@@ -31270,7 +31957,7 @@ function cropSprite(input, region) {
 
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
-import { glob as fsGlob, readFile as readFile19, rename, stat as stat4, writeFile as writeFile11 } from "fs/promises";
+import { glob as fsGlob, readFile as readFile20, rename, stat as stat4, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname2, extname as extname2, join as join4, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
@@ -31303,7 +31990,7 @@ async function readImageBuffer(pathOrUrl) {
     const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
     return buffer;
   }
-  return readFile19(pathOrUrl);
+  return readFile20(pathOrUrl);
 }
 async function isDirectory(path39) {
   try {
@@ -33639,7 +34326,7 @@ function parseResize(args) {
   }
   return void 0;
 }
-function parseColor(raw) {
+function parseColor2(raw) {
   if (typeof raw !== "string" || raw.length === 0) return void 0;
   try {
     return parseHex(raw);
@@ -33649,7 +34336,7 @@ function parseColor(raw) {
 }
 function buildOptions(args) {
   const resize = parseResize(args);
-  const color = parseColor(args.color);
+  const color = parseColor2(args.color);
   const removeBackground2 = typeof args["remove-bg"] === "boolean" ? args["remove-bg"] : color !== void 0;
   const shrinkToContent = typeof args["shrink-to-content"] === "boolean" ? args["shrink-to-content"] : removeBackground2;
   return {
@@ -34666,222 +35353,10 @@ Full guide: __tooling__/docs/tools/baker/images.md`
 import { defineCommand as defineCommand160 } from "citty";
 
 // src/commands/landing/critique.ts
-import { readdir as readdir8, stat as stat6 } from "fs/promises";
+import { readdir as readdir9, stat as stat6 } from "fs/promises";
 import path29 from "path";
 import { defineCommand as defineCommand150 } from "citty";
 
-// src/engine/landing/lib/brand-tokens.ts
-import { readFile as readFile20 } from "fs/promises";
-import path25 from "path";
-
-// src/engine/landing/lib/color.ts
-var NEUTRAL_COLOR_KEYWORDS = /* @__PURE__ */ new Set([
-  "transparent",
-  "currentcolor",
-  "black",
-  "white",
-  "gray",
-  "grey",
-  "silver",
-  "dimgray",
-  "dimgrey",
-  "darkgray",
-  "darkgrey",
-  "lightgray",
-  "lightgrey",
-  "gainsboro",
-  "whitesmoke"
-]);
-function hexChannels(color) {
-  const long = color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})(?:[0-9a-f]{2})?$/i);
-  if (long)
-    return [
-      Number.parseInt(long[1] ?? "0", 16),
-      Number.parseInt(long[2] ?? "0", 16),
-      Number.parseInt(long[3] ?? "0", 16)
-    ];
-  const short = color.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])(?:[0-9a-f])?$/i);
-  if (short) {
-    const dup = (s) => Number.parseInt(`${s ?? "0"}${s ?? "0"}`, 16);
-    return [dup(short[1]), dup(short[2]), dup(short[3])];
-  }
-  return null;
-}
-function parseColor2(raw) {
-  const c = String(raw || "").trim().toLowerCase();
-  if (!c || c === "transparent") return null;
-  const rgb = c.match(/rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)(?:[\s,/]+([\d.]+%?))?\s*\)/i);
-  if (rgb) {
-    const alpha = rgb[4];
-    const a = alpha === void 0 ? 1 : alpha.endsWith("%") ? Number.parseFloat(alpha) / 100 : Number.parseFloat(alpha);
-    return { r: Number(rgb[1]), g: Number(rgb[2]), b: Number(rgb[3]), a };
-  }
-  const oklch = parseOklch(c);
-  if (oklch) return oklch;
-  const hex = hexChannels(c);
-  if (hex) return { r: hex[0], g: hex[1], b: hex[2], a: 1 };
-  return null;
-}
-function parseOklch(c) {
-  const m = c.match(/oklch\(\s*([\d.]+%?)\s+([\d.]+%?)\s+([\d.]+)(?:deg)?(?:\s*\/\s*([\d.]+%?))?\s*\)/i);
-  if (!m) return null;
-  const pct = (s, scale) => s.endsWith("%") ? Number.parseFloat(s) / 100 * scale : Number.parseFloat(s);
-  const alpha = m[4];
-  const a = alpha === void 0 ? 1 : pct(alpha, 1);
-  return { ...oklchToRgb(pct(m[1] ?? "0", 1), pct(m[2] ?? "0", 0.4), Number.parseFloat(m[3] ?? "0")), a };
-}
-function oklchToRgb(L, C, H) {
-  const hRad = H * Math.PI / 180;
-  const a = C * Math.cos(hRad);
-  const b = C * Math.sin(hRad);
-  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
-  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
-  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
-  const lin = [
-    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
-  ].map((v) => {
-    const g = v <= 31308e-7 ? 12.92 * v : 1.055 * Math.sign(v) * Math.abs(v) ** (1 / 2.4) - 0.055;
-    return Math.round(Math.max(0, Math.min(1, g)) * 255);
-  });
-  return { r: lin[0] ?? 0, g: lin[1] ?? 0, b: lin[2] ?? 0 };
-}
-function isNeutralAuthoredColor(rawColor) {
-  const c = String(rawColor || "").trim().toLowerCase();
-  if (!c) return false;
-  if (NEUTRAL_COLOR_KEYWORDS.has(c)) return true;
-  if (/^rgba?\(/i.test(c)) {
-    const channels2 = c.match(/^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/i);
-    if (channels2) {
-      const values = [1, 2, 3].map((i) => Number(channels2[i]));
-      return Math.max(...values) - Math.min(...values) < 30;
-    }
-    return false;
-  }
-  const oklch = c.match(/oklch\(\s*[\d.]+%?\s+([\d.-]+)/i);
-  if (oklch) return Number.parseFloat(oklch[1] ?? "0") < 0.02;
-  const lch = c.match(/lch\(\s*[\d.]+%?\s+([\d.-]+)/i);
-  if (lch) return Number.parseFloat(lch[1] ?? "0") < 3;
-  const hsl = c.match(/hsla?\(\s*[\d.-]+\s*,?\s*([\d.]+)%/i);
-  if (hsl) return Number.parseFloat(hsl[1] ?? "0") < 10;
-  const channels = hexChannels(c);
-  if (channels) return Math.max(...channels) - Math.min(...channels) < 30;
-  return false;
-}
-function hasChroma(c, threshold = 30) {
-  if (!c) return false;
-  return Math.max(c.r, c.g, c.b) - Math.min(c.r, c.g, c.b) >= threshold;
-}
-function getHue(c) {
-  if (!c) return 0;
-  const r = c.r / 255;
-  const g = c.g / 255;
-  const b = c.b / 255;
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  if (max === min) return 0;
-  const d = max - min;
-  let h;
-  if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
-  else if (max === g) h = ((b - r) / d + 2) / 6;
-  else h = ((r - g) / d + 4) / 6;
-  return Math.round(h * 360);
-}
-function isAiPurpleHue(hue) {
-  return hue >= 225 && hue <= 310;
-}
-function isCreamColor(c) {
-  if (Math.min(c.r, c.g, c.b) < 209) return false;
-  if (!(c.r >= c.g && c.g >= c.b)) return false;
-  const warmth = c.r - c.b;
-  return warmth >= 6 && warmth <= 48;
-}
-
-// src/engine/landing/lib/brand-tokens.ts
-var EMPTY = { fonts: /* @__PURE__ */ new Set(), colors: [], hasTokens: false };
-function isWeightOrStyle(value) {
-  return /^(?:\d+(?:\.\d+)?[a-z%]*|normal|bold|bolder|lighter|italic|oblique|none|auto)$/i.test(value);
-}
-function parseBrandTokens(globalCss, brandMd) {
-  const fonts = /* @__PURE__ */ new Set();
-  const colors = [];
-  parseGlobalCss(globalCss, fonts, colors);
-  parseBrandMd(brandMd, fonts, colors);
-  return { fonts, colors, hasTokens: fonts.size > 0 || colors.length > 0 };
-}
-function parseGlobalCss(rawCss, fonts, colors) {
-  const globalCss = rawCss.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " "));
-  for (const m of globalCss.matchAll(/(?<![\w-])--font-([\w-]*)\s*:\s*([^;]+);/gi)) {
-    const slug = m[1] ?? "";
-    if (slug.includes("--") || /^weight(?:$|[-\s])/i.test(slug)) continue;
-    const first = (m[2] ?? "").split(",")[0]?.trim().replace(/^['"]|['"]$/g, "").toLowerCase();
-    if (!first || isWeightOrStyle(first)) continue;
-    fonts.add(first);
-  }
-  for (const m of globalCss.matchAll(
-    /--color-[\w-]*\s*:\s*(#[0-9a-f]{3,8}\b|rgba?\([^)]+\)|oklch\([^)]+\)|hsla?\([^)]+\))/gi
-  )) {
-    const c = parseColor2(m[1] ?? "");
-    if (c) colors.push(c);
-  }
-}
-function parseBrandMd(brandMd, fonts, colors) {
-  const isProhibition = (line) => /\b(?:never|don'?t|do not|avoid|not|instead of|ban(?:ned)?)\b/i.test(line);
-  for (const line of brandMd.split("\n")) {
-    if (isProhibition(line)) continue;
-    for (const m of line.matchAll(/#[0-9a-f]{6}\b/gi)) {
-      const c = parseColor2(m[0]);
-      if (c) colors.push(c);
-    }
-    if (!/\b(?:font|typeface|family)\b/i.test(line)) continue;
-    const named = line.match(/["'`]([A-Za-z][\w ]{1,30})["'`]/g);
-    if (named) for (const n of named) fonts.add(n.slice(1, -1).trim().toLowerCase());
-  }
-}
-function brandTokensFromCanonical(tokens) {
-  const fonts = new Set(tokens.fonts.map((f) => f.family.toLowerCase()));
-  const colors = [];
-  for (const color of tokens.colors) {
-    const parsed = parseColor2(color.value);
-    if (parsed) colors.push(parsed);
-  }
-  return { fonts, colors, hasTokens: fonts.size > 0 || colors.length > 0 };
-}
-async function loadBrandTokens(projectRoot) {
-  const tokensRaw = await safeRead(path25.join(projectRoot, "src", "brand", "tokens.json"));
-  if (tokensRaw) {
-    try {
-      const canonical2 = brandTokensSchema.safeParse(JSON.parse(tokensRaw));
-      if (canonical2.success) return brandTokensFromCanonical(canonical2.data);
-    } catch {
-    }
-  }
-  const globalCss = await safeRead(path25.join(projectRoot, "src", "styles", "global.css"));
-  const brandMd = await safeRead(path25.join(projectRoot, "src", "brand", "BRAND.md"));
-  if (!globalCss && !brandMd) return EMPTY;
-  return parseBrandTokens(globalCss, brandMd);
-}
-async function safeRead(file) {
-  try {
-    return await readFile20(file, "utf8");
-  } catch {
-    return "";
-  }
-}
-function brandCommitsFont(brand, snippet) {
-  if (brand.fonts.size === 0) return false;
-  const lower = snippet.toLowerCase();
-  for (const f of brand.fonts) if (f.length >= 3 && lower.includes(f)) return true;
-  return false;
-}
-function brandCommitsAiHue(brand) {
-  return brand.colors.some((c) => hasChroma(c, 40) && isAiPurpleHue(getHue(c)));
-}
-function brandCommitsCream(brand) {
-  return brand.colors.some((c) => isCreamColor(c));
-}
-
 // src/engine/landing/lib/constants.ts
 var OVERUSED_FONTS = /* @__PURE__ */ new Set([
   // Older monoculture (still ubiquitous):
@@ -35444,7 +35919,7 @@ var LINE_MATCHERS = [
     id: "cream-palette",
     regex: /background(?:-color)?\s*:\s*(#[0-9a-f]{6}\b|rgba?\([^)]+\))/gi,
     test: (m) => {
-      const c = parseColor2(cap2(m, 1));
+      const c = parseColor(cap2(m, 1));
       return c !== null && isCreamColor(c);
     },
     fmt: (m) => `${cap2(m, 1)} (cream ground)`
@@ -35785,7 +36260,7 @@ function shadowIsGlow(value) {
   const y = Number.parseFloat(offsets[1] ?? "0");
   const blur = Number.parseFloat(offsets[2] ?? "0");
   if (!(x === 0 && y === 0 && blur > 4)) return false;
-  const c = parseColor2(colorMatch[0]);
+  const c = parseColor(colorMatch[0]);
   return c !== null && hasChroma(c, 30);
 }
 function firstFamily(decl) {
@@ -35979,7 +36454,7 @@ async function writeCritiqueSnapshot(projectRoot, snapshot) {
 }
 
 // src/commands/landing/source-version.ts
-import { readdir as readdir7, readFile as readFile22, stat as stat5 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile22, stat as stat5 } from "fs/promises";
 import path28 from "path";
 async function landingSourceRelPaths(landingDir) {
   const rel = [];
@@ -36020,7 +36495,7 @@ async function isFile(p) {
 async function walkAstro(dir) {
   let entries;
   try {
-    entries = await readdir7(dir, { withFileTypes: true });
+    entries = await readdir8(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -36146,7 +36621,7 @@ async function critiqueOne(projectRoot, slug, brand, references) {
 }
 async function listLandingSlugs(projectRoot) {
   try {
-    const entries = await readdir8(path29.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    const entries = await readdir9(path29.join(projectRoot, "src", "pages"), { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return [];
@@ -39669,7 +40144,7 @@ var ESCALATION = {
   medium: "`medium` is a quick lookup, not a search. Re-ask the SAME question once with `--depth high` before concluding the web has nothing on it.",
   high: "`high` already thought hard about this. `--depth xhigh` is the only step left and it can run 15 minutes \u2014 take it only if this answer blocks a deliverable; otherwise record the gap and move on."
 };
-function fetchHints({
+function fetchHints2({
   truncated,
   contentChars,
   shownChars
@@ -40153,7 +40628,7 @@ Examples:
           content
         },
         fields: FIELDS6,
-        hints: fetchHints({
+        hints: fetchHints2({
           truncated: page.truncated,
           contentChars: page.contentChars,
           shownChars: content.length