@koda-sl/baker-cli 0.447.0-dev.397af7869 → 0.452.0-dev.63867ce0e

package/README.md

@@ -1814,10 +1814,10 @@ baker creatives make <idea> [--slug <s>] [--adset <id>] [--reference <adId>] [--
 baker creatives learn [--days <n>] [--dry-run]                 # what each idea's ads did, written back onto the idea
 ```
 
-- `brief` returns a verdict, not raw numbers: `account.bottleneck` is `hook`, `after_click`, `none` or `too_little_data`. A part that cannot be read says `unavailable`. `market` says what competitors' ads already say (the followed brands, else the library), how sophisticated the market is, and which awareness stages nobody speaks to.
+- `brief` returns a verdict, not raw numbers: `account.bottleneck` is `hook`, `after_click`, `none` or `too_little_data`. A part that cannot be read says `unavailable`; the market searches (the followed brands, and the library for what COMPANY.md's first line says the company sells, in a few words) run at once and get 12 seconds, so a slow ad library leaves them out rather than holding the brief. With no ideas on file, its hint lists the values `awareness`, `angle` and `format` take. `market` says what competitors' ads already say (the followed brands, else the library), how sophisticated the market is, and which awareness stages nobody speaks to.
 - `ideas` is free and local. An idea's `evidence` resolves to `src/content/insights/` entries, or it is an `explore` bet. Numbers must be in the Knowledge or our own customers' quotes (a Reddit, forum or web quote never sources a claim), no two ideas may share an angle and format, and a review or testimonial format needs a quote from our own customer.
 - `learn` pools each built idea's creatives, judges them against the rest of the account's cost per result and writes `status` (`winner`, `failed`, `inconclusive`, `testing`) and a frozen `result` onto the idea. `ideas` then warns when a new idea repeats a failed one.
-- `make` builds one idea. A static searches the idea's container for ads made for our viewer, checks the closest three with `winning-ads fit` and scaffolds from the first that fits. For a new creative it starts scaffolding the best-ranked one while the fits are asked (kept when it fits, removed whole when another is kept), so the reference's describe pass no longer waits for them. A video idea takes its beats spec. Either way it records the idea on `_definition.md`, sets `prompt.json`'s `message` and syncs the definition. Drafted copy lines claiming a figure the company never wrote come back first in `hints`. When no proven ad fits (or with `--from-idea`), a static starts from the idea itself: `prompt.json` holds the message and placeholders, and `canvas run` refuses to render until the scene and copy are written.
+- `make` builds one idea. A static searches the idea's container for ads made for our viewer, checks the closest three with `winning-ads fit` and scaffolds from the first that fits. For a new creative it starts scaffolding the best-ranked one while the fits are asked (kept when it fits, stopped and removed whole when another or none is kept), so the reference's describe pass no longer waits for them. A creative whose ad is already written is never built over (`ALREADY_MADE`): edit its `prompt.json`, or pass `--slug` for another ad of the same idea. A video idea takes its beats spec. Either way it records the idea on `_definition.md`, sets `prompt.json`'s `message` and syncs the definition. Drafted copy lines claiming a figure the company never wrote come back first in `hints`. When no proven ad fits (or with `--from-idea`), a static starts from the idea itself: `prompt.json` holds the message and placeholders, and `canvas run` refuses to render until the scene and copy are written.
 
 ### Competitive Intelligence (`baker research`)
 
@@ -4627,7 +4627,7 @@ Open record keyed by the composition's `meta.json` inputs.
 
 ##### `static_prefilter`
 
-Local; no credits (one box-reader call per variant, about $0.005, which rides on the run record's review spend). Ranks a static ad's variants before the judge by the deterministic checks (blocking defects, then every line of the ad spec's copy read back with its box, the brand's logo found, the button's words, every word and the logo inside the master's band) and passes on only the best-ranked, so the judge only breaks an exact tie. A variant the reader could not read ties with the best. **Inputs:** `images` (the variants' whole list), `spec` (the ad spec, `$ref:prompt.asset`). **Params:** `formats` (the delivered sizes). **Outputs:** `images` (the best-ranked variants, in an order seeded by the pictures rather than the render order; never empty: when every variant fails, the one with the fewest defects passes as `flagged`), `order` (which variant each of `images` is), `dropped` (each variant set aside, with its index and reasons), `flagged` (the variant kept when all failed) and `usage` (the reader's spend). Scaffolded by `scaffold-static-ad` between the variants and the judge.
+Local; no credits (one box-reader call per variant, about $0.005, which rides on the run record's review spend). Ranks a static ad's variants before the judge by the deterministic checks (blocking defects, then every line of the ad spec's copy read back with its box, the brand's logo found, the button's words, every word and the logo inside the master's band) and passes on only the best-ranked, so the judge only breaks an exact tie. A variant the reader could not read ties with the best. **Inputs:** `images` (the variants' whole list), `spec` (the ad spec, `$ref:prompt.asset`). **Params:** `formats` (the delivered sizes). **Outputs:** `images` (the best-ranked variants, in an order seeded by the pictures rather than the render order; never empty: when every variant fails, the one with the fewest defects passes as `flagged`), `order` (which variant each of `images` is), `dropped` (each variant set aside, with its index and reasons), `flagged` (the variant kept when all failed), `image` (the chosen picture: when a variant rendered at another shape, a 3:4 for a 4:5, would lose a word or the button to a cut about its centre, it comes cut to the master's frame where every word stays whole, else as rendered) and `usage` (the reader's spend). Scaffolded by `scaffold-static-ad` between the variants and the judge.
 
 ##### `static_safe_fit`
 
@@ -6009,7 +6009,7 @@ The canvas is validated before it is written. stdout returns `{ ok, canvas_path,
 
 **Who sees the ad.** `--target-adset <id>` names the Meta ad set the ad will run in. Before anything is billed, the viewer its targeting reaches is read exactly as `baker ads meta adsets --audience` reads it (`temperature`, what they already `knows`, `placements`) and written to `_definition.md` as `targetAdSet` and `viewer` (an existing definition keeps every other field). The sizes, the brief and the prefilter keep clear of that viewer's placements (`staticSafeArea`; `automatic`, a bare `facebook`/`instagram` or no placements is Advantage+, Reels included), and every `baker canvas run` checks the ad against that viewer. With no ad account, give the viewer from the Knowledge: `--viewer-temperature cold|warm|hot [--viewer-knows brand,offer,product] [--viewer-placements <placement,…>]`, recorded with `source: knowledge`; next to `--target-adset` they correct the read, and its `reasons` say so. A bad value exits 2 (`invalid_viewer`) before any billed pass; an ad set that cannot be read never stops the scaffold (a hint says why, and the sizes keep clear of every placement). With neither flag, a `viewer` (or `targetAdSet`) already in `_definition.md` is used as it is. stdout carries `target_adset`, `viewer` and a `checklist.viewer` line.
 
-**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format; **every line of `prompt.json`'s copy (in-scene and designed alike) read back with its box by a box reader and compared** (a line more than 2% off, missing, or joined by words nobody asked for is blocking; case and punctuation fold, as does a capital I read as an l (one stroke in a sans-serif), accents do not; words the picture adds are blocking only when set at the copy's usual size or making a claim (a figure, a price, an offer), and otherwise a note, as a screen's code, a poster or a mug in the scene; a copy line is "on the ad twice" only when most of its words repeat, never a word or two echoed on a prop; on a native screen, which code typesets from the spec, a line read differently is the reader's error and only a missing one counts); **the ad's own copy and its logo measured against the format's safe area** (`staticSafeArea`, the one owner of those areas; `must-show.ts` decides what is measured: never what the scene prints, nor a copy line printed again in the scene while the line itself sits clear). On a 9:16, which runs in Stories and Reels alike, what Stories' header or bottom bar covers (and any other app's interface named) is said as "where Stories and Reels cover it" ("where Reels covers it" for an ad set that runs only in Reels) and blocks for the logo, the button, the headline, the figure and the offer, while a supporting line (body, caption, label, small print) there is a note; what only Reels' taller footer covers is one note, and only for the lead line, since Stories shows it and the 9:16 is laid out in Stories' band; words merely close to where an app draws are no finding. The steps that place a size clear of an interface (`static_safe_fit`, `static_place`) are told the same copy (`prompt.json`'s lines, their roles, and the brand's name and the logo's words, a wordmark read close to them counting as the logo) and move the ad for those alone, a supporting line included only where the frame cuts it; on a feed image such as a 4:5, only a design margin, so words close to the edge are a warning and only words the frame cuts are blocking); a copy line written over two lines (`"15%\noff"`) is matched part by part wherever the reader finds each; designed type in a colour far from the brand palette is a warning; supporting lines too small to read on a phone are one note per size; the main line set smaller than a supporting one is a note, the brand's wordmark never counted as part of a line that starts with its name; the logo set twice is a note, a far smaller mark printed on something in the scene (a hoodie, a bag) is not. When the copy names a real person ("Lautaro Suarez, CTO at Vibiz"), the run casts them as themselves before it renders (`baker avatars research --create`, their avatar's sheet added to `prompt.json` `references` as a `PERSON_n`), and a face shown as a named person the ad has no photo of is blocking. When the reader cannot answer, the vision pass transcribes the copy instead and judges the safe zones by eye. Then one vision pass for clipping, overlaps, artifacts, one dominant idea, the brand with the logo covered and the concept's mechanisms, with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-candidate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed, and the run is recorded with `presentable: false` so it is never shown as a version; every fix is an edit to `prompt.json` and a re-run (wrong words: the lines in `copy`; wrong picture: the `scene`; a bad roll: `--regenerate static_variants`; one size wrong while the chosen picture is right: `--regenerate adapt_<size>`, which re-lays it out, named in the hints); a blocking defect is first corrected by the run itself (`--autofix`, above). The checks rank the variants before the pick and the judge only breaks an exact tie, comparing pairwise against the compiled brief, knowing the brand and the viewer; every variant stays on offer to the person in Baker. Within one chat turn an ad gets two runs you start (each with its automatic corrections), and none once it is `ready` or `ready_with_notes`: the next is refused (`CONFLICT`, exit 2) with what to show instead; the person's next message starts a new turn (`turn-renders.ts`). When a defect still stands after the automatic rounds, the hints say to fix it with a `--fix`, then by changing the spec or the approach, and if it still cannot be fixed to show the best version and name what is left in one plain sentence, without a question.
+**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format; **every line of `prompt.json`'s copy (in-scene and designed alike) read back with its box by a box reader and compared** (a line more than 2% off, missing, or joined by words nobody asked for is blocking; case and punctuation fold, as does a capital I read as an l (one stroke in a sans-serif), accents do not; words the picture adds are blocking only when set at the copy's usual size or making a claim (a figure, a price, an offer), and otherwise a note, as a screen's code, a poster or a mug in the scene, except a price (a currency sign beside a figure) the copy does not hold, blocking at any size and blurred by the correction, the document it is on kept; every render is asked for no readable prices on a bill, quote, receipt, screen or price tag beyond the copy; a copy line is "on the ad twice" only when most of its words repeat, never a word or two echoed on a prop; on a native screen, which code typesets from the spec, a line read differently is the reader's error and only a missing one counts); **the ad's own copy and its logo measured against the format's safe area** (`staticSafeArea`, the one owner of those areas; `must-show.ts` decides what is measured: never what the scene prints, nor a copy line printed again in the scene while the line itself sits clear). On a 9:16, which runs in Stories and Reels alike, what Stories' header or bottom bar covers (and any other app's interface named) is said as "where Stories and Reels cover it" ("where Reels covers it" for an ad set that runs only in Reels) and blocks for the logo, the button, the headline, the figure and the offer, while a supporting line (body, caption, label, small print) there is a note; what only Reels' taller footer covers is one note, and only for the lead line, since Stories shows it and the 9:16 is laid out in Stories' band; words merely close to where an app draws are no finding. The steps that place a size clear of an interface (`static_safe_fit`, `static_place`) are told the same copy (`prompt.json`'s lines, their roles, and the brand's name and the logo's words, a wordmark read close to them counting as the logo) and move the ad for those alone, a supporting line included only where the frame cuts it; on a feed image such as a 4:5, only a design margin, so words close to the edge are a warning and only words the frame cuts are blocking); a copy line written over two lines (`"15%\noff"`) is matched part by part wherever the reader finds each; designed type in a colour far from the brand palette is a warning; supporting lines too small to read on a phone are one note per size; the main line set smaller than a supporting one is a note, the brand's wordmark never counted as part of a line that starts with its name; the logo set twice is a note, a far smaller mark printed on something in the scene (a hoodie, a bag) is not. When the copy names a real person ("Lautaro Suarez, CTO at Vibiz"), the run casts them as themselves before it renders (`baker avatars research --create`, their avatar's sheet added to `prompt.json` `references` as a `PERSON_n`), and a face shown as a named person the ad has no photo of is blocking. When the reader cannot answer, the vision pass transcribes the copy instead and judges the safe zones by eye. Then one vision pass for clipping, overlaps, artifacts, one dominant idea, the brand with the logo covered and the concept's mechanisms, with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-candidate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed, and the run is recorded with `presentable: false` so it is never shown as a version; every fix is an edit to `prompt.json` and a re-run (wrong words: the lines in `copy`; wrong picture: the `scene`; a bad roll: `--regenerate static_variants`; one size wrong while the chosen picture is right: `--regenerate adapt_<size>`, which re-lays it out, named in the hints); a blocking defect is first corrected by the run itself (`--autofix`, above). The checks rank the variants before the pick and the judge only breaks an exact tie, comparing pairwise against the compiled brief, knowing the brand and the viewer; every variant stays on offer to the person in Baker. Within one chat turn an ad gets two runs you start (each with its automatic corrections), and none once it is `ready` or `ready_with_notes`: the next is refused (`CONFLICT`, exit 2) with what to show instead; the person's next message starts a new turn (`turn-renders.ts`). When a defect still stands after the automatic rounds, the hints say to fix it with a `--fix`, then by changing the spec or the approach, and if it still cannot be fixed to show the best version and name what is left in one plain sentence, without a question.
 
 The render prompt is **model-aware**: each model's profile (`src/engine/lib/prompt-profiles.ts`) sets its shape, word budget, picture order and request params. gpt-image gets short labelled sections with the constraints last; Gemini gets sentences that give the reason and a positive closing list of the only words allowed. A profile change, or a new model on the router (`src/engine/lib/image-model-router.ts`), is re-run on the static bench (`scripts/creative-evals`, `--job static`) before it ships. Run `baker canvas critique` on the scaffolded canvas for an advisory read before you spend.
 

package/dist/{chunk-WMAHVZMY.js → chunk-Q2ZO6I47.js}

@@ -6689,6 +6689,7 @@ function textFidelityDirective(strings2, hasFont) {
   return [
     exact,
     "Render NO other words anywhere in the image \u2014 no invented labels, captions, sub-headers, or filler text.",
+    "Any bill, quote, receipt, screen or price tag in the scene shows no readable prices or amounts beyond these strings: its figures are blurred or out of focus.",
     "For any brand name or uncommon word, lock its letters exactly as written (spell it out letter-by-letter if that helps the characters render correctly).",
     "Keep all type crisp, legible, and large enough to read cleanly; no garbled, warped, or duplicated characters, and no unreadable microtext."
   ].join("\n");
@@ -10164,7 +10165,7 @@ function checkOrphanNodes(ctx) {
       path: `nodes[${ctx.idToIndex.get(n.id)}]`,
       code: STAGE_CODES.ORPHAN_NODE,
       severity: "warning",
-      message: `node "${n.id}" (${n.type}) is not reachable from output "${out.node}" \u2014 it will still execute (and bill, if billable) but nothing consumes its result; wire it in or remove it`
+      message: `node "${n.id}" (${n.type}) is not reachable from output "${out.node}": a run skips it, so nothing it would make is used; wire it in or remove it`
     });
   }
 }
