@koda-sl/baker-cli 0.572.0 → 0.574.0

package/dist/chunk-P7OX5Y75.js

@@ -0,0 +1,1920 @@
+import {
+  finalOutputLabelsFromCanvas
+} from "./chunk-M7BSXJNL.js";
+import {
+  BRAND_LOGO_ROLE,
+  CLAIMS_MODEL,
+  CLAIMS_REQUEST,
+  PEOPLE_PROMPT_VERSION,
+  STATIC_AD_ROLE,
+  formatOfAdaptId,
+  isNativeCanvas,
+  isWordsObject,
+  peoplePrompt,
+  plannedPlacements,
+  prepareCanvas,
+  readPeople,
+  uncastPeople,
+  unsuppliedPlaceholderAssets
+} from "./chunk-MVDMMSXS.js";
+import {
+  ViewerAnswerSchema,
+  describeViewer,
+  jevReadJudge,
+  judgeViewerAnswer,
+  misreadings,
+  readTurnRenders,
+  sureEnough,
+  turnRenderRefusal
+} from "./chunk-BXR45CRI.js";
+import {
+  heldRules
+} from "./chunk-WB4FNMSI.js";
+import {
+  readCompanyReading
+} from "./chunk-KSBXVA4K.js";
+import {
+  frontmatterOf
+} from "./chunk-BNEWJXKU.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-CGLNCFAG.js";
+import {
+  LogoFacts,
+  MISALIGNED,
+  compareSizes,
+  sizeDifferenceFinding
+} from "./chunk-7LFOSBF4.js";
+import {
+  LOGO_COMPOSITE_ROLE,
+  SERIES_LEAD_ROLE,
+  STATIC_ADAPT_FORMAT_ROLE,
+  STATIC_ADAPT_ROLE,
+  STATIC_FIX_ROLE,
+  STATIC_FORMAT_ROLE,
+  STATIC_LEAD_ROLE,
+  STATIC_MASTER_ROLE,
+  STATIC_PICK_ROLE,
+  STATIC_PLACE_ROLE,
+  STATIC_PLATE_ROLE,
+  STATIC_SAFE_FIT_ROLE,
+  STATIC_SIZE_ROLE,
+  STATIC_VARIANTS_ROLE,
+  STATIC_VARIANT_CALL_ROLE,
+  VARIANT_PREFILTER_ROLE,
+  adaptPlan,
+  castsNobody,
+  deliveredSize,
+  fitArtwork,
+  formatSlug,
+  isPlateCanvas,
+  logoArtwork,
+  logoCornerWords,
+  nodesWithRole,
+  placementProblems,
+  rolesById,
+  slotPosition,
+  staticMasterFormat,
+  textColourSource,
+  usesTextColour
+} from "./chunk-LRIP2J5S.js";
+import {
+  bytesOf,
+  judgeWinner,
+  nearIdenticalFindings,
+  parseJudgeScores,
+  reviewRenderedStatic,
+  samePictureSizes,
+  staticVerdict
+} from "./chunk-AYOTYURE.js";
+import {
+  conceptSummary,
+  nativeChrome,
+  nativeCopy,
+  nativeSurfaceName,
+  readAdSpec,
+  readInterfaceWords
+} from "./chunk-NEALLMDP.js";
+import {
+  askAboutImages,
+  askAboutText
+} from "./chunk-37QNC344.js";
+import {
+  GLANCE_CHECK_MODEL,
+  nearestSupportedAspectRatio
+} from "./chunk-MCJ5I5LR.js";
+import {
+  describeMarket
+} from "./chunk-2WZI36D3.js";
+import {
+  isSourceStale
+} from "./chunk-AJ4OO3CV.js";
+
+// src/commands/canvas/static-edit.ts
+function specOf(raw) {
+  try {
+    return raw ? readAdSpec(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function frame(spec) {
+  const { copy: _copy, colors: _colors, brand, notes: _notes, source: _source, reference: _reference, ...rest } = spec;
+  const concept = rest.concept ? { ...rest.concept, transfer_note: void 0 } : void 0;
+  const brandShape = brand ? { ...brand, ground: void 0, ink: void 0, accent: void 0, cta: void 0, palette: [] } : void 0;
+  return JSON.stringify({ ...rest, concept, brand: brandShape });
+}
+var ROLE_WORDS = {
+  headline: "the headline",
+  cta: "the button",
+  button: "the button",
+  price: "the price",
+  body: "body text",
+  caption: "a caption",
+  label: "a label",
+  fine_print: "the fine print"
+};
+function copyEdits(before, after) {
+  const out = [];
+  const shared = Math.min(before.length, after.length);
+  for (let i = 0; i < shared; i++) {
+    const a = before[i];
+    const b = after[i];
+    if (a.text !== b.text) out.push(`Change the words "${a.text}" to exactly "${b.text}".`);
+    if ((a.position ?? "") !== (b.position ?? "") && b.position) out.push(`Move "${b.text}" to ${b.position}.`);
+    if ((a.look ?? "") !== (b.look ?? "") && b.look) out.push(`Set "${b.text}" ${b.look}.`);
+    if (a.lettering !== b.lettering || (a.role ?? "") !== (b.role ?? "") || (a.on ?? "") !== (b.on ?? "")) {
+      out.push(`Set "${b.text}" as ${ROLE_WORDS[b.role ?? ""] ?? "it is described"}${b.on ? `, lettered on ${b.on}` : ""}.`);
+    }
+  }
+  for (const added of after.slice(shared)) {
+    const role = ROLE_WORDS[added.role ?? ""];
+    out.push(`Add the words "${added.text}"${role ? ` (${role})` : ""}${added.position ? `, ${added.position}` : ""}.`);
+  }
+  for (const removed of before.slice(shared)) out.push(`Remove the words "${removed.text}".`);
+  return out;
+}
+function colourEdits(before, after) {
+  const out = [];
+  for (const use of after.colors) {
+    const was = before.colors.find((c) => c.object === use.object);
+    if (was && was.name === use.name && was.hex === use.hex) continue;
+    out.push(`Make ${use.object} ${use.name}${use.hex ? ` (${use.hex})` : ""}.`);
+  }
+  const roles = [
+    ["cta", "the button"],
+    ["ground", "the background"],
+    ["ink", "the designed type"],
+    ["accent", "the accent colour"]
+  ];
+  for (const [key, object] of roles) {
+    const was = before.brand?.[key];
+    const now = after.brand?.[key];
+    if (typeof now === "string" && was !== now) out.push(`Make ${object} ${now}.`);
+  }
+  return out;
+}
+function specEditInstruction(previous, next) {
+  const before = specOf(previous);
+  const after = specOf(next);
+  if (!before || !after || frame(before) !== frame(after)) return null;
+  const edits = [...copyEdits(before.copy, after.copy), ...colourEdits(before, after)];
+  return edits.length > 0 ? edits.join(" ") : null;
+}
+function frameChanges(previous, next) {
+  const before = specOf(previous);
+  const after = specOf(next);
+  if (!before || !after) return [];
+  const was = JSON.parse(frame(before));
+  const now = JSON.parse(frame(after));
+  return [.../* @__PURE__ */ new Set([...Object.keys(was), ...Object.keys(now)])].filter(
+    (key) => JSON.stringify(was[key]) !== JSON.stringify(now[key])
+  );
+}
+var normalized = (text) => text.trim().toLowerCase().replace(/\s+/g, " ");
+function repeatsFailedFix(last, instruction) {
+  return Boolean(last && last.blocking.length > 0 && normalized(last.instruction) === normalized(instruction));
+}
+function fixMemoryOf(shown, from) {
+  if (from !== void 0 && from !== shown.rendered?.runId) return { blocking: [] };
+  return { ...shown.lastFix ? { lastFix: shown.lastFix } : {}, blocking: shown.blocking ?? [] };
+}
+function persistingDefects(before, after) {
+  const now = new Set((after ?? []).filter((f) => f.severity === "blocking").map((f) => f.what));
+  return before.filter((what) => now.has(what));
+}
+var onSurface = (line) => line.on ? ` on ${line.on}` : "";
+function inSceneEdits(before, after) {
+  const was = before.filter((line) => line.lettering === "in_scene");
+  const now = after.filter((line) => line.lettering === "in_scene");
+  const out = [];
+  for (let i = 0; i < Math.min(was.length, now.length); i++) {
+    const a = was[i];
+    const b = now[i];
+    if (a.text !== b.text) out.push(`Change the words "${a.text}"${onSurface(a)} to exactly "${b.text}".`);
+    if ((a.on ?? "") !== (b.on ?? "") && b.on)
+      out.push(`Letter "${b.text}" on ${b.on}${a.on ? ` instead of ${a.on}` : ""}.`);
+  }
+  for (const added of now.slice(was.length)) out.push(`Letter the words "${added.text}"${onSurface(added)}.`);
+  for (const removed of was.slice(now.length)) out.push(`Remove the words "${removed.text}" from the picture.`);
+  return out;
+}
+function pictureEdit(previous, next) {
+  const before = specOf(previous);
+  const after = specOf(next);
+  if (!before || !after || frame(before) !== frame(after)) return null;
+  const changed = after.colors.filter((use) => {
+    const was = before.colors.find((c) => c.object === use.object);
+    return !isWordsObject(use.object) && !(was && was.name === use.name && was.hex === use.hex);
+  });
+  const ground = after.brand?.ground;
+  const edits = [
+    ...inSceneEdits(before.copy, after.copy),
+    ...changed.map((use) => `Make ${use.object} ${use.name}${use.hex ? ` (${use.hex})` : ""}.`),
+    ...typeof ground === "string" && before.brand?.ground !== ground ? [`Make the background ${ground}.`] : []
+  ];
+  return edits.length > 0 ? edits.join(" ") : null;
+}
+function plainRunEdit(canvas, shownPrompt, promptNow) {
+  if (isNativeCanvas(canvas)) return null;
+  return isPlateCanvas(canvas) ? pictureEdit(shownPrompt, promptNow) : specEditInstruction(shownPrompt, promptNow);
+}
+
+// src/commands/canvas/static-ad-canvas.ts
+function isStaticAdCanvas(parsed) {
+  const nodes = parsed?.nodes;
+  if (!Array.isArray(nodes)) return false;
+  return nodes.some((n) => {
+    const role = n?.tags?.role;
+    if (role === STATIC_VARIANTS_ROLE) return true;
+    return n?.type === "ingest" && (role === STATIC_AD_ROLE || n?.id === "compose_spec");
+  });
+}
+
+// src/commands/canvas/named-people-read.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var PEOPLE_TIMEOUT_MS = 3e4;
+function peopleReader(cacheDir, spent) {
+  const dir = path.join(cacheDir, "named-people");
+  return async (lines) => {
+    const said2 = lines.filter((l) => l.trim());
+    if (said2.length === 0) return [];
+    const key = createHash("sha256").update(JSON.stringify([PEOPLE_PROMPT_VERSION, CLAIMS_MODEL, said2])).digest("hex");
+    const file = path.join(dir, `${key}.json`);
+    const cached = await readFile(file, "utf8").then((text) => readPeople(JSON.parse(text), said2)).catch(() => null);
+    if (cached) return cached;
+    const answer = await askAboutText(CLAIMS_MODEL, peoplePrompt(said2), spent, {
+      timeoutMs: PEOPLE_TIMEOUT_MS,
+      request: CLAIMS_REQUEST
+    });
+    const people = readPeople(answer, said2);
+    if (people) {
+      await mkdir(dir, { recursive: true });
+      await writeFile(file, JSON.stringify(answer), "utf8");
+    }
+    return people;
+  };
+}
+
+// src/commands/canvas/static-autofix.ts
+var AUTO_FIX_ROUNDS = 3;
+function wholePicture(f) {
+  const kind = f.kind;
+  if (!kind) return false;
+  return kind.item === "subject" || kind.item === "one_idea" || kind.item === "concept" || (kind.item === "picture" || kind.item === "native" || kind.item === "rule") && kind.element === "picture";
+}
+var BRIEF_ITEMS = /* @__PURE__ */ new Set(["subject", "concept", "proof", "person"]);
+var fromBrief = (f) => f.kind !== void 0 && (BRIEF_ITEMS.has(f.kind.item) || f.kind.item === "rule" && f.kind.element === "picture");
+var wordsBreakRule = (f) => f.kind?.item === "rule" && f.kind.element === "copy";
+var lostVital = (f) => f.severity === "blocking" && f.kind?.item === "concept" && f.kind.job !== void 0;
+function keptLostHint(review, idea) {
+  const lost = unique(review.filter(lostVital).map((f) => f.what.replace(/\.$/, "")));
+  if (lost.length === 0) return null;
+  return `Not done: what made the proven ad win is gone (${lost.join("; ")}). Never show this version as done: restore it as the plan decided it (its line under "What survives and what changes" and prompt.json's \`concept.load_bearing\`, carried in the scene, the references and the lines' \`look\`) and run again; if nothing of ours may carry it, build the idea on another proven ad (\`baker winning-ads fit <adId>\` on the next candidates, then \`baker creatives make ${idea ?? "<idea>"} --slug <new slug> --reference <adId>\`) and tell the person why, in one line.`;
+}
+function stopsWithoutRepair(review, brief, repaired) {
+  return !repaired && review.some((f) => lostVital(f) && brief.includes(withoutSize(f.what)));
+}
+var comparesSizes = (f) => f.kind?.item === "sizes";
+var cutCopy = (f) => f.kind?.defect === "cut" && (f.kind.element === "logo" || f.kind.element === "button" || f.kind.element === "copy");
+function aboutWords(f) {
+  const what = withoutSize(f.what);
+  return PLACED.some((p) => p.test(what)) || MISREAD.test(what) || MISSING.test(what) || EXTRA_WORDS.test(what) || cutCopy(f) || f.kind !== void 0 && ["copy", "button", "logo"].includes(f.kind.element);
+}
+var PATCHED_WORDS = "the words came with a patch of redrawn picture around them";
+var UNREAD_WORDS = "where the words sit could not be read";
+var ARTIFACT = /\b(?:halos?|glow|seams?|smears?|smudges?|blotch(?:es)?|patch(?:es)?|box(?:es)?|rectangles?|scrims?|backings?|ghost(?:ed|ing|s)?)\b/i;
+var WORDS = /\b(?:words?|text|copy|headline|lines?|lettering|type|quote|caption|label|button|pill|cta|logo)\b/i;
+var wordsArtifact = (f) => {
+  const what = withoutSize(f.what);
+  return ARTIFACT.test(what) && WORDS.test(what);
+};
+var MANY_DEFECTS = 3;
+var withoutSize = (what) => what.replace(/^\d+(?:\.\d+)?:\d+(?:\.\d+)?(?:,\s*\d+(?:\.\d+)?:\d+(?:\.\d+)?)*:\s*/, "");
+var sizesOf = (what) => what.match(/^(\d+(?:\.\d+)?:\d+(?:\.\d+)?(?:,\s*\d+(?:\.\d+)?:\d+(?:\.\d+)?)*):\s/)?.[1]?.split(/,\s*/) ?? [];
+function carryUnchanged(now, prior, unchanged) {
+  const settled = (f) => {
+    const sizes = sizesOf(f.what);
+    return sizes.length > 0 && sizes.every((s) => unchanged.includes(s)) && !comparesSizes(f);
+  };
+  return [...now.filter((f) => !settled(f)), ...prior.filter(settled)];
+}
+var pct = (share) => `${Math.round(share * 100)}%`;
+var PAST_BAND = /^(.+?) sits? (?:close to )?where (.+?) covers? (?:it|them) \((.+)\)\.?$/;
+var OFF_EDGE = /^(.+?) runs? off the edge of the picture \((.+)\)\.?$/;
+var OUTSIDE_SPACE = /^(.+?) sits? outside the space every size keeps clear \((.+)\)\.?$/;
+var EXTRA_WORDS = /^the picture adds words that aren't in the copy: (.+?)\. Remove them, or add them to the copy\.?$/;
+var SCENE_PRICES = /^the picture shows prices the copy does not hold: (.+?)\. Make them unreadable\.?$/;
+var PLACED = [PAST_BAND, OFF_EDGE, OUTSIDE_SPACE];
+var MISREAD = /^Text: (".+") reads (".*")\.?$/;
+var MISSING = /^Text: (".+") is missing\.?$/;
+var MAKE_ROOM = "Make the room by moving what is next to it with it and shortening the picture or the gaps, keeping every block in its order.";
+var OVERSHOOT = 0.06;
+function moveInto(what, edges, band) {
+  const at = (edge) => edges.includes(edge);
+  const top = band ? band.top + OVERSHOOT : 0;
+  const bottom = band ? band.bottom + OVERSHOOT : 0;
+  const vertical = at("bottom") && at("top") ? band ? `so all of it sits between ${pct(top)} and ${pct(1 - bottom)} of the height` : "into the middle of the frame, away from its top and bottom" : at("bottom") && band ? `up so all of it sits above ${pct(1 - bottom)} of the height, the bottom ${pct(bottom)} showing only the picture` : at("top") && band ? `down so all of it sits below ${pct(top)} of the height, the top ${pct(top)} showing only the picture` : at("bottom") ? "up, away from the bottom of the frame" : at("top") ? "down, away from the top of the frame" : "";
+  const sides = ["right", "left"].filter((e) => at(e === "right" ? "right edge" : "left edge"));
+  const side = sides.map((e) => band ? `at least ${pct(band[e])} in from the ${e} edge` : `away from the ${e} edge`).join(" and ");
+  if (!vertical) return `Move ${what} ${side}`;
+  return side ? `Move ${what} ${vertical}, and ${side}` : `Move ${what} ${vertical}`;
+}
+function correctionOf(finding, band, kind) {
+  const what = withoutSize(finding).trim();
+  if (/could not be read back/.test(what)) return null;
+  const past = what.match(PAST_BAND);
+  if (past) {
+    const [, block = "", surface = "", edges = ""] = past;
+    const covers = band && edges.includes("bottom") && edges.includes("top") ? `: ${surface} covers the top ${pct(band.top)} and the bottom ${pct(band.bottom)} of the frame` : band && edges.includes("bottom") ? `: ${surface} covers the bottom ${pct(band.bottom)} of the frame` : band && edges.includes("top") ? `: ${surface} covers the top ${pct(band.top)} of the frame` : "";
+    return `${moveInto(block, edges, band)}${covers}. ${MAKE_ROOM}`;
+  }
+  const off = what.match(OFF_EDGE) ?? what.match(OUTSIDE_SPACE);
+  if (off) {
+    const [, block = "", edges = ""] = off;
+    const named = edges.replace(/the (top|bottom) of the screen/g, "the $1 edge").replace(/ and /g, " and ");
+    return `Move ${block} fully inside the frame, with clear space between it and ${named}, smaller if it needs to be.`;
+  }
+  const extra = what.match(EXTRA_WORDS);
+  if (extra) {
+    return `Erase these words wherever they appear, leaving the surface they are on blank or with plain lines: ${extra[1]}.`;
+  }
+  const prices = what.match(SCENE_PRICES);
+  if (prices) {
+    return `Blur these figures until no digit can be read, keeping the document or screen they are on as it is: ${prices[1]}.`;
+  }
+  const misread = what.match(MISREAD);
+  if (misread) return `Re-letter ${misread[1]} exactly as written, letter for letter (it now reads ${misread[2]}).`;
+  const missing = what.match(MISSING);
+  if (missing) return `Add the line ${missing[1]}, spelled exactly, where it belongs in the layout.`;
+  if (kind?.item === "sizes") return FOLLOW_PICTURE;
+  const described = what.replace(/\.$/, "");
+  return `Fix this: ${described.charAt(0).toLowerCase()}${described.slice(1)}.`;
+}
+function autoFixStep(canvas, review, opts = {}) {
+  if ((opts.round ?? 0) >= AUTO_FIX_ROUNDS) return null;
+  const flagged = (review ?? []).filter((f) => f.severity === "blocking" && !wordsBreakRule(f));
+  if (flagged.length === 0) return null;
+  if (isNativeCanvas(canvas)) return { kind: "respec", findings: unique(flagged.map((f) => f.what)) };
+  const relaid = relaidSizes(canvas);
+  const blocking = onDerivedSizes(flagged, relaid);
+  const painted = paintedPlates(canvas);
+  const onPainted = (f) => comparesSizes(f) && sizesOf(f.what).length > 0 && sizesOf(f.what).every((size) => painted.has(size));
+  const cutSizes = new Map(relaid.filter((r) => r.words).map((r) => [r.format, r.id]));
+  const patched = (f) => !lostVital(f) && ([PATCHED_WORDS, UNREAD_WORDS].some((said2) => withoutSize(f.what).startsWith(said2)) || wordsArtifact(f)) && sizesOf(f.what).length > 0 && sizesOf(f.what).every((size) => cutSizes.has(size));
+  const wordsOnly = (f) => patched(f) || aboutWords(f) && sizesOf(f.what).length > 0 && sizesOf(f.what).every((size) => cutSizes.has(size));
+  if (blocking.length > 0 && blocking.some(patched) && blocking.every(wordsOnly)) {
+    return {
+      kind: "regenerate",
+      ids: unique(blocking.flatMap((f) => sizesOf(f.what).flatMap((size) => cutSizes.get(size) ?? []))),
+      note: unique(blocking.map((f) => withoutSize(f.what))).join(" ")
+    };
+  }
+  if (blocking.length > 0 && blocking.every(onPainted)) {
+    return {
+      kind: "regenerate",
+      ids: unique(blocking.flatMap((f) => sizesOf(f.what).flatMap((size) => painted.get(size) ?? []))),
+      note: `The last picture painted from the chosen one had this wrong, so avoid it: ${unique(blocking.map((f) => withoutSize(f.what))).join(" ")}`
+    };
+  }
+  const worded = relaid.filter((r) => r.words).map((r) => r.format);
+  const unplaceable = /* @__PURE__ */ new Set([
+    ...(opts.tooFar ?? []).filter((format) => relaid.some((r) => r.format === format)),
+    ...worded
+  ]);
+  const misplaced = (f) => {
+    const what = withoutSize(f.what);
+    const sizes = sizesOf(f.what);
+    return sizes.length > 0 && !sizes.every((size) => unplaceable.has(size)) && (PLACED.some((p) => p.test(what)) || cutCopy(f));
+  };
+  const extend = unique(blocking.filter(misplaced).flatMap((f) => sizesOf(f.what))).filter((size) => !unplaceable.has(size));
+  const placing = extend.length > 0 ? { extend } : {};
+  const rest = blocking.filter((f) => !misplaced(f));
+  const at = (f) => relaid.find((r) => f.what.startsWith(`${r.format}:`) && (!r.words || aboutWords(f)));
+  const keepRight = keptRules(opts.fixedBefore);
+  const edits = {};
+  for (const r of relaid) {
+    const lines = unique(rest.filter((f) => at(f) === r).flatMap((f) => correctionOf(f.what, r.band, f.kind) ?? []));
+    if (lines.length > 0) edits[r.id] = [...lines, ...keepRight ? [keepRight] : []].join(" ");
+  }
+  const sizesOnly = () => {
+    const ids = Object.keys(edits);
+    if (ids.length > 0) return { kind: "relayout", ids, edits, ...placing };
+    return extend.length > 0 ? { kind: "extend", sizes: extend } : null;
+  };
+  const onSeveralSizes = (f) => {
+    const what = withoutSize(f.what);
+    return new Set(rest.filter((g) => withoutSize(g.what) === what).flatMap((g) => sizesOf(g.what))).size >= 2;
+  };
+  const settledPicture = opts.previous === "relayout" || opts.previous === "extend";
+  const pictureFindings = rest.filter((f) => !at(f) && !patched(f) && (!settledPicture || onSeveralSizes(f)));
+  const onPicture = unique(pictureFindings.map((f) => withoutSize(f.what)));
+  if (onPicture.length === 0) return sizesOnly();
+  const every = unique([...extend, ...deliveredSizes(canvas)]).filter((size) => !worded.includes(size));
+  const afterNewPicture = every.length > 0 ? { extend: every } : {};
+  const persisting = new Set((opts.lastFix?.blocking ?? []).map(withoutSize));
+  const stillWrong = opts.previous === "fix" && onPicture.some((w) => persisting.has(w));
+  const brief = unique(pictureFindings.filter(fromBrief).map((f) => withoutSize(f.what)));
+  const rollAgain = stillWrong || brief.length > 0 || onPicture.length >= MANY_DEFECTS || pictureFindings.some(wholePicture);
+  const last = (opts.round ?? 0) >= AUTO_FIX_ROUNDS - 1;
+  if (rollAgain && (!last || brief.length > 0) && !opts.keepPicture && nodesWithRole(canvas, STATIC_VARIANTS_ROLE).length > 0) {
+    return {
+      kind: "regenerate",
+      ids: [STATIC_VARIANTS_ROLE],
+      note: [`The last picture made from this brief had this wrong, so avoid it: ${onPicture.join(" ")}`, ...keepRight ? [keepRight] : []].join(" "),
+      ...brief.length > 0 ? { brief } : {},
+      ...afterNewPicture
+    };
+  }
+  const changes = unique(
+    pictureFindings.filter((f) => !fromBrief(f)).flatMap((f) => correctionOf(f.what, void 0, f.kind) ?? [])
+  );
+  if (changes.length === 0) return sizesOnly();
+  const named = new Set(blocking.flatMap((f) => sizesOf(f.what)));
+  const keep = relaid.filter((r) => !r.words).map((r) => r.format).filter((format) => !named.has(format));
+  const remade = every.filter((size) => !keep.includes(size));
+  const kept = {
+    ...keep.length > 0 ? { keep } : {},
+    ...remade.length > 0 ? { extend: remade } : {}
+  };
+  const asked = `Change only this: ${changes.join(" ")}`;
+  const again = onPicture.filter((w) => persisting.has(w)).map((w) => w.replace(/\.$/, ""));
+  const instruction = [
+    again.length > 0 ? `${asked} The last edit was already asked for this and Image 1 still shows it, so make it clearly: ${again.join("; ")}.` : asked,
+    ...keepRight ? [keepRight] : []
+  ].join(" ");
+  if (repeatsFailedFix(opts.lastFix, asked) || repeatsFailedFix(opts.lastFix, instruction)) return null;
+  const relay = Object.fromEntries(Object.entries(edits).filter(([id]) => relaid.some((r) => r.id === id && !r.words)));
+  return { kind: "fix", instruction, ...Object.keys(relay).length > 0 ? { relay } : {}, ...kept };
+}
+var unique = (lines) => [...new Set(lines)];
+var blockingOf = (review) => unique(review.filter((f) => f.severity === "blocking").map((f) => f.what));
+function correctFrom(attempts) {
+  const latest = attempts[attempts.length - 1];
+  const fewest = Math.min(...attempts.map((a) => blockingOf(a.review).length));
+  const base = blockingOf(latest.review).length > fewest ? attempts.find((a) => blockingOf(a.review).length === fewest) : latest;
+  const now = new Set(blockingOf(base.review).map(withoutSize));
+  const fixedBefore = unique(
+    attempts.filter((a) => a !== base).flatMap((a) => blockingOf(a.review)).filter((what) => !now.has(withoutSize(what)))
+  );
+  return { ...base, fixedBefore };
+}
+function keptRules(fixedBefore) {
+  const rules = unique((fixedBefore ?? []).map((f) => withoutSize(f).replace(/\.$/, "")));
+  return rules.length > 0 ? `These were wrong in an earlier version and are right now, so keep them right: ${rules.join("; ")}.` : null;
+}
+var FOLLOW_PICTURE = "Show exactly what the finished ad (Image 2) shows: its people, products, panels and their order, and nothing it does not show.";
+function onDerivedSizes(findings, relaid) {
+  if (relaid.length === 0) return [...findings];
+  return findings.flatMap((f) => {
+    const sizes = sizesOf(f.what);
+    const onPicture = sizes.length > 0 && sizes.every((size) => !relaid.some((r) => r.format === size));
+    if (!onPicture || !comparesSizes(f)) return [f];
+    return relaid.map((r) => ({ ...f, what: `${r.format}: ${withoutSize(f.what)}` }));
+  });
+}
+function deliveredSizes(canvas) {
+  const nodes = canvas?.nodes;
+  const labels = Array.isArray(nodes) ? nodes.find((n) => n.id === "final" && n.type === "collect")?.params?.labels : void 0;
+  return Array.isArray(labels) ? labels.filter((l) => typeof l === "string") : [];
+}
+function relaidSizes(canvas) {
+  const nodes = canvas?.nodes;
+  const placements = Array.isArray(nodes) ? plannedPlacements(nodes) : void 0;
+  const relaid = nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE).flatMap((n) => {
+    const format = formatOfAdaptId(n.id);
+    if (!format) return [];
+    const model = String(n.params?.model ?? "");
+    return [{ id: n.id, format, band: adaptPlan(model, format, placements).safe, words: false }];
+  });
+  const cut = nodesWithRole(canvas, STATIC_FORMAT_ROLE).flatMap((n) => {
+    const format = n.params?.format;
+    if (typeof format !== "string") return [];
+    const model = String(n.params?.words?.model ?? "");
+    const own = Array.isArray(n.params?.placements) ? n.params.placements : placements;
+    return [{ id: n.id, format, band: adaptPlan(model, format, own).safe, words: true }];
+  });
+  return [...relaid, ...cut];
+}
+function paintedPlates(canvas) {
+  const plates = new Set(nodesWithRole(canvas, STATIC_PLATE_ROLE).map((n) => n.id));
+  return new Map(
+    nodesWithRole(canvas, STATIC_FORMAT_ROLE).flatMap((n) => {
+      const plate = String(n.inputs?.plate ?? "").match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1];
+      const format = n.params?.format;
+      return plate && plates.has(plate) && typeof format === "string" ? [[format, plate]] : [];
+    })
+  );
+}
+function placedTooFar(canvas, outputsByNode) {
+  const placed = nodesWithRole(canvas, STATIC_PLACE_ROLE).flatMap((n) => {
+    const format = n.params?.format;
+    const unmoved = outputsByNode[n.id]?.reason;
+    return (unmoved === "too_far" || unmoved === "inside_band") && typeof format === "string" ? [format] : [];
+  });
+  const cut = nodesWithRole(canvas, STATIC_FORMAT_ROLE).flatMap((n) => {
+    const format = n.params?.format;
+    const facts = outputsByNode[n.id]?.facts;
+    return facts?.reason === "band_too_far" && typeof format === "string" ? [format] : [];
+  });
+  return [...placed, ...cut];
+}
+function formatOfSizeNode(canvas, id) {
+  const relaid = formatOfAdaptId(id);
+  if (relaid) return relaid;
+  const node = nodesWithRole(canvas, STATIC_FORMAT_ROLE).find((n) => n.id === id);
+  const format = node?.params?.format;
+  return typeof format === "string" ? format : null;
+}
+function rendersNewPicture(run) {
+  return !run.fix && !run.useVariant && !run.sizesOnly;
+}
+function paidFor(run) {
+  if (run.fix) return "edit";
+  return run.useVariant || run.sizesOnly ? "sizes" : "options";
+}
+function withRelayNote(canvas, ids, note) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  return {
+    ...holder,
+    nodes: holder.nodes.map((n) => {
+      if (typeof n.id !== "string" || !ids.includes(n.id)) return n;
+      const paint = n.params?.paint;
+      if (paint && typeof paint === "object") {
+        const prompt = [typeof paint.prompt === "string" ? paint.prompt : "", note].filter(Boolean).join("\n\n");
+        return { ...n, params: { ...n.params, paint: { ...paint, prompt } } };
+      }
+      if (typeof n.params?.prompt !== "string") return n;
+      const [lead = "", ...rest] = n.params.prompt.split("\n\n");
+      return { ...n, params: { ...n.params, prompt: [lead, note, ...rest].join("\n\n") } };
+    })
+  };
+}
+function withRelayEdit(canvas, id, opts) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  const target = holder.nodes.find((n) => n.id === id);
+  if (target?.type === "static_format") return withWordsEdit({ nodes: holder.nodes, holder }, target, opts);
+  const prompt = target?.params?.prompt;
+  const refs = target?.inputs?.reference;
+  if (!target || typeof prompt !== "string" || !Array.isArray(refs)) return canvas;
+  const lastId = `last_${id}`;
+  const remote = /^(?:https?|data):/.test(opts.previous);
+  const last = {
+    id: lastId,
+    type: "ingest",
+    params: remote ? { source: "url", url: opts.previous, expect: "image" } : { source: "path", path: opts.previous, expect: "image" }
+  };
+  const again = opts.asked?.includes(opts.instruction) ? "The last edit was asked for this and Image 1 still shows it wrong, so make the change clearly: " : "";
+  const lead = `Edit: Image 1 is this ad as it was last laid out for this size. ${again}${opts.instruction} Keep the rest of Image 1 as it is: the picture, the colours, the lettering and every word, its layout changed only as much as this needs.`;
+  const kept = prompt.split("\n\n").slice(1).filter((p) => !p.startsWith("Scale:")).map((p) => p.replace(/\bImage (\d+)\b/g, (_, n) => `Image ${Number(n) + 1}`)).map(
+    (p) => p.startsWith("References:") ? p.replace("References:", "References:\nImage 1 (THIS SIZE): the last layout of this size, to edit.").replace(/^Image 2 \(AD\):.*$/m, "Image 2 (AD): the finished ad this size is made from: its words, logo and picture are the ones to keep.") : p
+  );
+  const leads = new Set(
+    holder.nodes.flatMap((n) => n.tags?.role === SERIES_LEAD_ROLE ? [n.id] : [])
+  );
+  const own = refs.map((r) => typeof r === "string" && leads.has(r.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1]) ? "$ref:master.image" : r);
+  const edited = {
+    ...target,
+    inputs: { ...target.inputs, reference: [`$ref:${lastId}.asset`, ...own] },
+    params: { ...target.params, prompt: [lead, ...kept].join("\n\n") }
+  };
+  const at = holder.nodes.indexOf(target);
+  return { ...holder, nodes: [...holder.nodes.slice(0, at), last, edited, ...holder.nodes.slice(at + 1)] };
+}
+function lastFile(id, file) {
+  const remote = /^(?:https?|data):/.test(file);
+  return {
+    id,
+    type: "ingest",
+    params: remote ? { source: "url", url: file, expect: "image" } : { source: "path", path: file, expect: "image" }
+  };
+}
+function withWordsEdit(at, target, opts) {
+  const words = target.params?.words;
+  if (typeof words?.prompt !== "string") return at.holder;
+  const lastId = `last_${String(target.id)}`;
+  const again = opts.asked?.includes(opts.instruction) ? "The last edit was asked for this and Image 1 still shows it wrong, so make the change clearly: " : "";
+  const instruction = `Image 1 is this size as its words were last set. ${again}${opts.instruction} Keep the rest of Image 1's words as they are: the lines, the type, the colours and what carries them, moved only as much as this needs. The picture is Image 2's, unchanged.`;
+  const prompt = words.prompt.replace(/\bImage (\d+)\b/g, (_, n) => `Image ${Number(n) + 1}`).replace("References:", "References:\nImage 1 (THIS SIZE): this size as its words were last set, to edit.");
+  const edited = {
+    ...target,
+    inputs: { ...target.inputs, previous: `$ref:${lastId}.asset` },
+    params: { ...target.params, words: { ...words, prompt, edit: { instruction } } }
+  };
+  const index = at.nodes.indexOf(target);
+  return {
+    ...at.holder,
+    nodes: [...at.nodes.slice(0, index), lastFile(lastId, opts.previous), edited, ...at.nodes.slice(index + 1)]
+  };
+}
+function withSizesFollowingFix(canvas, opts) {
+  let out = canvas;
+  for (const n of nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE)) {
+    const also = opts.also?.[n.id];
+    const previous = opts.last[n.id];
+    if (previous) {
+      const instruction = `Make the change the finished ad (Image 2) just had: ${opts.change}${also ? ` ${also}` : ""}`;
+      out = withRelayEdit(out, n.id, { previous, instruction });
+    } else if (also) out = withRelayNote(out, [n.id], `This size must also change this: ${also}`);
+  }
+  return out;
+}
+var EXTEND_PROMPT = [
+  "Deliverable: Image 1 is a finished ad set inside a frame with flat grey margins around it. Paint only the grey: continue the picture outward into it so the whole frame reads as one picture, the scene going on (the wall, the floor, the sky, the room) or, where the ad has no scene, its own plain ground and colours.",
+  "Keep everything that is not grey exactly where and as it is: every word, the logo, the button, the people, the products. Nothing in it moves, grows or is redrawn.",
+  "Add nothing in the grey: no words, no letters, no logos, no buttons, no new people or objects, no frames, borders or shadows around the ad. Never repeat any part of the ad in it: no second logo, button, line of text, card or person; the grey is only more of the room, the table, the floor, the sky or the plain ground."
+].join("\n\n");
+function withExtendedSizes(canvas, formats) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  const nodes = holder.nodes;
+  const final = nodes.find((n) => n.id === "final" && n.type === "collect");
+  const labels = final?.params?.labels;
+  const images = final?.inputs?.images;
+  if (!final || !Array.isArray(labels) || !Array.isArray(images)) return canvas;
+  const painter = nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE)[0] ?? nodesWithRole(canvas, STATIC_VARIANT_CALL_ROLE)[0];
+  const params = painter?.params ?? {};
+  const model = typeof params.model === "string" ? params.model : void 0;
+  if (!model) return canvas;
+  const placements = plannedPlacements(nodes) ?? nodes.find((n) => n.type === "static_safe_fit" && Array.isArray(n.params?.placements))?.params?.placements;
+  const copy = placingCopy(nodes);
+  const added = [];
+  const delivered = [...images];
+  const logoOn = /* @__PURE__ */ new Map();
+  const cut = new Set(nodesWithRole(canvas, STATIC_FORMAT_ROLE).map((n) => `$ref:${n.id}.image`));
+  for (const format of formats) {
+    const at = labels.indexOf(format);
+    const reads = images[at];
+    const composite = nodes.find(
+      (n) => typeof reads === "string" && reads === `$ref:${String(n.id)}.image` && n.tags?.role === LOGO_COMPOSITE_ROLE
+    );
+    const source = composite ? composite.inputs?.image : reads;
+    if (at < 0 || typeof source !== "string" || cut.has(source)) continue;
+    const slug = formatSlug(format);
+    const ratio = nearestSupportedAspectRatio("image_generate", model, format);
+    added.push(
+      {
+        id: `place_${slug}`,
+        type: "static_place",
+        inputs: { image: source },
+        params: {
+          format,
+          render_ratio: ratio,
+          ...placements ? { placements: [...placements] } : {},
+          ...copy ? { copy } : {}
+        },
+        tags: { role: STATIC_PLACE_ROLE }
+      },
+      {
+        id: `merge_${slug}`,
+        type: "static_extend_merge",
+        inputs: { placed: `$ref:place_${slug}.placed`, shown: `$ref:place_${slug}.shown`, keep: `$ref:place_${slug}.keep` },
+        params: {
+          render_ratio: ratio,
+          paint: {
+            model,
+            aspect_ratio: ratio,
+            ...params.quality !== void 0 ? { quality: params.quality } : {},
+            ...params.image_size !== void 0 ? { image_size: params.image_size } : {},
+            prompt: EXTEND_PROMPT
+          }
+        }
+      }
+    );
+    if (composite) logoOn.set(String(composite.id), { ...composite, inputs: { ...composite.inputs, image: `$ref:merge_${slug}.image` } });
+    else delivered[at] = `$ref:merge_${slug}.image`;
+  }
+  if (added.length === 0) return canvas;
+  const kept = nodes.filter((n) => n !== final && !logoOn.has(String(n.id)));
+  return {
+    ...holder,
+    nodes: [...kept, ...added, ...logoOn.values(), { ...final, inputs: { ...final.inputs, images: delivered } }]
+  };
+}
+function placingCopy(nodes) {
+  const told = nodes.find(
+    (n) => (n.type === "static_safe_fit" || n.type === "static_place") && Array.isArray(n.params?.copy)
+  )?.params?.copy;
+  if (Array.isArray(told)) return told;
+  const kept = nodes.find((n) => n.type === "image_aspect_adapt" && Array.isArray(n.params?.copy))?.params?.copy;
+  return Array.isArray(kept) ? kept.filter((t) => typeof t === "string").map((text) => ({ text })) : void 0;
+}
+function deliveredRole(ref, nodes, roles) {
+  const idOf = (r) => typeof r === "string" ? /^\$ref:([^.]+)\./.exec(r)?.[1] : void 0;
+  const read = idOf(ref);
+  const composite = read && roles[read] === LOGO_COMPOSITE_ROLE ? nodes.find((n) => n.id === read) : void 0;
+  const from = composite ? idOf(composite.inputs?.image) : read;
+  return from ? roles[from] : void 0;
+}
+function withDeliveredSizes(canvas, last) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return canvas;
+  const final = holder.nodes.find((n) => n.id === "final" && n.type === "collect");
+  const labels = final?.params?.labels;
+  const images = final?.inputs?.images;
+  if (!final || !Array.isArray(labels) || !Array.isArray(images)) return canvas;
+  const ingests = [];
+  const roles = rolesById(canvas);
+  const delivered = images.map((ref, i) => {
+    const format = labels[i];
+    const file = typeof format === "string" ? last[format] : void 0;
+    if (!file || typeof format !== "string") return ref;
+    const id = `last_${formatSlug(format)}`;
+    const remote = /^(?:https?|data):/.test(file);
+    const role = deliveredRole(ref, holder.nodes ?? [], roles);
+    ingests.push({
+      id,
+      type: "ingest",
+      params: remote ? { source: "url", url: file, expect: "image" } : { source: "path", path: file, expect: "image" },
+      ...role === STATIC_MASTER_ROLE ? { tags: { role } } : {}
+    });
+    return `$ref:${id}.asset`;
+  });
+  const at = holder.nodes.indexOf(final);
+  return {
+    ...holder,
+    nodes: [
+      ...holder.nodes.slice(0, at),
+      ...ingests,
+      { ...final, inputs: { ...final.inputs, images: delivered } },
+      ...holder.nodes.slice(at + 1)
+    ]
+  };
+}
+
+// src/commands/canvas/static-run-review.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+
+// src/commands/canvas/glance-check.ts
+import sharp from "sharp";
+import { z } from "zod";
+var GLANCE_REQUIRED = {
+  offer: "guess",
+  for_whom: "unclear",
+  next_step: "unclear"
+};
+var GLANCE_WIDTH = 400;
+var GlanceAnswerSchema = ViewerAnswerSchema.extend({
+  /** What kind of product or service they take it for (D4). */
+  category: z.object({ answer: z.string().default(""), clarity: z.enum(["clear", "guess", "unclear"]).default("unclear") }).default({ answer: "", clarity: "unclear" }),
+  stopped: z.string().default(""),
+  me: z.enum(["yes", "no", "unsure"]).default("unsure")
+});
+function wherePhrase(placements) {
+  const fullScreen = placements.length === 0 || placements.some((p) => /automatic|stor|reel/i.test(p));
+  return fullScreen ? "your Instagram or Facebook feed, Stories or Reels" : "your Instagram or Facebook feed";
+}
+function knowledge(viewer) {
+  if (!viewer.knows.includes("brand")) return "You have never heard of the advertiser.";
+  const offer = viewer.knows.includes("offer") ? " You know roughly what they sell." : "";
+  return `You have come across the advertiser before.${offer}`;
+}
+function buildGlancePrompt(input) {
+  const who = input.market ? `You are ${input.market}. ` : "";
+  return [
+    `${who}You are scrolling ${wherePhrase(input.viewer.placements)} on your phone. ${knowledge(input.viewer)}`,
+    "This ad passes under your thumb and holds you for about three seconds: you take in the picture and read the biggest words, not the small print. The image is shown at the size your phone shows it.",
+    "Answer as this person, from those three seconds alone. Do not fill gaps with what ads like this usually sell.",
+    'For each question give your answer in English and how sure you are: "clear" when the ad says it outright or you already know it; "guess" when you are piecing it together; "unclear" when you cannot tell.',
+    "offer: what is being sold or offered?",
+    "for_whom: who is it for?",
+    "next_step: what would you do next if you wanted it?",
+    "category: what kind of product or service is this for (a payroll app, a trade course, a phone)?",
+    'missing: in one short sentence, what you would need to be told to get it; "" when nothing.',
+    "stopped: what made you stop on it, or what nearly made you scroll past, in a few words.",
+    'me: is this for someone like you? "yes", "no" or "unsure".',
+    "",
+    'Reply with only this JSON: {"offer":{"answer":"","clarity":"clear|guess|unclear"},"for_whom":{"answer":"","clarity":"clear|guess|unclear"},"next_step":{"answer":"","clarity":"clear|guess|unclear"},"category":{"answer":"","clarity":"clear|guess|unclear"},"missing":"","stopped":"","me":"yes|no|unsure"}'
+  ].join("\n");
+}
+var QUESTION_WORDS = {
+  offer: "what is offered",
+  for_whom: "who it is for",
+  next_step: "what to do next"
+};
+function missWords(miss) {
+  if (miss.question === "presumes") return `it talks to them as a customer already ("${miss.viewerSaid}")`;
+  const said2 = miss.viewerSaid.trim() ? `"${miss.viewerSaid.trim()}"` : "nothing";
+  const what = QUESTION_WORDS[miss.question];
+  return miss.reason === "misread" ? `${what} (they were sure it is ${said2})` : `${what} (they said ${said2})`;
+}
+function glanceFindings(answer, intended, format, viewer, misread = { offer: false, category: false }) {
+  const verdict = judgeViewerAnswer({ ...answer, presumes: "" }, intended, GLANCE_REQUIRED, misread.offer);
+  const category = answer.category.answer.trim();
+  const kind = intended.recognition && category && misread.category ? [
+    {
+      severity: "warning",
+      what: `${format}: At a glance, a stranger took it for "${category}"; it is meant as ${intended.recognition}.`
+    }
+  ] : [];
+  if (verdict.pass) return kind;
+  const needed = answer.missing.trim() ? ` They needed: ${answer.missing.trim().replace(/[.!]+$/, "")}.` : "";
+  const missed = verdict.missed.map(missWords).join("; ");
+  return [
+    {
+      severity: "blocking",
+      what: `${format}: At a glance, ${describeViewer(viewer).replace(/, on .* placements$/, "")} could not tell ${missed}.${needed}`
+    },
+    ...kind
+  ];
+}
+async function glanceMisreads(answer, intended, judge) {
+  const sure = sureEnough(answer.offer.clarity, GLANCE_REQUIRED.offer);
+  const [offer = false, category = false] = await misreadings(
+    [
+      { said: sure ? answer.offer.answer : "", meant: intended.offer, sells: intended.sells },
+      { said: answer.category.answer, meant: intended.recognition }
+    ],
+    judge
+  );
+  return { offer, category };
+}
+function gatewayGlanceModel(onSpend) {
+  return (jpeg, prompt) => askAboutImages(GLANCE_CHECK_MODEL, [jpeg], prompt, onSpend);
+}
+async function glanceCheck(opts) {
+  let jpeg;
+  try {
+    const bytes = await bytesOf(opts.image);
+    jpeg = (await sharp(bytes).resize({ width: GLANCE_WIDTH }).jpeg({ quality: 85 }).toBuffer()).toString("base64");
+  } catch {
+    return null;
+  }
+  const prompt = buildGlancePrompt({ viewer: opts.viewer, ...opts.market ? { market: opts.market } : {} });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const parsed = GlanceAnswerSchema.safeParse(await opts.ask(jpeg, prompt));
+    if (parsed.success) {
+      const misread = await glanceMisreads(parsed.data, opts.intended, opts.judge ?? jevReadJudge());
+      return glanceFindings(parsed.data, opts.intended, opts.format, opts.viewer, misread);
+    }
+  }
+  return null;
+}
+
+// src/commands/canvas/logo-review.ts
+import sharp2 from "sharp";
+
+// src/engine/nodes/local/lib/logo-match.ts
+var SOLID = 250;
+var SAME_COLOUR = 60;
+var LOGO_MATCH = 0.98;
+var DRAWN_LOGO_MATCH = 0.9;
+var COARSE_WIDTH = 180;
+var MIN_SHOWN = 0.4;
+var MAIN_COLOUR = 0.12;
+var INK_NEAR = 90;
+function inkColours(logo) {
+  const bins = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (let i = 0; i < logo.width * logo.height; i++) {
+    if ((logo.data[i * 4 + 3] ?? 0) < SOLID) continue;
+    const r = logo.data[i * 4] ?? 0;
+    const g = logo.data[i * 4 + 1] ?? 0;
+    const b = logo.data[i * 4 + 2] ?? 0;
+    const key = r >> 5 << 6 | g >> 5 << 3 | b >> 5;
+    const bin = bins.get(key) ?? { n: 0, r: 0, g: 0, b: 0 };
+    bins.set(key, { n: bin.n + 1, r: bin.r + r, g: bin.g + g, b: bin.b + b });
+    total++;
+  }
+  return [...bins.values()].filter((b) => b.n >= MAIN_COLOUR * total).map((b) => [b.r / b.n, b.g / b.n, b.b / b.n]);
+}
+function mapOf(img, f, test) {
+  const width = Math.max(1, Math.floor(img.width / f));
+  const height = Math.max(1, Math.floor(img.height / f));
+  const map = new Uint8Array(width * height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) map[y * width + x] = cellOn(img.width, f, x * f, y * f, test) ? 1 : 0;
+  }
+  return { map, width, height };
+}
+function cellOn(width, f, x0, y0, test) {
+  let on = 0;
+  for (let j = 0; j < f; j++) {
+    for (let i = 0; i < f; i++) on += test((y0 + j) * width + x0 + i) ? 1 : 0;
+  }
+  return on * 2 >= f * f;
+}
+function inkMapOf(image, colours, f) {
+  return mapOf(image, f, (i) => colours.some((c) => distance(image.data, i * 4, c, 0) < INK_NEAR));
+}
+var maskOf = (logo, f) => mapOf(logo, f, (i) => (logo.data[i * 4 + 3] ?? 0) >= 128);
+function summed(m) {
+  const w = m.width + 1;
+  const sum = new Int32Array(w * (m.height + 1));
+  for (let y = 0; y < m.height; y++) {
+    let row = 0;
+    for (let x = 0; x < m.width; x++) {
+      row += m.map[y * m.width + x] ?? 0;
+      sum[(y + 1) * w + x + 1] = (sum[y * w + x + 1] ?? 0) + row;
+    }
+  }
+  return { ...m, sum };
+}
+function inkIn(m, x0, y0, x1, y1) {
+  const w = m.width + 1;
+  const [a, b] = [Math.max(0, x0), Math.min(m.width, x1)];
+  const [c, d] = [Math.max(0, y0), Math.min(m.height, y1)];
+  if (a >= b || c >= d) return 0;
+  return (m.sum[d * w + b] ?? 0) - (m.sum[c * w + b] ?? 0) - (m.sum[d * w + a] ?? 0) + (m.sum[c * w + a] ?? 0);
+}
+function cellsOf(m) {
+  const rows = [];
+  const x0s = [];
+  const x1s = [];
+  for (let y = 0; y < m.height; y++) {
+    for (let x = 0; x < m.width; x++) {
+      if (!m.map[y * m.width + x]) continue;
+      const start = x;
+      while (x < m.width && m.map[y * m.width + x]) x++;
+      rows.push(y);
+      x0s.push(start);
+      x1s.push(x);
+    }
+  }
+  const mask = summed(m);
+  return {
+    rows: Int32Array.from(rows),
+    x0s: Int32Array.from(x0s),
+    x1s: Int32Array.from(x1s),
+    mask,
+    area: inkIn(mask, 0, 0, m.width, m.height),
+    width: m.width,
+    height: m.height
+  };
+}
+var fitScore = (inter, inside, win, area) => inter / (inside + win - inter) * Math.sqrt(inside / area);
+function fitAt(ink, cells, x, y, floor = 0) {
+  const inside = inkIn(cells.mask, -x, -y, ink.width - x, ink.height - y);
+  if (inside < MIN_SHOWN * cells.area) return 0;
+  const win = inkIn(ink, x, y, x + cells.width, y + cells.height);
+  if (fitScore(Math.min(inside, win), inside, win, cells.area) <= floor) return 0;
+  let inter = 0;
+  for (let k = 0; k < cells.rows.length; k++) {
+    const v = y + (cells.rows[k] ?? 0);
+    inter += inkIn(ink, x + (cells.x0s[k] ?? 0), v, x + (cells.x1s[k] ?? 0), v + 1);
+  }
+  return fitScore(inter, inside, win, cells.area);
+}
+function bestFit(ink, cells, xs, ys, step = 1) {
+  let best = { x: 0, y: 0, score: 0 };
+  if (cells.area === 0) return best;
+  for (let y = ys[0]; y <= ys[1]; y += step) {
+    for (let x = xs[0]; x <= xs[1]; x += step) {
+      const score = fitAt(ink, cells, x, y, best.score);
+      if (score > best.score) best = { x, y, score };
+    }
+  }
+  return best;
+}
+function locateLogo(image, templates) {
+  const first = templates[0];
+  if (!first) return null;
+  const colours = inkColours(templates[templates.length - 1] ?? first);
+  if (colours.length === 0) return null;
+  const f = Math.max(1, Math.round(image.width / COARSE_WIDTH));
+  const found = coarseFind(summed(inkMapOf(image, colours, f)), templates, f);
+  if (!found || found.score === 0) return null;
+  if (f === 1) {
+    const t = templates[found.template];
+    return { x: found.x, y: found.y, width: t.width, height: t.height, template: found.template, score: found.score };
+  }
+  return fineFind(summed(inkMapOf(image, colours, 1)), templates, found, f);
+}
+function coarseFind(coarse, templates, f) {
+  let found = null;
+  templates.forEach((t, k) => {
+    const cells = cellsOf(maskOf(t, f));
+    const reachX = Math.round(cells.width * (1 - MIN_SHOWN));
+    const reachY = Math.round(cells.height * (1 - MIN_SHOWN));
+    const fit = bestFit(
+      coarse,
+      cells,
+      [-reachX, coarse.width - cells.width + reachX],
+      [-reachY, coarse.height - cells.height + reachY]
+    );
+    if (!found || fit.score > found.score) found = { template: k, ...fit };
+  });
+  return found;
+}
+function fineFind(full, templates, found, f) {
+  let fine = null;
+  const [cx, cy] = [found.x * f, found.y * f];
+  for (const k of [-2, -1, 0, 1, 2].map((d) => found.template + d)) {
+    const t = templates[k];
+    if (!t) continue;
+    const cells = cellsOf(maskOf(t, 1));
+    const near = bestFit(full, cells, [cx - 2 * f, cx + 2 * f], [cy - 2 * f, cy + 2 * f], 3);
+    const fit = bestFit(full, cells, [near.x - 2, near.x + 2], [near.y - 2, near.y + 2]);
+    if (!fine || fit.score > fine.score)
+      fine = { x: fit.x, y: fit.y, width: t.width, height: t.height, template: k, score: fit.score };
+  }
+  return fine;
+}
+var distance = (a, i, b, j) => Math.hypot((a[i] ?? 0) - (b[j] ?? 0), (a[i + 1] ?? 0) - (b[j + 1] ?? 0), (a[i + 2] ?? 0) - (b[j + 2] ?? 0));
+function logoAgreement(image, logo, at) {
+  let solid = 0;
+  let same = 0;
+  for (let j = 0; j < logo.height; j++) {
+    for (let i = 0; i < logo.width; i++) {
+      const s = (j * logo.width + i) * 4;
+      if ((logo.data[s + 3] ?? 0) < SOLID) continue;
+      solid++;
+      const u = at.x + i;
+      const v = at.y + j;
+      if (u < 0 || v < 0 || u >= image.width || v >= image.height) continue;
+      if (distance(image.data, (v * image.width + u) * 4, logo.data, s) < SAME_COLOUR) same++;
+    }
+  }
+  return solid === 0 ? 0 : same / solid;
+}
+
+// src/commands/canvas/logo-review.ts
+var nodesOf = (parsed) => {
+  const nodes = parsed?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+};
+var refId = (ref) => typeof ref === "string" ? ref.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1] ?? null : null;
+var edgesSaid = (edges) => edges.join(" and ") || "edge";
+var sizeId = formatSlug;
+function wordsNodeOf(nodes, composite, format) {
+  let ref = composite?.inputs?.image;
+  for (let hops = 0; hops < 12; hops++) {
+    const n = nodes.find((m) => m.id === refId(ref));
+    if (!n) break;
+    if (n.type === "static_format" || n.type === "image_generate") return String(n.id);
+    if (n.type === "static_prefilter") return null;
+    ref = n.inputs?.image;
+  }
+  return `format_${sizeId(format)}`;
+}
+function saidOfRoom(format, defect, corner, words = `format_${sizeId(format)}`) {
+  const kind = { item: "logo", element: "logo", defect: "other", edges: [] };
+  const room = words === null ? `keep the ${corner} plain for the logo, with no word, button or card in it (a \`--fix\` of the chosen picture).` : `run \`baker canvas run \u2026 --regenerate ${words}\` and keep the ${corner} clear for the logo.`;
+  const what = defect === "no_room" ? `${format}: there is no room for the logo, not even on a small plate; ${room}` : `${format}: the logo is lost on the picture under it; run \`--regenerate logo_${sizeId(format)}\` so it is set on a plate.`;
+  return { severity: "blocking", what, kind };
+}
+function said(format, p, corner = logoCornerWords(void 0), words) {
+  if (p.defect === "no_room" || p.defect === "illegible") return saidOfRoom(format, p.defect, corner, words);
+  const kind = (item, element, defect) => ({
+    item,
+    element,
+    defect,
+    edges: p.defect === "cut" ? [...p.edges] : []
+  });
+  const blocking = (what, k) => ({
+    severity: "blocking",
+    what: `${format}: ${what}`,
+    kind: k
+  });
+  if (p.element === "logo") {
+    return p.defect === "cut" ? blocking(
+      `the frame cuts the logo at its ${edgesSaid(p.edges)}; place it again inside the frame.`,
+      kind("logo", "logo", "cut")
+    ) : blocking(
+      `the logo reaches past the ${edgesSaid(p.edges)} of the part of the frame the app leaves clear; place it again inside it.`,
+      kind("safe_zone", "logo", "other")
+    );
+  }
+  if (p.defect === "under_logo") {
+    const what = p.element === "headline" ? "the headline" : "a line of the copy";
+    return blocking(
+      `the logo covers ${what}; set the words again clear of the logo's corner.`,
+      kind("layout", "copy", "other")
+    );
+  }
+  return p.defect === "cut" ? blocking(
+    `the frame cuts the headline at its ${edgesSaid(p.edges)}; set the words again inside the frame.`,
+    kind("layout", "copy", "cut")
+  ) : blocking(
+    `the headline reaches past the ${edgesSaid(p.edges)} of the part of the frame the app leaves clear; set the words again inside it.`,
+    kind("safe_zone", "copy", "other")
+  );
+}
+function logoPlacementFindings(parsed, outputsByNode) {
+  return nodesWithRole(parsed, LOGO_COMPOSITE_ROLE).flatMap((n) => {
+    const facts = LogoFacts.safeParse(outputsByNode[n.id]?.facts);
+    if (!facts.success) return [];
+    const { format, slot, problems } = facts.data;
+    const kept = problems.some((p) => p.defect === "no_room") ? slotPosition(slot, deliveredSize(format)) : void 0;
+    const corner = logoCornerWords(kept ?? n.params?.position);
+    const words = wordsNodeOf(nodesOf(parsed), n, facts.data.format);
+    return facts.data.problems.map((p) => said(facts.data.format, p, corner, words));
+  });
+}
+async function rgbaOf(bytes) {
+  const { data, info } = await sharp2(bytes).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  return { data, width: info.width, height: info.height };
+}
+async function ingestBytes(ref, outputsByNode) {
+  const id = refId(ref);
+  const asset = id ? outputsByNode[id]?.asset : void 0;
+  const source = await textColourSource(asset?.metadata);
+  if (source) return source;
+  const at = typeof asset?.path === "string" ? asset.path : typeof asset?.url === "string" ? asset.url : null;
+  return at ? await bytesOf(at).catch(() => null) : null;
+}
+var LOGO_FOUND = 0.6;
+var pct2 = (v) => `${Math.round(v * 100)}%`;
+function mismatch(format, agreement) {
+  return {
+    severity: "blocking",
+    what: `${format}: the logo is not the brand's file as it is (redrawn or altered: ${pct2(agreement)} of it matches the file); run it again so the file itself is placed.`,
+    kind: { item: "logo", element: "logo", defect: "other", edges: [] }
+  };
+}
+function drawnMismatch(format, agreement) {
+  return {
+    severity: "blocking",
+    what: `${format}: the logo drawn is not the brand's logo (only ${pct2(agreement)} of it matches the file); draw this size again with the brand's logo copied exactly from the logo file, letter for letter.`,
+    kind: { item: "logo", element: "logo", defect: "other", edges: [] }
+  };
+}
+function searchWidths(frameWidth) {
+  const widths = [];
+  for (let w = frameWidth * 0.08; w <= frameWidth * 0.45; w *= 1.04) widths.push(Math.round(w));
+  return widths;
+}
+async function placedLogoFinding(n, outputsByNode, images) {
+  const facts = LogoFacts.safeParse(outputsByNode[String(n.id)]?.facts);
+  if (!facts.success || facts.data.problems.some((p) => p.defect === "no_room")) return [];
+  const { format, box, variant, ink } = facts.data;
+  const image = images.find((i) => i.format === format);
+  const logos = Array.isArray(n.inputs?.logos) ? n.inputs.logos : [];
+  const [ad, file] = await Promise.all([
+    image ? bytesOf(image.path).catch(() => null) : null,
+    ingestBytes(logos[variant], outputsByNode)
+  ]);
+  if (!ad || !file) return [];
+  const placed = await fitArtwork(await logoArtwork(file, ink ? { currentColor: ink } : {}), box);
+  const agreement = logoAgreement(await rgbaOf(ad), placed, box);
+  return agreement < LOGO_MATCH ? [mismatch(format, agreement)] : [];
+}
+async function drawnLogoOn(picture, arts) {
+  let best = null;
+  for (const art of arts) {
+    if (!art) continue;
+    const templates = await Promise.all(
+      searchWidths(picture.width).map((w) => fitArtwork(art, { width: w, height: picture.height }))
+    );
+    const at = locateLogo(picture, templates);
+    if (!at || at.score < LOGO_FOUND || best && best.score >= at.score) continue;
+    best = { agreement: logoAgreement(picture, templates[at.template], at), box: at, score: at.score };
+  }
+  return best;
+}
+var NO_MARGIN = { top: 0, bottom: 0, left: 0, right: 0 };
+async function artworksOf(file, inks) {
+  const colours = usesTextColour(file) ? inks : [void 0];
+  return await Promise.all(colours.map((ink) => logoArtwork(file, ink ? { currentColor: ink } : {}).catch(() => null)));
+}
+async function drawnLogoFinding(image, arts) {
+  const ad = await bytesOf(image.path).catch(() => null);
+  if (!ad) return [];
+  const picture = await rgbaOf(ad);
+  const drawn = await drawnLogoOn(picture, arts);
+  if (!drawn) return [];
+  const frame2 = { width: picture.width, height: picture.height };
+  const cut = placementProblems({ frame: frame2, safe: NO_MARGIN, logo: drawn.box });
+  if (cut.length > 0) return cut.map((p) => said(image.format, p));
+  return drawn.agreement < DRAWN_LOGO_MATCH ? [drawnMismatch(image.format, drawn.agreement)] : [];
+}
+async function deliveredLogoFindings(parsed, outputsByNode, images, inks = ["#000000", "#FFFFFF"]) {
+  const nodes = nodesOf(parsed);
+  const composites = nodes.filter((n) => n.tags?.role === LOGO_COMPOSITE_ROLE && n.type === "static_logo");
+  if (composites.length > 0) {
+    return (await Promise.all(composites.map((n) => placedLogoFinding(n, outputsByNode, images)))).flat();
+  }
+  const logos = nodes.filter((n) => n.type === "ingest" && /^brand_logo/.test(String(n.tags?.role ?? "")));
+  const files = await Promise.all(logos.map((n) => ingestBytes(`$ref:${String(n.id)}.asset`, outputsByNode)));
+  const arts = (await Promise.all(files.map((f) => f ? artworksOf(f, inks) : []))).flat();
+  if (!arts.some((a) => a !== null)) return [];
+  const asIs = deliveredAsIs(nodes);
+  const drawn = images.filter((i) => !asIs.has(i.format));
+  return (await Promise.all(drawn.map((image) => drawnLogoFinding(image, arts)))).flat();
+}
+function deliveredAsIs(nodes) {
+  const final = nodes.find((n) => n.id === "final" && n.type === "collect");
+  const labels = final?.params?.labels;
+  const images = final?.inputs?.images;
+  if (!Array.isArray(labels) || !Array.isArray(images)) return /* @__PURE__ */ new Set();
+  return new Set(
+    labels.filter((label, i) => {
+      const from = nodes.find((n) => n.id === refId(images[i]));
+      return typeof label === "string" && from?.type === "ingest";
+    })
+  );
+}
+
+// src/commands/canvas/static-run-review.ts
+function imagesOf(output) {
+  const list = Array.isArray(output) ? output : [output];
+  const images = list.filter((o) => Boolean(o) && typeof o === "object");
+  return images.length > 0 && images.every((i) => i.kind === "image") ? images : null;
+}
+function promptPathOf(parsed) {
+  const nodes = parsed?.nodes;
+  if (!Array.isArray(nodes)) return null;
+  const prompt = nodes.find((n) => n?.id === "prompt" && n?.type === "ingest");
+  const p = prompt?.params;
+  return p?.source === "path" && p.expect === "json" && typeof p.path === "string" ? p.path : null;
+}
+function staticReviewTargets(parsed, output) {
+  const promptPath = promptPathOf(parsed);
+  const images = imagesOf(output);
+  if (!promptPath || !images) return null;
+  const labels = finalOutputLabelsFromCanvas(parsed)?.labels ?? [];
+  return {
+    promptPath,
+    // A local file when the run downloaded it, else its durable URL.
+    images: images.flatMap((image, i) => {
+      const source = typeof image.path === "string" ? image.path : typeof image.url === "string" ? image.url : null;
+      return source ? [{ path: source, format: labels[i] ?? "" }] : [];
+    })
+  };
+}
+function nodesOf2(parsed) {
+  const nodes = parsed?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+}
+var refId2 = (ref) => typeof ref === "string" ? ref.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1] ?? null : null;
+var hasRole = (n, role) => n.tags?.role === role;
+function variantCount(nodes) {
+  const calls = nodes.filter((n) => hasRole(n, STATIC_VARIANT_CALL_ROLE)).length;
+  if (calls > 0) return calls;
+  const one = nodes.find((n) => hasRole(n, STATIC_VARIANTS_ROLE) && n.type === "image_generate");
+  if (one) return typeof one.params?.n === "number" ? one.params.n : 1;
+  if (nodes.some((n) => hasRole(n, STATIC_FIX_ROLE))) return 1;
+  return nodes.filter((n) => n.type === "image_generate" && /^ad(_[a-z])?$/.test(String(n.id))).length;
+}
+function staticRunShape(parsed) {
+  const nodes = nodesOf2(parsed);
+  const renders = nodes.filter((n) => n.type === "image_generate" && typeof n.id === "string");
+  const candidates = variantCount(nodes);
+  const logoIds = new Set(nodes.filter((n) => hasRole(n, BRAND_LOGO_ROLE)).map((n) => String(n.id)));
+  const logo = nodes.some((n) => hasRole(n, LOGO_COMPOSITE_ROLE)) || renders.some((n) => {
+    const refs = n.inputs?.reference;
+    return (Array.isArray(refs) ? refs : [refs]).some((r) => logoIds.has(refId2(r) ?? ""));
+  }) || // On one picture each size's words call places the logo file.
+  nodes.some((n) => n.type === "static_format" && logoIds.has(refId2(n.inputs?.logo) ?? ""));
+  const masterId = nodes.find((n) => hasRole(n, STATIC_MASTER_ROLE))?.id;
+  const adapt = nodes.find((n) => hasRole(n, STATIC_ADAPT_ROLE));
+  return {
+    candidates,
+    judged: candidates > 1 && nodes.some(
+      (n) => n.type === "image_select" && (hasRole(n, STATIC_PICK_ROLE) || n.id === "pick") || hasRole(n, VARIANT_PREFILTER_ROLE) && typeof n.params?.judge_model === "string"
+    ),
+    relays: masterId !== void 0 ? 0 : Math.max(0, renders.length - candidates),
+    cuts: nodes.filter((n) => {
+      const from = refId2(n.inputs?.image);
+      return hasRole(n, STATIC_SIZE_ROLE) && from !== null && from === masterId;
+    }).length,
+    relaid: nodes.filter((n) => hasRole(n, STATIC_ADAPT_FORMAT_ROLE)).length,
+    adapted: Array.isArray(adapt?.params?.formats) ? adapt.params.formats.length : 0,
+    plates: nodes.some((n) => hasRole(n, STATIC_LEAD_ROLE)) ? nodes.filter((n) => hasRole(n, STATIC_VARIANT_CALL_ROLE)).length : 0,
+    // The lead the master delivers is the chosen option's own words, replayed: not a size set again.
+    worded: nodes.filter((n) => hasRole(n, STATIC_FORMAT_ROLE) && n.id !== masterReads(nodes)).length,
+    logo
+  };
+}
+function masterReads(nodes) {
+  return refId2(nodes.find((n) => hasRole(n, STATIC_MASTER_ROLE))?.inputs?.image);
+}
+function shapeHint(shape, copy) {
+  const drawn = shape.plates > 0 ? " (a picture each without the ad's words, the lead size's words set on it)" : "";
+  const variants = `${shape.candidates} variant${shape.candidates === 1 ? "" : "s"} rendered${drawn}${shape.judged ? ", ranked by the checks with a judge on a tie" : ", no judge"}`;
+  const sizes = [
+    ...shape.worded > 0 ? [`${shape.worded} size${shape.worded === 1 ? "" : "s"} cut from the chosen picture with ${shape.worded === 1 ? "its" : "their"} words set for ${shape.worded === 1 ? "it" : "them"} (one request each)`] : [],
+    ...shape.relaid > 0 ? [`${shape.relaid} size${shape.relaid === 1 ? "" : "s"} re-laid out from the chosen picture (one request each)`] : [],
+    ...shape.cuts > 0 ? [`${shape.cuts} size${shape.cuts === 1 ? "" : "s"} cut from the chosen picture`] : [],
+    ...shape.adapted > 0 ? [`${shape.adapted} adapted from it`] : [],
+    ...shape.relays > 0 ? [`${shape.relays} other format${shape.relays === 1 ? "" : "s"} re-laid from the winner`] : []
+  ];
+  const text = copy === 0 ? "no copy (the picture is the ad)" : "the copy set by the model and read back word for word";
+  return `This run: ${variants}${sizes.length > 0 ? `; ${sizes.join("; ")}` : ""}; ${text}; ${shape.logo ? "the brand logo on the ad from its real file" : "no logo"}.`;
+}
+var PAID_FOR = {
+  edit: "one edit of the version shown",
+  sizes: "only the sizes asked for, laid out again",
+  options: "new options from scratch, every size made from the one chosen"
+};
+function runCostHint(stats, kind) {
+  if (!stats) return null;
+  const cached = stats.cached_nodes > 0 ? ` (${stats.cached_nodes} of ${stats.total_nodes} steps came from the cache, free)` : "";
+  return `This run cost ${Math.round(stats.total_credits)} credits: ${PAID_FOR[kind]}${cached}.`;
+}
+async function textOf(ref) {
+  const r = ref;
+  try {
+    if (typeof r?.path === "string") return await readFile2(r.path, "utf8");
+    if (typeof r?.url === "string") {
+      const res = await fetch(r.url);
+      return res.ok ? await res.text() : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function sizeShapeOf(canvas) {
+  return isPlateCanvas(canvas) ? "plate" : "relayout";
+}
+function oneSizeFix(shape) {
+  return shape === "plate" ? "`baker canvas run \u2026 --regenerate format_<size>` (for example `format_9x16`) sets that size's words again on the same picture (one request)" : "`baker canvas run \u2026 --regenerate adapt_<size>` (for example `adapt_9x16`) lays out that size again from the same picture (one request)";
+}
+function fixHint(shape) {
+  return `One thing wrong in a version that is otherwise right: \`baker canvas run \u2026 --fix "<what to change>"\` edits that version and changes only that, keeping the picture, the layout and the other words (one render). Wrong or missing words: check the lines in prompt.json \`copy\` are exactly what should be printed, shorten a line the model keeps breaking, and re-run: a change only to copy, positions or colours is made as an edit of the version shown. Wrong picture, colour or subject: edit prompt.json's \`scene\`, \`colors\` or \`references\`. Layout or a logo drawn wrong: say in each line's \`position\` (and \`scene.layout\`) where it sits, by what is around it. A right prompt that rolled badly: \`baker canvas run \u2026 --regenerate static_variants\` renders new options (every size follows from the new pick). One size wrong while the chosen picture is right (words cut or too small, the button small, something drawn twice): ${oneSizeFix(shape)}.`;
+}
+function verdictHints(verdict, shape = "plate") {
+  if (verdict === "needs_fixes") {
+    const cost = shape === "plate" ? "each size's words take one request" : "each re-laid-out size takes one request; a cut is free";
+    return [
+      `NOT READY: the finished ad has blocking problems. Do not present it as done, and never ask the person whether to fix them: fix them now, inside this version. A defect in a version that is otherwise right is a \`--fix\`: it edits the chosen picture only, and every size is made from it again (${cost}). The same defect after a fix means the fix does not work: change the spec (prompt.json) or the approach, never the same retry. If it still cannot be fixed, show the person the best version and say in one plain sentence what is left, in their words ("the logo sits where Stories covers it"), without a question; never record your own checks as their feedback.`,
+      fixHint(shape)
+    ];
+  }
+  if (verdict === "not_reviewed") {
+    return [
+      "The finished ad was NOT reviewed: no model gateway key here, or the review model did not answer twice. Look at every word of every format yourself before showing it, or re-run the same command (every node comes from the cache) to review it again."
+    ];
+  }
+  if (verdict === "ready") {
+    return ["Reviewed every format of the finished ad: every word read back exactly, nothing to fix.", SHOW_IT];
+  }
+  return verdict === "ready_with_notes" ? [SHOW_IT] : [];
+}
+function verdictBrief(verdict, shape = "plate") {
+  if (verdict === "needs_fixes") {
+    const size = shape === "plate" ? "format_<size>" : "adapt_<size>";
+    return [
+      `NOT READY: fix every blocking finding now, never asking the person: \`--fix "<what to change>"\` for one thing wrong, \`--regenerate ${size}\` for one size. Never present it as done.`
+    ];
+  }
+  if (verdict === "not_reviewed") return verdictHints(verdict, shape);
+  const show = 'Show it as a Version ("Version 2"), never a run id or a file; never ask which to keep or whether to publish.';
+  if (verdict === "ready") return [`Reviewed every format: nothing to fix. ${show}`];
+  return verdict === "ready_with_notes" ? [show] : [];
+}
+var SHOW_IT = `Show it as a Version ("Version 2"), never a run id or a file, in one line: the idea's message, who it is for, the customer quote it stands on (or that it is an explore bet), and the finding it answers. Name the versions you would run first; never ask which to keep or whether to publish: the person answers in their own time.`;
+function allowedSceneWords(spec) {
+  return [.../* @__PURE__ */ new Set([...spec.scene_text, ...spec.third_party_brands.map((b) => b.name)])];
+}
+function brandPalette(brand) {
+  if (!brand) return [];
+  const named = [brand.ink, brand.accent, brand.cta, brand.ground, ...brand.palette];
+  return [...new Set(named.filter((hex) => typeof hex === "string"))];
+}
+function safeAreaPlacements(viewer) {
+  const named = (viewer?.placements ?? []).filter((p) => p !== "automatic");
+  return named.length > 0 && named.length === viewer?.placements.length ? named : void 0;
+}
+function canvasPlacements(parsed) {
+  const node = nodesWithRole(parsed, VARIANT_PREFILTER_ROLE)[0];
+  const placements = node?.params?.placements;
+  return Array.isArray(placements) && placements.length > 0 && placements.every((p) => typeof p === "string") ? placements : void 0;
+}
+async function reviewStaticRun(opts) {
+  const targets = staticReviewTargets(opts.parsed, opts.output);
+  if (!targets) return null;
+  const prefilterId = nodesWithRole(opts.parsed, VARIANT_PREFILTER_ROLE)[0]?.id;
+  const tieBreak = prefilterId ? opts.outputsByNode[prefilterId]?.reasoning : void 0;
+  const pickId = nodesWithRole(opts.parsed, STATIC_PICK_ROLE)[0]?.id ?? "pick";
+  const reasoning = typeof tieBreak === "string" ? tieBreak : await textOf(opts.outputsByNode[pickId]?.reasoning);
+  const judge = reasoning ? parseJudgeScores(reasoning) : null;
+  let copy = [];
+  let mechanisms = [];
+  let intended = {};
+  let expectLogo = false;
+  let concept = null;
+  let uncast = [];
+  let nobody = false;
+  let brand = opts.brandName;
+  let lockup = [...opts.lockup ?? []];
+  let sceneText = [];
+  let lines = [];
+  let native;
+  let palette = [];
+  try {
+    const spec = readAdSpec(JSON.parse(await readFile2(targets.promptPath, "utf8")));
+    copy = spec.copy.map((l) => l.text);
+    lines = spec.copy.map((l) => ({ text: l.text, lettering: l.lettering, ...l.role ? { role: l.role } : {} }));
+    if (spec.native) {
+      copy = nativeCopy(spec.native);
+      lines = copy.map((text) => ({ text, lettering: "designed" }));
+      native = nativeSurfaceName(spec.native);
+    }
+    palette = spec.native ? [] : brandPalette(spec.brand);
+    mechanisms = spec.mechanism.map((m) => m.device);
+    brand = spec.brand?.name ?? opts.brandName;
+    const sells = (await readCompanyReading(path2.resolve(path2.dirname(targets.promptPath), "../../..")))?.sells;
+    intended = {
+      ...spec.message?.trim() ? { offer: spec.message.trim() } : {},
+      ...spec.viewer?.who.trim() ? { persona: spec.viewer.who.trim() } : {},
+      ...spec.recognition?.trim() ? { recognition: spec.recognition.trim() } : {},
+      ...sells ? { sells } : {}
+    };
+    lockup = [.../* @__PURE__ */ new Set([...spec.brand?.lockup ?? [], ...lockup])];
+    sceneText = [
+      ...allowedSceneWords(spec),
+      ...spec.native ? nativeChrome(spec.native, spec.viewer?.market?.language, interfaceWordsOf(opts.parsed)) : []
+    ];
+    expectLogo = spec.logo && !spec.native && staticRunShape(opts.parsed).logo;
+    concept = conceptSummary(spec);
+    const cacheDir = path2.join(findWorkspaceRoot(path2.dirname(targets.promptPath)) ?? path2.dirname(targets.promptPath), "canvas", ".cache");
+    const people = spec.native ? [] : await peopleReader(cacheDir, (u) => opts.onSpend?.(u))(copy) ?? [];
+    uncast = uncastPeople(spec, people);
+    nobody = !spec.native && castsNobody(spec);
+  } catch {
+    copy = [];
+  }
+  const shape = staticRunShape(opts.parsed);
+  const placements = canvasPlacements(opts.parsed) ?? safeAreaPlacements(opts.viewer);
+  const masterFormat = staticMasterFormat(opts.parsed) ?? void 0;
+  const glancing = opts.glance === false ? Promise.resolve(null) : glanceAtFinished(
+    targets.images,
+    opts.viewer ?? STRANGER,
+    intended,
+    opts.glance ?? gatewayGlanceModel(opts.onSpend),
+    opts.onSpend
+  ).catch(() => null);
+  const comparing = opts.previous ? nearIdenticalFindings(targets.images, opts.previous).catch(() => []) : Promise.resolve([]);
+  const leadFormat = masterFormat ?? targets.images[0]?.format ?? "";
+  const lead = targets.images.find((i) => i.format === leadFormat);
+  const drawn = native || !lead ? [] : drawnSizes(opts.parsed, targets.images.map((i) => i.format), leadFormat);
+  const matching = lead && drawn.length > 0 ? compareSizes(
+    lead,
+    targets.images.filter((i) => drawn.includes(i.format)),
+    { ...opts.onSpend ? { onSpend: opts.onSpend } : {} }
+  ).catch(() => drawn.map((format) => ({ format, compared: false, differences: [] }))) : Promise.resolve([]);
+  const untouched = opts.settled ? await samePictureSizes(targets.images, opts.settled.images) : [];
+  const changed = targets.images.filter((i) => !untouched.includes(i.format));
+  const held = await heldRules(path2.dirname(targets.promptPath)).catch(() => ({ rules: [] }));
+  const review = await reviewRenderedStatic({
+    images: changed.length > 0 ? changed : targets.images,
+    rules: held.rules,
+    copy,
+    lines,
+    palette,
+    ...placements ? { placements } : {},
+    ...brand ? { brand } : {},
+    ...lockup.length > 0 ? { lockup } : {},
+    ...sceneText.length > 0 ? { sceneText } : {},
+    ...masterFormat ? { masterFormat } : {},
+    ...expectLogo ? { expectLogo } : {},
+    ...concept && concept.mustKeep.length > 0 && referenceSource(opts.parsed) ? { concept: { ...concept, reference: referenceSource(opts.parsed) } } : {},
+    logo: shape.logo,
+    ...native ? { native } : {},
+    ...uncast.length > 0 ? { uncastPeople: uncast } : {},
+    ...nobody ? { castsNobody: true } : {},
+    ...native ? { scrolled: scrolledLines(opts.parsed, opts.outputsByNode) } : {},
+    mechanisms,
+    ...opts.viewer ? { viewer: describeViewer(opts.viewer) } : {},
+    onSpend: opts.onSpend
+  });
+  const [glanced, compared, matched] = await Promise.all([glancing, comparing, matching]);
+  const glance = review === null ? null : glanced;
+  const unchanged = review === null ? [] : compared;
+  const sized = sizeFactFindings(opts.parsed, opts.outputsByNode);
+  const logoChecked = expectLogo && review !== null;
+  const placedLogo = logoChecked ? logoPlacementFindings(opts.parsed, opts.outputsByNode) : [];
+  const deliveredLogo = logoChecked ? await deliveredLogoFindings(opts.parsed, opts.outputsByNode, changed.length > 0 ? changed : targets.images, [
+    .../* @__PURE__ */ new Set([...palette, "#FFFFFF", "#000000"])
+  ]).catch(() => []) : [];
+  const differing = matched.flatMap((m) => m.differences.length > 0 ? [sizeDifferenceFinding(m.format, m.differences)] : []);
+  const fresh = review === null ? null : [...review, ...glance ?? [], ...unchanged, ...sized, ...placedLogo, ...deliveredLogo, ...differing];
+  const reviewed = fresh === null || !opts.settled ? fresh : carryUnchanged(fresh, opts.settled.review, untouched);
+  const verdict = staticVerdict(reviewed);
+  const hints = verdictHints(verdict, sizeShapeOf(opts.parsed));
+  const notes = [];
+  const note = (hint) => {
+    hints.push(hint);
+    notes.push(hint);
+  };
+  const lost = keptLostHint(reviewed ?? [], await ideaOf(targets.promptPath));
+  if (lost) note(lost);
+  const sizeHints = verdict === "needs_fixes" ? sizeFixHints(opts.parsed, reviewed) : [];
+  const sizesFirst = sizeHints[0]?.startsWith("Do this first") === true;
+  if (sizesFirst) hints.push(...sizeHints);
+  for (const f of reviewed ?? []) hints.push(`${f.severity === "blocking" ? "Must fix" : "Should fix"}: ${f.what}`);
+  if ((reviewed ?? []).some((f) => f.severity === "blocking" && f.kind?.item === "rule" && f.kind.element === "copy")) {
+    note(
+      'A company rule the words break is yours to rewrite in prompt.json\'s `copy` (no automatic round changes the words); only when the person asked for those words, keep them and add `"waive": [{"rule": "<id>", "why": "<their ask>"}]`.'
+    );
+  }
+  if (review !== null && glance === null && opts.glance !== false) {
+    note("The finished ad was not shown to a stranger at a glance (the model did not answer): look at the 4:5 at phone size yourself and say what it sells in three seconds.");
+  }
+  const unmatched = review === null ? [] : matched.filter((m) => !m.compared).map((m) => m.format);
+  if (unmatched.length > 0) {
+    note(
+      `The ${unmatched.join(" and ")} could not be compared with the ${leadFormat} (the model did not answer): look at them side by side yourself, for the same people and product, shown once, unstretched.`
+    );
+  }
+  if (!sizesFirst) hints.push(...sizeHints);
+  hints.push(shapeHint(shape, copy.length));
+  hints.push(...variantHints(judge, prefilterOutcome(opts.parsed, opts.outputsByNode)));
+  return { review: reviewed, verdict, judge, hints, notes };
+}
+function scrolledLines(parsed, outputsByNode) {
+  return Object.fromEntries(
+    nodesOf2(parsed).flatMap((n) => {
+      const out = typeof n.id === "string" ? outputsByNode[n.id] : void 0;
+      const format = n.params?.format;
+      return n.type === "static_native" && typeof format === "string" && Array.isArray(out?.scrolled) ? [[format, out.scrolled.filter((t) => typeof t === "string")]] : [];
+    })
+  );
+}
+async function ideaOf(promptPath) {
+  const definition = await readFile2(path2.join(path2.dirname(promptPath), "_definition.md"), "utf8").catch(() => "");
+  const idea = frontmatterOf(definition)?.idea;
+  return typeof idea === "string" && idea.trim() ? idea.trim() : void 0;
+}
+function referenceSource(parsed) {
+  const original = nodesOf2(parsed).find((n) => n.id === "original" && n.type === "ingest");
+  const source = original?.params?.url ?? original?.params?.path;
+  return typeof source === "string" && !source.includes("[TODO") ? source : null;
+}
+function interfaceWordsOf(parsed) {
+  const nodes = parsed?.nodes;
+  const screen = Array.isArray(nodes) ? nodes.find((n) => n?.type === "static_native") : void 0;
+  return readInterfaceWords(screen?.params?.interface_words) ?? void 0;
+}
+var STRANGER = { temperature: "cold", knows: [], placements: ["automatic"], source: "knowledge", reasons: [] };
+async function glanceAtFinished(images, viewer, intended, ask, onSpend) {
+  const shown = images.find((i) => i.format === "4:5") ?? images[0];
+  if (!shown) return null;
+  return await glanceCheck({
+    image: shown.path,
+    format: shown.format,
+    viewer,
+    intended,
+    ask,
+    judge: jevReadJudge(onSpend),
+    ...viewer.market ? { market: describeMarket(viewer.market) } : {}
+  });
+}
+function sizeFixHints(parsed, review) {
+  const cut = new Set(nodesWithRole(parsed, STATIC_FORMAT_ROLE).map((n) => n.id));
+  const relaid = [...nodesWithRole(parsed, STATIC_ADAPT_FORMAT_ROLE).map((n) => n.id), ...cut];
+  const blocking = (review ?? []).filter((f) => f.severity === "blocking");
+  const regenerate = relaid.flatMap((id) => {
+    const format = formatOfSizeNode(parsed, id);
+    if (!format || !blocking.some((f) => f.what.startsWith(`${format}:`))) return [];
+    return [
+      cut.has(id) ? `The ${format}'s words alone need fixing and the picture is right: \`baker canvas run \u2026 --regenerate ${id}\` sets the ${format}'s words again on the same picture (one request). If the picture itself is wrong, \`--fix\` it instead: every size's words are set again on the corrected picture.` : `The ${format} alone needs fixing and the chosen picture is right: \`baker canvas run \u2026 --regenerate ${id}\` lays out the ${format} again from the same picture (one request). If the chosen picture itself is wrong, \`--fix\` it instead: every size follows.`
+    ];
+  });
+  const relaidFormats = relaid.map((id) => formatOfSizeNode(parsed, id)).filter((f) => Boolean(f));
+  const sizesOnly = regenerate.length > 0 && blocking.every((f) => relaidFormats.some((format) => f.what.startsWith(`${format}:`)));
+  const lead = sizesOnly ? regenerate.map((h, i) => i === 0 ? `Do this first, not a --fix: ${h}` : h) : regenerate;
+  return [...lead, ...safeFitHints(parsed, blocking)];
+}
+var COVERED = / sits? where .+? covers? (?:it|them) /;
+function safeFitHints(parsed, blocking) {
+  return nodesWithRole(parsed, STATIC_SAFE_FIT_ROLE).flatMap((n) => {
+    const format = typeof n.params?.format === "string" ? n.params.format : formatOfSlug(n.id.replace(/^safe_/, ""));
+    if (!blocking.some((f) => f.what.startsWith(`${format}:`) && COVERED.test(f.what))) return [];
+    return [
+      `The ${format} was already shrunk and shifted automatically to clear what the app covers; small misses are corrected that way, so this one is too large for it. Change the layout itself (shorter copy, fewer lines, a smaller block of text) rather than a \`--fix\` asking to move it, which moves it only about 1%.`
+    ];
+  });
+}
+var SIZE_FACT_FINDING = {
+  band_too_far: {
+    what: (format) => `${format}: the words reach too far past the part of the frame the app leaves clear to be moved inside it; set them inside it.`,
+    kind: { item: "safe_zone", element: "copy", defect: "other", edges: [] }
+  },
+  words_over_face: {
+    what: (format) => `${format}: the words were set over a face; set them where no face is.`,
+    kind: { item: "layout", element: "copy", defect: "other", edges: [] }
+  },
+  words_misaligned: {
+    what: (format) => `${format}: ${PATCHED_WORDS}, which shows as a box; set them again on the same picture.`,
+    kind: { item: "layout", element: "copy", defect: "other", edges: [] }
+  },
+  words_not_read: {
+    what: (format) => `${format}: ${UNREAD_WORDS}, so the picture around them may have been redrawn; set them again on the same picture.`,
+    kind: { item: "layout", element: "copy", defect: "other", edges: [] }
+  },
+  subject_covered: {
+    what: (format, facts) => `${format}: the words hide ${(facts.covered ?? ["the product"]).join(" and ")}, which the other sizes show; set them where it stays in view.`,
+    kind: { item: "layout", element: "copy", defect: "other", edges: [] }
+  },
+  subject_cut: {
+    what: (format) => `${format}: no cut of the picture keeps every person and product whole in this size.`,
+    kind: { item: "picture", element: "picture", defect: "cut", edges: [] }
+  }
+};
+function coveredIn(facts) {
+  if (facts === void 0 || facts === null || typeof facts !== "object") return null;
+  const covered = facts.covered;
+  return Array.isArray(covered) ? covered.filter((c) => typeof c === "string") : [];
+}
+function hiddenEverywhere(sizes, outputsByNode) {
+  const lists = sizes.map((s) => ({ ...s, covered: coveredIn(outputsByNode[s.id]?.facts) }));
+  const labels = new Set(
+    (lists[0]?.covered ?? []).filter((label) => lists.length > 1 && lists.every((s) => s.covered?.includes(label)))
+  );
+  const first = lists.find((s) => s.format && s.covered?.some((label) => labels.has(label)));
+  const notes = first?.format && labels.size > 0 ? [
+    {
+      severity: "warning",
+      what: `${first.format}: the words hide ${[...labels].join(" and ")} in every size; set them where it stays in view if it is what the ad sells.`,
+      kind: { item: "layout", element: "copy", defect: "other", edges: [] }
+    }
+  ] : [];
+  return { labels, notes };
+}
+function sizeFactFindings(parsed, outputsByNode) {
+  const added = paintedAdditions(parsed, outputsByNode);
+  const sizes = nodesWithRole(parsed, STATIC_FORMAT_ROLE);
+  const everywhere = hiddenEverywhere(
+    sizes.map((n) => ({ id: n.id, format: formatOfSizeNode(parsed, n.id) })),
+    outputsByNode
+  );
+  const found = sizes.flatMap((n) => {
+    const format = formatOfSizeNode(parsed, n.id);
+    const facts = outputsByNode[n.id]?.facts ?? {};
+    const shownElsewhere = (coveredIn(facts) ?? []).some((label) => !everywhere.labels.has(label));
+    const said2 = typeof facts.reason === "string" && (facts.reason !== "subject_covered" || shownElsewhere) ? SIZE_FACT_FINDING[facts.reason] : void 0;
+    const patched = facts.reason !== "words_misaligned" && facts.words_mode !== "whole" && typeof facts.residual === "number" && facts.residual > MISALIGNED ? SIZE_FACT_FINDING.words_misaligned : void 0;
+    const covered = (coveredIn(facts) ?? []).filter((label) => !everywhere.labels.has(label));
+    const fromPlate = refId2(n.inputs?.plate);
+    const extra = fromPlate ? added.get(fromPlate) : void 0;
+    if (!format) return [];
+    return [
+      ...[said2, patched].flatMap(
+        (f) => f ? [{ severity: "blocking", what: f.what(format, covered.length > 0 ? { covered } : {}), kind: f.kind }] : []
+      ),
+      ...extra ? [
+        {
+          severity: "blocking",
+          what: `${format}: the picture painted wider from the chosen one shows ${extra.join(", ")}, which the other sizes do not. It must show the main size's people and product, once each.`,
+          kind: { item: "sizes", element: "picture", defect: "other", edges: [] }
+        }
+      ] : []
+    ];
+  });
+  return [...found, ...everywhere.notes];
+}
+function paintedAdditions(parsed, outputsByNode) {
+  return new Map(
+    nodesWithRole(parsed, STATIC_PLATE_ROLE).flatMap((n) => {
+      const facts = outputsByNode[n.id]?.facts;
+      const added = Array.isArray(facts?.added) ? facts.added.filter((a) => typeof a === "string") : [];
+      return facts?.reason === "subject_added" && added.length > 0 ? [[n.id, added]] : [];
+    })
+  );
+}
+function drawnSizes(parsed, delivered, masterFormat) {
+  const others = delivered.filter((format) => format && format !== masterFormat);
+  const cut = nodesWithRole(parsed, STATIC_FORMAT_ROLE);
+  if (cut.length === 0) return others;
+  const painted = new Set(nodesWithRole(parsed, STATIC_PLATE_ROLE).map((n) => n.id));
+  const fromPainted = new Set(
+    cut.flatMap((n) => {
+      const plate = refId2(n.inputs?.plate);
+      const format = formatOfSizeNode(parsed, n.id);
+      return plate && painted.has(plate) && format ? [format] : [];
+    })
+  );
+  return others.filter((format) => fromPainted.has(format));
+}
+function formatOfSlug(slug) {
+  return slug.replace("x", ":").replace("_", ".");
+}
+function prefilterNodeId(parsed) {
+  return nodesWithRole(parsed, VARIANT_PREFILTER_ROLE)[0]?.id ?? null;
+}
+function prefilterOutcome(parsed, outputsByNode) {
+  const id = prefilterNodeId(parsed);
+  const out = id ? outputsByNode[id] : void 0;
+  return out && Array.isArray(out.dropped) ? out : null;
+}
+function prefilterSpend(parsed, outputsByNode, nodeRuns) {
+  const cached = (id2) => nodeRuns.some((r) => r.node_id === id2 && r.cached);
+  const id = prefilterNodeId(parsed);
+  const checks = id && !cached(id) ? prefilterOutcome(parsed, outputsByNode)?.usage ?? [] : [];
+  const fits = [
+    ...nodesWithRole(parsed, STATIC_SAFE_FIT_ROLE),
+    ...nodesWithRole(parsed, STATIC_PLACE_ROLE),
+    // A size cut from one picture reads its subjects and its words; a widened picture its subjects.
+    ...nodesWithRole(parsed, STATIC_LEAD_ROLE),
+    ...nodesWithRole(parsed, STATIC_FORMAT_ROLE),
+    ...nodesWithRole(parsed, STATIC_PLATE_ROLE),
+    // The logo's composite reads the size's words for its check.
+    ...nodesWithRole(parsed, LOGO_COMPOSITE_ROLE)
+  ].filter((n) => !cached(n.id)).flatMap((n) => {
+    const usage = outputsByNode[n.id]?.usage;
+    return Array.isArray(usage) ? usage : [];
+  });
+  return [...checks, ...fits];
+}
+function variantHints(judge, prefilter) {
+  const hints = [];
+  const dropped = prefilter?.dropped ?? [];
+  const kept = Array.isArray(prefilter?.images) ? prefilter.images.length : judge?.length ?? 0;
+  const total = dropped.length + kept;
+  if (prefilter?.flagged) {
+    hints.push(
+      `Every variant failed the checks; variant ${prefilter.flagged.index + 1} had the fewest problems and was kept: ${prefilter.flagged.reasons.join(" ")}`
+    );
+  } else if (dropped.length > 0) {
+    const list = dropped.map((d) => `variant ${d.index + 1} (${d.reasons.join(" ")})`).join("; ");
+    hints.push(`${dropped.length} of ${total} variants set aside by the checks before the judge: ${list}.`);
+  }
+  const alone = prefilter?.order?.length === 1 && !prefilter.flagged ? prefilter.order[0] : void 0;
+  if (alone !== void 0 && dropped.length > 0) {
+    hints.push(
+      `The checks ranked variant ${alone + 1} best, so no judge was needed; the others stay in this run as options the person can switch to (\`baker canvas run --use-variant\`).`
+    );
+  }
+  const winner = judge ? judgeWinner(judge) : null;
+  if (judge && winner) {
+    const gone = new Set(dropped.map((d) => d.index));
+    const shown = prefilter?.order ?? Array.from({ length: total }, (_, i) => i).filter((i) => !gone.has(i));
+    const variant = (shown[winner.image - 1] ?? winner.image - 1) + 1;
+    const why = winner.of === void 0 ? `${winner.total}/${Object.keys(winner.scores).length * 5}` : `first on ${Object.entries(winner.scores).filter(([, beaten]) => beaten === winner.of).map(([criterion]) => criterion.replace(/_/g, " ")).join(", ") || "none of the criteria alone"}`;
+    hints.push(
+      `The judge picked variant ${variant} of the ${judge.length} it compared (${why}); the others it compared stay in this run as options the person can switch to (\`baker canvas run --use-variant\`).`
+    );
+  }
+  return hints;
+}
+
+// src/commands/canvas/render-state.ts
+import { mkdir as mkdir2, readdir, readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+var RENDER_STATE_DIR = ".rendered";
+function statePath(canvasRoot, slug) {
+  return path3.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);
+}
+async function readRenderState(canvasRoot, slug) {
+  try {
+    const parsed = JSON.parse(await readFile3(statePath(canvasRoot, slug), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function latestVersion(canvasRoot, slug) {
+  return (await readRenderState(canvasRoot, slug)).rendered?.runId ?? null;
+}
+async function updateRenderState(canvasRoot, slug, patch) {
+  try {
+    const next = { ...await readRenderState(canvasRoot, slug), ...patch };
+    await mkdir2(path3.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });
+    await writeFile2(statePath(canvasRoot, slug), `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+async function recordRenderAttempt(canvasRoot, slug, sourceSha) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, { attempted: { sourceSha, at: Date.now() } });
+}
+async function recordRendered(canvasRoot, slug, sourceSha, runId, drawn = {}) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, {
+    rendered: { sourceSha, runId, at: Date.now() },
+    ...drawn.prompt !== void 0 ? { prompt: drawn.prompt } : {},
+    ...drawn.anchor ? { anchor: drawn.anchor } : {},
+    ...drawn.idea ? { idea: drawn.idea } : {},
+    lastFix: drawn.lastFix,
+    picture: drawn.picture,
+    ...drawn.seriesLeadRun ? { seriesLeadRun: drawn.seriesLeadRun } : {}
+  });
+}
+async function recordSeen(canvasRoot, slug, seen) {
+  await updateRenderState(canvasRoot, slug, { seen });
+}
+async function recordIdeaLines(canvasRoot, slug, idea) {
+  if ((await readRenderState(canvasRoot, slug)).idea) return;
+  await updateRenderState(canvasRoot, slug, { idea });
+}
+async function recordReviewOutcome(canvasRoot, slug, outcome) {
+  await updateRenderState(canvasRoot, slug, outcome);
+}
+async function recordSeriesLeadRun(canvasRoot, slug, leadRunId) {
+  await updateRenderState(canvasRoot, slug, { seriesLeadRun: leadRunId });
+}
+async function recordSnapshot(canvasRoot, slug, snapshot) {
+  await updateRenderState(canvasRoot, slug, { snapshot });
+}
+function isRenderStale(state, currentSourceSha) {
+  if (!state.rendered) return false;
+  if (!isSourceStale(currentSourceSha, state.rendered.sourceSha)) return false;
+  return state.attempted?.sourceSha !== currentSourceSha;
+}
+async function staleCreatives(workspaceRoot, turnId) {
+  const creativesDir = path3.join(workspaceRoot, "src", "creatives");
+  const canvasRoot = path3.join(workspaceRoot, "canvas");
+  const turnRenders = turnId === void 0 ? void 0 : await readTurnRenders(path3.join(canvasRoot, ".cache"));
+  let slugs;
+  try {
+    slugs = (await readdir(creativesDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const stale = [];
+  for (const slug of slugs.sort()) {
+    const state = await readRenderState(canvasRoot, slug);
+    if (!state.rendered) continue;
+    const canvasPath = path3.join(creativesDir, slug, `${slug}.canvas.json`);
+    let prepared;
+    try {
+      prepared = await prepareCanvas(canvasPath, { write: false });
+    } catch {
+      continue;
+    }
+    if (unsuppliedPlaceholderAssets(prepared.fileGraph).length > 0) continue;
+    const current = prepared.sourceSha;
+    if (!current || !isRenderStale(state, current)) continue;
+    const promptOnDisk = await readFile3(path3.join(creativesDir, slug, "prompt.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+    const promptNow = isStaticAdCanvas(prepared.canvas) ? promptOnDisk : null;
+    const refusal = turnRenderRefusal(turnRenders, turnId, slug, {
+      correction: plainRunEdit(prepared.canvas, state.prompt, promptNow) !== null,
+      shape: sizeShapeOf(prepared.fileGraph)
+    });
+    stale.push({
+      slug,
+      canvasPath: path3.relative(workspaceRoot, canvasPath).split(path3.sep).join("/"),
+      renderedRunId: state.rendered.runId,
+      sourceSha: current,
+      ...refusal ? { refusedThisTurn: `${refusal.message} ${refusal.fix}` } : {}
+    });
+  }
+  return stale;
+}
+async function clearLegacyDirtyMarker(canvasRoot, slug) {
+  await rm(path3.join(canvasRoot, ".dirty", `${slug}.json`), { force: true }).catch(() => void 0);
+}
+
+export {
+  specEditInstruction,
+  frameChanges,
+  repeatsFailedFix,
+  fixMemoryOf,
+  persistingDefects,
+  pictureEdit,
+  plainRunEdit,
+  isStaticAdCanvas,
+  peopleReader,
+  AUTO_FIX_ROUNDS,
+  lostVital,
+  stopsWithoutRepair,
+  autoFixStep,
+  correctFrom,
+  placedTooFar,
+  formatOfSizeNode,
+  rendersNewPicture,
+  paidFor,
+  withRelayNote,
+  withRelayEdit,
+  withSizesFollowingFix,
+  withExtendedSizes,
+  withDeliveredSizes,
+  staticReviewTargets,
+  runCostHint,
+  sizeShapeOf,
+  oneSizeFix,
+  verdictBrief,
+  reviewStaticRun,
+  prefilterSpend,
+  readRenderState,
+  latestVersion,
+  recordRenderAttempt,
+  recordRendered,
+  recordSeen,
+  recordIdeaLines,
+  recordReviewOutcome,
+  recordSeriesLeadRun,
+  recordSnapshot,
+  staleCreatives,
+  clearLegacyDirtyMarker
+};
+//# sourceMappingURL=chunk-P7OX5Y75.js.map