@koda-sl/baker-cli 0.569.0 → 0.571.0-dev.6a3439a0a

package/dist/chunk-3UNMVVSI.js

@@ -0,0 +1,917 @@
+import {
+  finalOutputLabelsFromCanvas
+} from "./chunk-PR5OPERY.js";
+import {
+  BRAND_LOGO_ROLE,
+  CLAIMS_MODEL,
+  CLAIMS_REQUEST,
+  PATCHED_WORDS,
+  PEOPLE_PROMPT_VERSION,
+  STATIC_AD_ROLE,
+  UNREAD_WORDS,
+  carryUnchanged,
+  deliveredLogoFindings,
+  formatOfSizeNode,
+  keptLostHint,
+  logoPlacementFindings,
+  peoplePrompt,
+  plainRunEdit,
+  prepareCanvas,
+  readPeople,
+  uncastPeople,
+  unsuppliedPlaceholderAssets
+} from "./chunk-MZLPOYCC.js";
+import {
+  ViewerAnswerSchema,
+  describeViewer,
+  jevReadJudge,
+  judgeViewerAnswer,
+  misreadings,
+  readTurnRenders,
+  sureEnough,
+  turnRenderRefusal
+} from "./chunk-TCLJRWST.js";
+import {
+  heldRules
+} from "./chunk-CST52ZME.js";
+import {
+  readCompanyReading
+} from "./chunk-Z7ICQKC2.js";
+import {
+  frontmatterOf
+} from "./chunk-NOCBNING.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-DGHSXHZR.js";
+import {
+  MISALIGNED,
+  compareSizes,
+  sizeDifferenceFinding
+} from "./chunk-JGSEHX2Q.js";
+import {
+  LOGO_COMPOSITE_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,
+  castsNobody,
+  isPlateCanvas,
+  nodesWithRole,
+  staticMasterFormat
+} from "./chunk-Z5BG47PO.js";
+import {
+  bytesOf,
+  judgeWinner,
+  nearIdenticalFindings,
+  parseJudgeScores,
+  reviewRenderedStatic,
+  samePictureSizes,
+  staticVerdict
+} from "./chunk-LAMSUL26.js";
+import {
+  conceptSummary,
+  nativeChrome,
+  nativeCopy,
+  nativeSurfaceName,
+  readAdSpec,
+  readInterfaceWords
+} from "./chunk-J4AWNWKN.js";
+import {
+  askAboutImages,
+  askAboutText
+} from "./chunk-GRX3JXSR.js";
+import {
+  GLANCE_CHECK_MODEL
+} from "./chunk-F3CZFUXZ.js";
+import {
+  describeMarket
+} from "./chunk-2WZI36D3.js";
+import {
+  isSourceStale
+} from "./chunk-6DSPB6YA.js";
+
+// 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 said = lines.filter((l) => l.trim());
+    if (said.length === 0) return [];
+    const key = createHash("sha256").update(JSON.stringify([PEOPLE_PROMPT_VERSION, CLAIMS_MODEL, said])).digest("hex");
+    const file = path.join(dir, `${key}.json`);
+    const cached = await readFile(file, "utf8").then((text) => readPeople(JSON.parse(text), said)).catch(() => null);
+    if (cached) return cached;
+    const answer = await askAboutText(CLAIMS_MODEL, peoplePrompt(said), spent, {
+      timeoutMs: PEOPLE_TIMEOUT_MS,
+      request: CLAIMS_REQUEST
+    });
+    const people = readPeople(answer, said);
+    if (people) {
+      await mkdir(dir, { recursive: true });
+      await writeFile(file, JSON.stringify(answer), "utf8");
+    }
+    return people;
+  };
+}
+
+// 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 said = miss.viewerSaid.trim() ? `"${miss.viewerSaid.trim()}"` : "nothing";
+  const what = QUESTION_WORDS[miss.question];
+  return miss.reason === "misread" ? `${what} (they were sure it is ${said})` : `${what} (they said ${said})`;
+}
+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/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 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 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 = nodesOf(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(refId(r) ?? ""));
+  }) || // On one picture each size's words call places the logo file.
+  nodes.some((n) => n.type === "static_format" && logoIds.has(refId(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 = refId(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 refId(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(
+    nodesOf(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 = nodesOf(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 said = 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 = refId(n.inputs?.plate);
+    const extra = fromPlate ? added.get(fromPlate) : void 0;
+    if (!format) return [];
+    return [
+      ...[said, 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 = refId(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 {
+  isStaticAdCanvas,
+  peopleReader,
+  staticReviewTargets,
+  runCostHint,
+  sizeShapeOf,
+  oneSizeFix,
+  verdictBrief,
+  reviewStaticRun,
+  prefilterSpend,
+  readRenderState,
+  latestVersion,
+  recordRenderAttempt,
+  recordRendered,
+  recordSeen,
+  recordIdeaLines,
+  recordReviewOutcome,
+  recordSeriesLeadRun,
+  recordSnapshot,
+  staleCreatives,
+  clearLegacyDirtyMarker
+};
+//# sourceMappingURL=chunk-3UNMVVSI.js.map