@@ -15802,6 +15803,7 @@ function mostOfALine(chunk, copy) {
   });
 }
 var CLAIM = /[%€$£]|\b(?:free|gratis|gratuit[oa]?s?|off|sale|oferta|descuento|rebajas?|promo)\b/i;
+var PRICE = /[€$£]\s?\d|\d\s?[€$£]/;
 var COPY_SIZE_SHARE = 0.8;
 function extraWordFindings(format, extra, boxes, copyBoxes) {
   if (extra.length === 0) return [];
@@ -15819,7 +15821,8 @@ function extraWordFindings(format, extra, boxes, copyBoxes) {
   const printed = (chunk) => usual > 0 && underCopy.includes(chunk) && (!CLAIM.test(chunk) || scenery(chunk));
   const quote = (chunks) => chunks.map((e) => `"${e}"`).join(", ");
   const asCopy = extra.filter((chunk) => !printed(chunk));
-  const inScene = extra.filter(printed);
+  const prices = extra.filter((chunk) => printed(chunk) && PRICE.test(chunk));
+  const inScene = extra.filter((chunk) => printed(chunk) && !prices.includes(chunk));
   return [
     ...asCopy.length > 0 ? [
       {
@@ -15828,6 +15831,13 @@ function extraWordFindings(format, extra, boxes, copyBoxes) {
         what: `${format}: the picture adds words that aren't in the copy: ${quote(asCopy)}. Remove them, or add them to the copy.`
       }
     ] : [],
+    ...prices.length > 0 ? [
+      {
+        severity: "blocking",
+        // `static-autofix.ts` SCENE_PRICES reads this sentence to blur them.
+        what: `${format}: the picture shows prices the copy does not hold: ${quote(prices)}. Make them unreadable.`
+      }
+    ] : [],
     ...inScene.length > 0 ? [
       {
         severity: "warning",
@@ -16032,6 +16042,22 @@ function everySizeChecks(opts) {
     onSpend: opts.onSpend
   };
 }
+async function confirmBlocking(findings, stills, formats, ask2) {
+  const claims = findings.filter((f) => f.severity === "blocking");
+  if (claims.length === 0 || stills.length === 0) return [...findings];
+  const prompt = [
+    `These are the finished sizes of one ad, in order: ${formats.map((f, i) => `Image ${i + 1} is the ${f}`).join("; ")}.`,
+    "A reviewer reported each claim below. Look again at the size each one names (and, for a claim comparing sizes, at the others) and answer true only when the defect is plainly there for someone looking at it on a phone.",
+    "Answer false when the thing is not there, when it is an ordinary part of the scene (a second house, a neighbour's roof, a reflection), or when the sizes it compares show the same thing.",
+    ...claims.map((c, i) => `${i + 1}. ${c.what}`),
+    `Reply with only this JSON: {"answers":[true|false, ...]}, one answer per claim, in order.`
+  ].join("\n");
+  const answer = await ask2([...stills], prompt).catch(() => null);
+  const answers = answer?.answers;
+  if (!Array.isArray(answers) || answers.length !== claims.length) return [...findings];
+  const unconfirmed = new Set(claims.filter((_, i) => answers[i] === false));
+  return findings.map((f) => unconfirmed.has(f) ? { ...f, severity: "warning" } : f);
+}
 async function reviewRenderedStatic(opts) {
   const { measured, originals, stills, thumbs } = await loadDelivered(opts.images);
   if (measured.length === 0) return null;
@@ -16062,7 +16088,14 @@ async function reviewRenderedStatic(opts) {
   if (answer === null) return unreviewed(shape, measuredText);
   const text2 = read ? measuredText : copyFindings(answer, opts.copy, formats, opts.scrolled);
   const boxesByFormat = read ? Object.fromEntries(checks.flatMap((c, i) => c.status === "checked" ? [[formats[i] ?? "", c.boxes]] : [])) : {};
-  return [...shape, ...text2, ...corroborateEdgeClaims(classifyStaticFindings(answer), boxesByFormat, lines)];
+  const judged = corroborateEdgeClaims(classifyStaticFindings(answer), boxesByFormat, lines);
+  const confirmed = await confirmBlocking(
+    judged,
+    stills,
+    formats,
+    (images, prompt) => askAboutStills(images, prompt, opts.onSpend)
+  );
+  return [...shape, ...text2, ...confirmed];
 }
 
 // src/engine/nodes/local/staticNative.ts
@@ -16634,12 +16667,64 @@ import { z as z26 } from "zod";
 // src/engine/nodes/local/lib/variant-prefilter.ts
 import { createHash as createHash3 } from "crypto";
 import sharp8 from "sharp";
-function coverFitBoxes(boxes, from, to) {
+function coverOf(from, to) {
   const scale = Math.max(to.width / from.width, to.height / from.height);
-  const offX = (from.width * scale - to.width) / 2;
-  const offY = (from.height * scale - to.height) / 2;
-  const x = (f) => (f * from.width * scale - offX) / to.width;
-  const y = (f) => (f * from.height * scale - offY) / to.height;
+  const width = from.width * scale;
+  const height = from.height * scale;
+  return { scale, width, height, centre: { left: (width - to.width) / 2, top: (height - to.height) / 2 } };
+}
+function framingOf(from, to) {
+  let frame;
+  return {
+    place: (boxes) => {
+      frame = frameKeeping(boxes, from, to);
+      return coverFitBoxes(boxes, from, to, frame);
+    },
+    moved: () => {
+      const { centre } = coverOf(from, to);
+      return frame && (Math.abs(frame.left - centre.left) >= 1 || Math.abs(frame.top - centre.top) >= 1) ? frame : void 0;
+    }
+  };
+}
+async function cutToFrame(bytes, frame, to) {
+  const { width = 0, height = 0 } = await sharp8(bytes).metadata();
+  const { scale } = coverOf({ width, height }, to);
+  const w = Math.min(width, Math.round(to.width / scale));
+  const h = Math.min(height, Math.round(to.height / scale));
+  const left = Math.min(width - w, Math.max(0, Math.round(frame.left / scale)));
+  const top = Math.min(height - h, Math.max(0, Math.round(frame.top / scale)));
+  return sharp8(bytes).extract({ left, top, width: w, height: h }).png().toBuffer();
+}
+var FRAME_MARGIN = 0.02;
+function frameKeeping(boxes, from, to) {
+  const cover = coverOf(from, to);
+  if (boxes.length === 0) return cover.centre;
+  const along = (offset2, extent, frame, lo, hi) => {
+    const low = lo * extent;
+    const high = hi * extent;
+    const room = extent - frame;
+    const margin = FRAME_MARGIN * frame;
+    for (const m of [margin, 0]) {
+      const min = Math.max(0, high + m - frame);
+      const max = Math.min(room, low - m);
+      if (min <= max) return Math.min(max, Math.max(min, offset2));
+    }
+    return offset2;
+  };
+  const x0 = Math.min(...boxes.map((b) => b.x0));
+  const x1 = Math.max(...boxes.map((b) => b.x1));
+  const y0 = Math.min(...boxes.map((b) => b.y0));
+  const y1 = Math.max(...boxes.map((b) => b.y1));
+  return {
+    left: along(cover.centre.left, cover.width, to.width, x0, x1),
+    top: along(cover.centre.top, cover.height, to.height, y0, y1)
+  };
+}
+function coverFitBoxes(boxes, from, to, frame) {
+  const cover = coverOf(from, to);
+  const { left: offX, top: offY } = frame ?? cover.centre;
+  const x = (f) => (f * cover.width - offX) / to.width;
+  const y = (f) => (f * cover.height - offY) / to.height;
   return boxes.map((b) => ({ ...b, x0: x(b.x0), y0: y(b.y0), x1: x(b.x1), y1: y(b.y1) }));
 }
 var NO_LOGO = "The brand's logo was not found on it.";
@@ -16693,34 +16778,45 @@ async function prefilterVariants(variants, spec, formats, opts = {}) {
   });
   const format = plan.master.format;
   const grade = plan.masterShape === "relayout" ? plan.placements ? { placements: plan.placements } : {} : { band: plan.band };
+  const want = { lines, buttons, ...brand ? { brand } : {}, logo, format, grade };
   const checked = await Promise.all(
-    variants.map(async (variant) => {
-      const source = variant.path ?? variant.url;
-      if (!source) return { index: variant.index, blocking: null };
-      try {
-        const bytes = await bytesOf(source);
-        const { width = 0, height = 0 } = await sharp8(bytes).metadata();
-        const check = await checkStaticImage(bytes, {
-          format,
-          lines,
-          allowed: brand ? [brand] : [],
-          ...grade,
-          toFrame: (boxes) => coverFitBoxes(boxes, { width, height }, plan.master.size),
-          ...opts.read ? { read: opts.read } : {},
-          ...opts.onSpend ? { onSpend: opts.onSpend } : {}
-        });
-        if (check.status === "not_checked") return { index: variant.index, blocking: null };
-        const prefix = `${format}: `;
-        const blocking = check.findings.filter((f) => f.severity === "blocking").map((f) => f.what.startsWith(prefix) ? f.what.slice(prefix.length) : f.what);
-        const want = { lines, buttons, ...brand ? { brand } : {}, logo, format, grade };
-        return { index: variant.index, blocking, ...rankOf(check.boxes, blocking, want) };
-      } catch {
-        return { index: variant.index, blocking: null };
-      }
-    })
+    variants.map(
+      (variant) => checkVariant(variant, { format, size: plan.master.size, lines, brand, grade, want, opts })
+    )
   );
   const outcome = prefilterOutcome(checked);
-  return { ...outcome, kept: seededOrder(outcome.kept, variants) };
+  const frames = Object.fromEntries(checked.flatMap((c) => "frame" in c && c.frame ? [[c.index, c.frame]] : []));
+  return {
+    ...outcome,
+    kept: seededOrder(outcome.kept, variants),
+    ...Object.keys(frames).length > 0 ? { frames, masterSize: plan.master.size } : {}
+  };
+}
+async function checkVariant(variant, c) {
+  const { format, lines, brand, grade, want, opts } = c;
+  const source = variant.path ?? variant.url;
+  if (!source) return { index: variant.index, blocking: null };
+  try {
+    const bytes = await bytesOf(source);
+    const { width = 0, height = 0 } = await sharp8(bytes).metadata();
+    const framing = framingOf({ width, height }, c.size);
+    const check = await checkStaticImage(bytes, {
+      format,
+      lines,
+      allowed: brand ? [brand] : [],
+      ...grade,
+      toFrame: framing.place,
+      ...opts.read ? { read: opts.read } : {},
+      ...opts.onSpend ? { onSpend: opts.onSpend } : {}
+    });
+    if (check.status === "not_checked") return { index: variant.index, blocking: null };
+    const prefix = `${format}: `;
+    const blocking = check.findings.filter((f) => f.severity === "blocking").map((f) => f.what.startsWith(prefix) ? f.what.slice(prefix.length) : f.what);
+    const frame = framing.moved();
+    return { index: variant.index, blocking, ...rankOf(check.boxes, blocking, want), ...frame ? { frame } : {} };
+  } catch {
+    return { index: variant.index, blocking: null };
+  }
 }
 function seededOrder(indexes, variants) {
   const shaOf = new Map(variants.map((v) => [v.index, v.sha256]));
@@ -16796,7 +16892,7 @@ async function readSpec(ref) {
 }
 var staticPrefilterNode = defineNode({
   id: "static_prefilter",
-  version: "1.0.0",
+  version: "1.1.0",
   category: "image",
   location: "local",
   // Reads each variant's pixels itself, from its file or its durable URL, so the variants
@@ -16829,7 +16925,8 @@ var staticPrefilterNode = defineNode({
     images: z26.array(ImageRef).min(1),
     // Which variant (its place among the inputs) each of `images` is, so the judge's "Image k" maps back.
     order: z26.array(z26.number().int().min(0)).optional(),
-    // The picture every size is made from: the checks' first, or on a tie the judge's.
+    // The picture every size is made from: the checks' first, or on a tie the judge's. Cut to the
+    // master's frame where every word stays whole when its centre would cut one, else as rendered.
     image: ImageRef.optional(),
     // Which variant it is (its place among the inputs).
     chosen: z26.number().int().min(0).optional(),
@@ -16842,12 +16939,12 @@ var staticPrefilterNode = defineNode({
   }).strict(),
   outputKinds: { images: "image", image: "image" },
   cost: () => ({ credits: 0, seconds_estimate: 1 }),
-  async execute({ inputs, params }) {
-    const variants = inputs.images.map((image, index) => ({
+  async execute({ inputs, params, ctx }) {
+    const variants = inputs.images.map((image2, index) => ({
       index,
-      sha256: image.sha256,
-      ...image.path ? { path: image.path } : {},
-      ...image.url ? { url: image.url } : {}
+      sha256: image2.sha256,
+      ...image2.path ? { path: image2.path } : {},
+      ...image2.url ? { url: image2.url } : {}
     }));
     const usage = [];
     const result = await prefilterVariants(variants, params.checks ?? await readSpec(inputs.spec), params.formats, {
@@ -16863,10 +16960,11 @@ var staticPrefilterNode = defineNode({
       { model: params.judge_model, prompt: params.judge_prompt, onSpend: (u) => usage.push(u) }
     ) : null;
     const chosen = tie?.chosen ?? shown[0] ?? 0;
+    const image = await framed(inputs.images[chosen], result.frames?.[chosen], result.masterSize, ctx);
     return {
       images: kept.length > 0 ? kept : inputs.images,
       order: shown,
-      ...inputs.images[chosen] ? { image: inputs.images[chosen] } : {},
+      ...image ? { image } : {},
       chosen,
       ...tie ? { reasoning: tie.reasoning } : {},
       dropped: result.dropped,
@@ -16875,6 +16973,12 @@ var staticPrefilterNode = defineNode({
     };
   }
 });
+async function framed(picture, frame, size2, ctx) {
+  const source = picture?.path ?? picture?.url;
+  if (!picture || !frame || !size2 || !source) return picture;
+  const bytes = await cutToFrame(await bytesOf(source), frame, size2);
+  return await ctx.assets.ingestBytes({ bytes, kind: "image", mime: "image/png" });
+}
 
 // src/engine/nodes/local/staticSafeFit.ts
 import { z as z27 } from "zod";
@@ -18617,4 +18721,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-WMAHVZMY.js.map
+//# sourceMappingURL=chunk-Q2ZO6I47.js.map