@koda-sl/baker-cli 0.538.0 → 0.540.0-dev.91934cfea

package/dist/chunk-ZJOXRK2G.js

@@ -0,0 +1,1518 @@
+import {
+  perceptualHash
+} from "./chunk-DGCUPJZD.js";
+import {
+  confirmBlocking,
+  cutByFrame,
+  reviewAgainstRules
+} from "./chunk-Y3ESEQRI.js";
+import {
+  citedBy,
+  citedPlatforms,
+  jevCitationJudge,
+  namedPlatform
+} from "./chunk-2OCUXPWT.js";
+import {
+  FINDING_DEFECTS,
+  FINDING_ELEMENTS,
+  FRAME_EDGES,
+  STATIC_REVIEW_ITEMS,
+  askAboutImages,
+  askAboutStills,
+  reviewedRules
+} from "./chunk-KAUW3OFC.js";
+import {
+  AD_PLACEMENTS,
+  TEXT_BOX_READER_MODEL,
+  verticalCover
+} from "./chunk-F3CZFUXZ.js";
+import {
+  askJev
+} from "./chunk-ZPF253G5.js";
+
+// src/engine/nodes/local/lib/static-review.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import sharp3 from "sharp";
+import { z as z2 } from "zod";
+
+// src/engine/scaffold/platform-safe-area.ts
+var STORIES = placementOf("meta_stories");
+var REELS = placementOf("meta_reels");
+function placementOf(id) {
+  const found = AD_PLACEMENTS.find((p) => p.id === id);
+  if (!found) throw new Error(`no placement ${id} in the registry`);
+  return found;
+}
+var REELS_SAFE_BOTTOM = REELS.safe.bottom;
+var FEED = { top: 0.06, bottom: 0.06, left: 0.07, right: 0.07 };
+var FEED_IMAGE = { ...placementOf("meta_feed").safe };
+var EVERY_SURFACE = /* @__PURE__ */ new Set(["automatic", "facebook", "instagram", "meta"]);
+var OTHER_VERTICAL = [
+  { id: "tiktok_feed", names: ["tiktok", "tiktok_feed"], surface: "TikTok" },
+  { id: "snapchat_snap_ads", names: ["snapchat", "snapchat_snap_ads", "snap"], surface: "Snapchat" },
+  { id: "youtube_shorts", names: ["youtube", "youtube_shorts", "shorts"], surface: "YouTube Shorts" }
+];
+function metaVertical(named) {
+  const every = named.length === 0 || named.some((p) => EVERY_SURFACE.has(p));
+  const reels = every || named.some((p) => p.includes("reels"));
+  const stories = every || named.some((p) => p.includes("stor"));
+  if (reels) return { ids: stories ? [STORIES.id, REELS.id] : [REELS.id], placement: "reels", surface: "Reels" };
+  return stories ? { ids: [STORIES.id], placement: "stories", surface: "Stories" } : null;
+}
+function staticSafeArea(format, placements) {
+  const feed = { ...FEED_IMAGE, placement: "feed", surface: "the feed" };
+  if (format !== "9:16") return feed;
+  const named = (placements ?? []).map((p) => p.toLowerCase());
+  const meta = metaVertical(named);
+  const others = OTHER_VERTICAL.filter((o) => named.some((p) => o.names.includes(p)));
+  const cover = verticalCover([...meta?.ids ?? [], ...others.map((o) => o.id)]);
+  if (!cover) return feed;
+  return {
+    ...cover.safe,
+    placement: meta?.placement ?? "vertical",
+    surface: [...meta ? [meta.surface] : [], ...others.map((o) => o.surface)].join(" and "),
+    covered: { top: cover.top, bottom: cover.bottom, ...cover.rail ? { rail: cover.rail } : {} },
+    ...cover.railMargin ? { rail: cover.railMargin } : {}
+  };
+}
+var VIDEO_VERTICAL_SIDE = 0.06;
+function videoSafeArea(format) {
+  return format === "9:16" ? { ...STORIES.safe, bottom: REELS_SAFE_BOTTOM, left: VIDEO_VERTICAL_SIDE, right: VIDEO_VERTICAL_SIDE } : FEED;
+}
+function safeRectPx(area, width, height) {
+  const x = Math.ceil(atPx(area.left * width));
+  const y = Math.ceil(atPx(area.top * height));
+  const right = Math.floor(atPx((1 - area.right) * width));
+  const bottom = Math.floor(atPx((1 - area.bottom) * height));
+  return { x, y, width: right - x, height: bottom - y };
+}
+function atPx(value) {
+  return Number(value.toFixed(6));
+}
+function blockingArea(format, placements) {
+  return staticSafeArea(format, blockingPlacements(placements));
+}
+function blockingPlacements(placements) {
+  const named = (placements ?? []).map((p) => p.toLowerCase());
+  const storiesToo = named.length === 0 || named.some((p) => EVERY_SURFACE.has(p)) || named.some((p) => p.includes("reels")) && named.some((p) => p.includes("stor"));
+  if (!storiesToo) return [...placements ?? []];
+  const others = (placements ?? []).filter((p) => OTHER_VERTICAL.some((o) => o.names.includes(p.toLowerCase())));
+  return [...others, "reels", "stories"];
+}
+var MARGIN = 0.035;
+function nativeLayoutInsets(format, placements) {
+  const area = blockingArea(format, placements);
+  if (!area.covered) {
+    return {
+      top: Math.max(area.top, MARGIN),
+      bottom: Math.max(area.bottom, MARGIN),
+      left: Math.max(area.left, MARGIN),
+      right: Math.max(area.right, MARGIN)
+    };
+  }
+  const rail = area.covered.rail;
+  const bottom = area.covered.bottom + MARGIN;
+  const railReached = rail ? 1 - bottom > rail.from : false;
+  return {
+    top: area.covered.top + MARGIN,
+    bottom,
+    left: Math.max(area.left, MARGIN),
+    right: Math.max(area.right, railReached && rail ? rail.width + MARGIN / 2 : 0, MARGIN)
+  };
+}
+
+// src/engine/nodes/local/lib/band-check.ts
+var BOX_TOLERANCE = 0.01;
+var FRAME_CUT = 5e-3;
+function underInterface(box, covered, tolerance) {
+  if (!covered) return false;
+  if (covered.top - box.y0 > tolerance || box.y1 - (1 - covered.bottom) > tolerance) return true;
+  const rail = covered.rail;
+  return Boolean(rail && box.y1 > rail.from && box.x1 - (1 - rail.width) > tolerance);
+}
+function bandViolations(boxes, format, opts = {}) {
+  const own = staticSafeArea(format, opts.placements);
+  const band = opts.band ?? own;
+  const covered = opts.band ? void 0 : own.covered;
+  const rail = opts.band ? void 0 : own.rail;
+  const tolerance = opts.tolerance ?? BOX_TOLERANCE;
+  return boxes.flatMap((box) => {
+    const right = rail && box.y1 > rail.from ? Math.max(band.right, rail.width) : band.right;
+    const reach = {
+      top: band.top - box.y0,
+      bottom: box.y1 - (1 - band.bottom),
+      left: band.left - box.x0,
+      right: box.x1 - (1 - right)
+    };
+    const edges = Object.keys(reach).filter((edge) => reach[edge] > tolerance);
+    if (edges.length === 0) return [];
+    const toFrame = { top: box.y0, bottom: 1 - box.y1, left: box.x0, right: 1 - box.x1 };
+    return [
+      {
+        text: box.text,
+        kind: box.kind,
+        edges,
+        overshoot: Math.max(...edges.map((edge) => reach[edge])),
+        clearance: Math.max(0, Math.min(...edges.map((edge) => toFrame[edge]))),
+        covered: opts.band !== void 0 || underInterface(box, covered, tolerance)
+      }
+    ];
+  });
+}
+
+// src/engine/nodes/local/lib/brand-colour.ts
+import chroma from "chroma-js";
+import sharp from "sharp";
+var OFF_BRAND_DELTA_E = 20;
+var INK_CLUSTERS = 4;
+var MIN_INK_SHARE = 0.05;
+var NEUTRAL_CHROMA = 12;
+async function inkOf(image, box) {
+  try {
+    const { width = 0, height = 0 } = await sharp(image).metadata();
+    const left = Math.max(0, Math.floor(box.x0 * width));
+    const top = Math.max(0, Math.floor(box.y0 * height));
+    const region = {
+      left,
+      top,
+      width: Math.min(width - left, Math.ceil((box.x1 - box.x0) * width)),
+      height: Math.min(height - top, Math.ceil((box.y1 - box.y0) * height))
+    };
+    if (region.width < 2 || region.height < 2) return null;
+    const quantized = await sharp(image).extract(region).removeAlpha().resize({ width: 96, withoutEnlargement: true }).png({ palette: true, colours: INK_CLUSTERS, dither: 0 }).toBuffer();
+    const { data, info } = await sharp(quantized).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+    const counts = /* @__PURE__ */ new Map();
+    for (let i = 0; i + 2 < data.length; i += info.channels) {
+      const hex = chroma(data[i] ?? 0, data[i + 1] ?? 0, data[i + 2] ?? 0).hex();
+      counts.set(hex, (counts.get(hex) ?? 0) + 1);
+    }
+    const total = info.width * info.height;
+    const [ground, ...rest] = [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([hex]) => hex);
+    const inks = rest.filter((hex) => (counts.get(hex) ?? 0) / total >= MIN_INK_SHARE);
+    if (!ground || inks.length === 0) return null;
+    return inks.sort((a, b) => chroma.deltaE(ground, b) - chroma.deltaE(ground, a))[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+var SHADE_HUE = 30;
+var NEAR_BLACK_L = 20;
+var NEAR_WHITE_L = 92;
+var hueGap = (a, b) => {
+  const d = Math.abs(a - b) % 360;
+  return d > 180 ? 360 - d : d;
+};
+function shadeOfBrand(hex, palette) {
+  const [, , hue] = chroma(hex).lch();
+  return palette.some((p) => {
+    const [, c, h] = chroma(p).lch();
+    return c >= NEUTRAL_CHROMA && !Number.isNaN(h) && !Number.isNaN(hue) && hueGap(h, hue) <= SHADE_HUE;
+  });
+}
+function offBrandInks(inks, palette) {
+  if (palette.length === 0) return [];
+  return inks.flatMap((ink) => {
+    const [lightness, inkChroma] = chroma(ink.hex).lch();
+    if (inkChroma < NEUTRAL_CHROMA || lightness < NEAR_BLACK_L || lightness > NEAR_WHITE_L) return [];
+    if (shadeOfBrand(ink.hex, palette)) return [];
+    const [nearest] = palette.map((hex) => ({ hex, deltaE: chroma.deltaE(ink.hex, hex) })).sort((a, b) => a.deltaE - b.deltaE);
+    if (!nearest || nearest.deltaE <= OFF_BRAND_DELTA_E) return [];
+    return [{ text: ink.text, hex: ink.hex, nearest: nearest.hex, deltaE: nearest.deltaE }];
+  });
+}
+
+// src/engine/nodes/local/lib/copy-match.ts
+import { distance } from "fastest-levenshtein";
+var MAX_LINE_DISTANCE = 0.02;
+var SPAN_SLACK = 2;
+var MIN_MATCH = 0.5;
+var ALLOWED_MATCH = 0.8;
+function normalizeCopy(text) {
+  return text.replace(/[™®℠©]/g, "").normalize("NFKC").toLowerCase().replace(/[’'`´ʼ‘]/g, "").replace(/\s*&\s*/g, " and ").replace(/[^\p{L}\p{N}%€$£]+/gu, " ").replace(new RegExp("(\\p{N})([%\u20AC$\xA3])", "gu"), "$1 $2").replace(new RegExp("([\u20AC$\xA3])(\\p{N})", "gu"), "$1 $2").trim();
+}
+var CLOCK = /^\d{1,2}:\d{2}(?:\s?[ap]\.?\s?m\.?)?$/i;
+function isInterfaceChrome(raw) {
+  const text = raw.trim();
+  if (CLOCK.test(text)) return true;
+  if (/^\d{1,3}$/.test(text)) return true;
+  return new RegExp("^\\p{L}$", "u").test(text);
+}
+var lineHeight = (b) => Math.max(b.y1 - b.y0, 5e-3);
+function continuesColumn(last, next) {
+  if (next.y0 < last.y0 + 0.3 * lineHeight(last)) return null;
+  const gap = next.y0 - last.y1;
+  if (gap > 1.2 * Math.max(lineHeight(last), lineHeight(next))) return null;
+  const overlap = Math.min(last.x1, next.x1) - Math.max(last.x0, next.x0);
+  const narrower = Math.min(last.x1 - last.x0, next.x1 - next.x0);
+  return narrower > 0 && overlap >= 0.3 * narrower ? gap : null;
+}
+function continuesRow(last, next) {
+  const shared = Math.min(last.y1, next.y1) - Math.max(last.y0, next.y0);
+  const height = Math.min(lineHeight(last), lineHeight(next));
+  const gap = next.x0 - last.x1;
+  return shared >= 0.5 * height && gap > -0.5 * height && gap <= Math.max(lineHeight(last), lineHeight(next));
+}
+function rowsOf(boxes) {
+  const rows = [];
+  const byLeft = boxes.map((box, index) => ({ box, index })).sort((a, b) => a.box.x0 - b.box.x0 || a.index - b.index);
+  for (const item of byLeft) {
+    const row = rows.find((r) => {
+      const last = r.items[r.items.length - 1];
+      return last !== void 0 && continuesRow(last.box, item.box);
+    });
+    if (!row) {
+      rows.push({ items: [item], span: item.box });
+      continue;
+    }
+    row.items.push(item);
+    const { span } = row;
+    row.span = {
+      text: "",
+      kind: span.kind,
+      x0: Math.min(span.x0, item.box.x0),
+      y0: Math.min(span.y0, item.box.y0),
+      x1: Math.max(span.x1, item.box.x1),
+      y1: Math.max(span.y1, item.box.y1)
+    };
+  }
+  return rows;
+}
+function readingOrder(boxes) {
+  const first = (row) => Math.min(...row.items.map((i) => i.index));
+  const byTop = rowsOf(boxes).sort((a, b) => a.span.y0 - b.span.y0 || first(a) - first(b));
+  const blocks = [];
+  for (const row of byTop) {
+    let best = null;
+    for (const block of blocks) {
+      const last = block[block.length - 1];
+      const gap = last ? continuesColumn(last.span, row.span) : null;
+      if (gap !== null && (best === null || gap < best.gap)) best = { block, gap };
+    }
+    if (best) best.block.push(row);
+    else blocks.push([row]);
+  }
+  return blocks.sort((a, b) => Math.min(...a.map(first)) - Math.min(...b.map(first))).flatMap((block) => block.flatMap((row) => row.items.map((i) => i.box)));
+}
+function copySimilarity(a, b) {
+  return similarity(a, b);
+}
+var sameStroke = (text) => text.replace(/l/g, "i");
+function similarity(a, b) {
+  const longest = Math.max(a.length, b.length);
+  return longest === 0 ? 1 : 1 - distance(sameStroke(a), sameStroke(b)) / longest;
+}
+function spans(words, size) {
+  const out = [];
+  for (let length = Math.max(1, size - SPAN_SLACK); length <= size + SPAN_SLACK; length++) {
+    for (let start = 0; start + length <= words.length; start++) {
+      const indexes = Array.from({ length }, (_, i) => start + i);
+      out.push({ indexes, text: indexes.map((i) => words[i]?.word ?? "").join(" ") });
+    }
+  }
+  return out;
+}
+function assign(targets, words, claimed, threshold) {
+  const pairs = targets.flatMap(
+    (target, index) => target.length === 0 ? [] : spans(words, target.split(" ").length).map((span) => ({
+      index,
+      span,
+      similarity: similarity(target, span.text)
+    }))
+  );
+  pairs.sort((a, b) => b.similarity - a.similarity);
+  const matches = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    if (pair.similarity < threshold) break;
+    if (matches.has(pair.index)) continue;
+    if (pair.span.indexes.some((i) => claimed.has(i))) continue;
+    matches.set(pair.index, { span: pair.span, similarity: pair.similarity });
+    for (const i of pair.span.indexes) claimed.add(i);
+  }
+  return matches;
+}
+function hyphenatedCompounds(texts) {
+  const out = /* @__PURE__ */ new Set();
+  for (const text of texts) {
+    for (const [compound] of text.normalize("NFKC").toLowerCase().matchAll(new RegExp("\\p{L}+(?:[-\u2010\u2011]\\p{L}+)+", "gu"))) {
+      const words = compound.split(/[-‐‑]/u);
+      for (let i = 1; i < words.length; i++) out.add(`${words[i - 1]}-${words[i]}`);
+    }
+  }
+  return out;
+}
+var LIST_MARKER = /^\s*(\d{1,2})[.)]\s+(?=\S)/u;
+var listMarker = (text) => text.match(LIST_MARKER)?.[1] ?? null;
+var withoutListMarker = (text) => text.replace(LIST_MARKER, "");
+function trademarked(texts) {
+  const out = /* @__PURE__ */ new Set();
+  for (const text of texts) {
+    for (const [, word = ""] of text.matchAll(/([\p{L}\p{N}]+)\s?[®™]/gu)) out.add(word.toLowerCase());
+  }
+  return out;
+}
+function withoutTrademarkLetters(text, marked) {
+  if (marked.size === 0) return text;
+  return text.replace(
+    /([\p{L}\p{N}]+)\s?(?:\((?:r|tm)\)|r|tm)(?![\p{L}\p{N}])/giu,
+    (whole, word) => marked.has(word.toLowerCase()) ? word : whole
+  );
+}
+function joinHyphenBreaks(texts, compounds) {
+  const out = [];
+  let carry = "";
+  for (const text of texts) {
+    const next = text.trim();
+    const before = carry.match(new RegExp("\\p{L}+$", "u"))?.[0] ?? "";
+    const after = next.match(new RegExp("^\\p{L}+", "u"))?.[0] ?? "";
+    const own = carry !== "" && compounds.has(`${before}-${after}`.normalize("NFKC").toLowerCase());
+    const line = carry + (own ? "-" : "") + next;
+    const broken = line.match(new RegExp("^(.*\\p{L})[-\u2010\u2011]$", "u"));
+    if (broken) carry = broken[1] ?? "";
+    else {
+      out.push(line);
+      carry = "";
+    }
+  }
+  if (carry) out.push(`${carry}-`);
+  return out;
+}
+function lineParts(text) {
+  const parts = text.split(/\r?\n/).filter((part) => part.trim().length > 0);
+  return parts.length > 0 ? parts : [text];
+}
+function textMismatch(expected, boxes, opts = {}) {
+  const compounds = hyphenatedCompounds(expected.map((line) => line.text));
+  const clockAsked = expected.some((line) => CLOCK.test(line.text.trim()));
+  const read = boxes.filter((b) => b.kind === "text" && (clockAsked || !CLOCK.test(b.text.trim())));
+  const texts = readingOrder(read).map((b) => b.text);
+  const joined = joinHyphenBreaks(texts, compounds);
+  const marked = trademarked(expected.map((line) => line.text));
+  const words = joined.flatMap(
+    (text, box) => normalizeCopy(withoutTrademarkLetters(text, marked)).split(" ").filter((word) => word.length > 0).map((word) => ({ word, box }))
+  );
+  const claimed = /* @__PURE__ */ new Set();
+  const parts = expected.flatMap(
+    (line, lineIndex) => lineParts(line.text).map((text) => ({ lineIndex, text: normalizeCopy(withoutListMarker(text)) }))
+  );
+  const matches = assign(
+    parts.map((part) => part.text),
+    words,
+    claimed,
+    MIN_MATCH
+  );
+  const markers = expected.flatMap((line) => lineParts(line.text).flatMap((text) => listMarker(text) ?? []));
+  const allowed = [...opts.allowed ?? [], ...markers].map(normalizeCopy).filter((a) => a.length > 0);
+  for (let before = -1; claimed.size !== before; ) {
+    before = claimed.size;
+    assign(allowed, words, claimed, ALLOWED_MATCH);
+  }
+  const logos = boxes.filter((b) => b.kind === "logo").map((b) => normalizeCopy(b.text));
+  const inLogo = (text) => {
+    const t = normalizeCopy(text);
+    return allowed.some((a) => similarity(a, t) >= ALLOWED_MATCH) && logos.some((l) => similarity(l, t) >= ALLOWED_MATCH);
+  };
+  const lines = expected.flatMap((line, index) => {
+    if (inLogo(line.text)) return [];
+    const lineMatches = parts.flatMap(
+      (part, partIndex) => part.lineIndex === index && part.text.length > 0 ? [matches.get(partIndex)] : []
+    );
+    if (lineMatches.length === 0) return [];
+    const score = Math.min(...lineMatches.map((match) => match?.similarity ?? 0));
+    if (score >= 1 - MAX_LINE_DISTANCE) return [];
+    const read2 = lineMatches.flatMap((match) => match ? [match.span.text] : []).join(" ");
+    return [{ ...line, read: read2.length > 0 ? read2 : null, similarity: score }];
+  });
+  const extra = [];
+  words.forEach(({ word, box }, index) => {
+    if (claimed.has(index)) return;
+    const previous = words[index - 1];
+    const last = extra.at(-1);
+    if (previous && !claimed.has(index - 1) && previous.box === box && last) {
+      last.text += ` ${word}`;
+    } else {
+      extra.push({ text: word, box });
+    }
+  });
+  const unasked = extra.filter((chunk) => !isInterfaceChrome(joined[chunk.box] ?? "")).map((chunk) => chunk.text.replace(new RegExp("(\\p{N}) ([%\u20AC$\xA3])", "gu"), "$1$2").replace(new RegExp("([\u20AC$\xA3]) (\\p{N})", "gu"), "$1$2"));
+  return { ok: lines.length === 0 && unasked.length === 0, lines, extra: unasked };
+}
+
+// src/engine/nodes/local/lib/must-show.ts
+var roleKey = (role) => (role ?? "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+var SUPPORTING_ROLES = /* @__PURE__ */ new Set([
+  "body",
+  "caption",
+  "subheadline",
+  "subhead",
+  "subtitle",
+  "supporting",
+  "support",
+  "label",
+  "tagline",
+  "eyebrow",
+  "kicker",
+  "description",
+  "detail",
+  "details",
+  "note",
+  "fine_print",
+  "legal",
+  "disclaimer",
+  "footnote",
+  "attribution"
+]);
+var WORDMARK_MATCH = 0.8;
+function withWordmark(boxes, logoWords) {
+  const names = logoWords.map(normalizeCopy).filter((n) => n.length > 0);
+  const isName = (text) => {
+    const read = normalizeCopy(text);
+    return read.length > 0 && names.some((n) => copySimilarity(n, read) >= WORDMARK_MATCH);
+  };
+  return boxes.map((b) => b.kind === "text" && isName(b.text) ? { ...b, kind: "logo" } : b);
+}
+function boxesOfLine(line, boxes) {
+  const words = ` ${normalizeCopy(line.text)} `;
+  return boxes.filter((b) => {
+    const read = normalizeCopy(b.text);
+    return b.kind === "text" && read.length > 0 && words.includes(` ${read} `);
+  });
+}
+var HEADLINE_ROLES = /* @__PURE__ */ new Set(["headline", "title", "hook"]);
+function headlineBox(lines, boxes) {
+  const line = lines.find((l) => HEADLINE_ROLES.has(roleKey(l.role))) ?? lines[0];
+  const found = line ? boxesOfLine(line, boxes) : [];
+  if (found.length === 0) return null;
+  return {
+    x0: Math.min(...found.map((b) => b.x0)),
+    y0: Math.min(...found.map((b) => b.y0)),
+    x1: Math.max(...found.map((b) => b.x1)),
+    y1: Math.max(...found.map((b) => b.y1))
+  };
+}
+var BUTTON_PAD = 0.7;
+var isButtonLine = (line) => /^(cta|button|call_to_action)$/.test(roleKey(line.role));
+function buttonShape(box) {
+  const pad = BUTTON_PAD * (box.y1 - box.y0);
+  return {
+    ...box,
+    x0: Math.max(0, box.x0 - pad),
+    y0: Math.max(0, box.y0 - pad),
+    x1: Math.min(1, box.x1 + pad),
+    y1: Math.min(1, box.y1 + pad)
+  };
+}
+function shownBoxes(boxes, lines, clear) {
+  const linesOfBox = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const found = boxesOfLine(line, boxes);
+    for (const box of found) linesOfBox.set(box, [...linesOfBox.get(box) ?? [], { line, found }]);
+  }
+  const echo = (box, of) => of.every(
+    ({ found }) => found.some((other) => other !== box && normalizeCopy(other.text) === normalizeCopy(box.text) && clear(other))
+  );
+  return boxes.flatMap((box) => {
+    if (box.kind === "logo") return [{ box, supporting: false }];
+    const of = linesOfBox.get(box);
+    if (!of || echo(box, of)) return [];
+    return [{ box, supporting: of.every(({ line }) => SUPPORTING_ROLES.has(roleKey(line.role))) }];
+  });
+}
+
+// src/engine/nodes/local/lib/text-boxes.ts
+import sharp2 from "sharp";
+import { z } from "zod";
+var GRID = 1e3;
+var ReaderItem = z.object({
+  text: z.string(),
+  kind: z.enum(["text", "logo"]),
+  box_2d: z.array(z.number()).length(4)
+});
+var ReaderAnswer = z.object({ items: z.array(ReaderItem) });
+var fraction = (value) => Math.min(1, Math.max(0, value / GRID));
+function textBoxesFromReader(answer) {
+  const parsed = ReaderAnswer.safeParse(answer);
+  if (!parsed.success) return null;
+  return parsed.data.items.map(({ text, kind, box_2d }) => {
+    const [ymin = 0, xmin = 0, ymax = 0, xmax = 0] = box_2d;
+    return {
+      text,
+      kind,
+      x0: fraction(Math.min(xmin, xmax)),
+      y0: fraction(Math.min(ymin, ymax)),
+      x1: fraction(Math.max(xmin, xmax)),
+      y1: fraction(Math.max(ymin, ymax))
+    };
+  });
+}
+var TEXT_BOX_PROMPT = [
+  "Find every line of visible text in this image and every logo mark.",
+  "For each, return: `text` exactly as rendered, character for character (keep misspellings, doubled or missing letters and garbled glyphs as they appear; never correct or complete them; for a logo, its wordmark text or an empty string); `kind` text or logo; `box_2d` the tight box around it as [ymin, xmin, ymax, xmax] on a 0-1000 grid over the whole image.",
+  "One entry per line of each column: a headline wrapped over two lines is two entries, and where text sits in columns, cards or bubbles side by side, each one's lines are their own entries. Never join text from two columns into one entry. List the text block by block in reading order, each block's lines top to bottom. Pseudo-text that is not readable as letters is left out. No text: an empty list.",
+  'Reply with only this JSON: {"items":[{"text":"...","kind":"text|logo","box_2d":[ymin,xmin,ymax,xmax]}]}'
+].join("\n");
+var READ_EDGE = 1536;
+async function readTextBoxes(image, opts = {}) {
+  let jpeg;
+  try {
+    const resized = await sharp2(image).resize(READ_EDGE, READ_EDGE, { fit: "inside", withoutEnlargement: true }).jpeg({ quality: 90 }).toBuffer();
+    jpeg = resized.toString("base64");
+  } catch {
+    return { status: "not_checked" };
+  }
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const answer = await askAboutImages(TEXT_BOX_READER_MODEL, [jpeg], TEXT_BOX_PROMPT, opts.onSpend, 6e4, {
+      effort: "minimal"
+    });
+    const boxes = textBoxesFromReader(answer);
+    if (boxes) return { status: "read", boxes };
+  }
+  return { status: "not_checked" };
+}
+
+// src/engine/nodes/local/lib/static-review.ts
+var RATIO_TOLERANCE = 0.02;
+function ratioOf(format) {
+  const [w, h] = format.split(":").map(Number);
+  return w && h ? w / h : null;
+}
+function ratioFindings(images) {
+  return images.flatMap(({ format, width, height }) => {
+    const want = ratioOf(format);
+    if (want === null || width <= 0 || height <= 0) return [];
+    if (Math.abs(width / height / want - 1) <= RATIO_TOLERANCE) return [];
+    return [
+      {
+        severity: "blocking",
+        what: `The ${format} version came out ${width}x${height}, which is not ${format}. It cannot be delivered as ${format}.`
+      }
+    ];
+  });
+}
+var RANKING_LINE = /^[\s*#>-]*(?:\d+[.)]\s*)?\**\s*([a-z][a-z ]*?)\s*\**\s*:\s*\**\s*(image\s+\d+(?:\s*[>=]\s*image\s+\d+)+)/i;
+function parseJudgeRanking(reasoning) {
+  const byImage = /* @__PURE__ */ new Map();
+  let candidates = 0;
+  for (const line of reasoning.split("\n")) {
+    const match = line.match(RANKING_LINE);
+    if (!match) continue;
+    const criterion = (match[1] ?? "").trim().toLowerCase().replace(/\s+/g, "_");
+    const tiers = (match[2] ?? "").split(">").map((tier) => [...tier.matchAll(/image\s+(\d+)/gi)].map((m) => Number(m[1])));
+    const ranked = tiers.flat();
+    candidates = Math.max(candidates, ranked.length, ...ranked);
+    let below = ranked.length;
+    for (const tier of tiers) {
+      below -= tier.length;
+      for (const image of tier) {
+        const scores = byImage.get(image) ?? {};
+        scores[criterion] = below;
+        byImage.set(image, scores);
+      }
+    }
+  }
+  return [...byImage.entries()].sort(([a], [b]) => a - b).map(([image, scores]) => ({
+    image,
+    total: Object.values(scores).reduce((a, b) => a + b, 0),
+    of: candidates - 1,
+    scores
+  }));
+}
+function parseJudgeScores(reasoning) {
+  const out = [];
+  for (const line of reasoning.split("\n")) {
+    const head = line.match(/^\s*Image\s+(\d+)\s*:(.*)$/i);
+    if (!head) continue;
+    const scores = {};
+    let total;
+    for (const pair of (head[2] ?? "").matchAll(/([a-z_]+)\s*=\s*(\d+(?:\.\d+)?)/gi)) {
+      const key = (pair[1] ?? "").toLowerCase();
+      const value = Number(pair[2]);
+      if (key === "total") total = value;
+      else scores[key] = value;
+    }
+    if (Object.keys(scores).length === 0) continue;
+    out.push({ image: Number(head[1]), total: total ?? Object.values(scores).reduce((a, b) => a + b, 0), scores });
+  }
+  return out.length > 0 ? out : parseJudgeRanking(reasoning);
+}
+function judgeWinner(judge) {
+  const byGate = (a, b) => {
+    if (a.of === void 0) return b.total - a.total;
+    for (const criterion of Object.keys(a.scores)) {
+      const gap = (b.scores[criterion] ?? 0) - (a.scores[criterion] ?? 0);
+      if (gap !== 0) return gap;
+    }
+    return b.total - a.total;
+  };
+  return [...judge].sort(byGate)[0] ?? null;
+}
+var StaticFinding = z2.object({
+  severity: z2.enum(["blocking", "warning"]),
+  format: z2.string().optional(),
+  what: z2.string().trim().min(1),
+  item: z2.enum(STATIC_REVIEW_ITEMS).catch("other"),
+  element: z2.enum(FINDING_ELEMENTS).catch("other"),
+  defect: z2.enum(FINDING_DEFECTS).catch("other"),
+  edges: z2.array(z2.enum(FRAME_EDGES)).catch([])
+});
+var ALWAYS_BLOCKING = /* @__PURE__ */ new Set(["subject", "person"]);
+function classifyStaticFindings(json) {
+  const findings = json?.findings;
+  if (!Array.isArray(findings)) return [];
+  return findings.flatMap((raw) => {
+    const parsed = StaticFinding.safeParse(raw);
+    if (!parsed.success) return [];
+    const { severity, format, what, ...fields } = parsed.data;
+    const kind = {
+      item: fields.item,
+      element: fields.element,
+      defect: fields.defect,
+      edges: [...new Set(fields.edges)]
+    };
+    if (kind.element === "button" && kind.defect === "missing") return [];
+    const graded = ALWAYS_BLOCKING.has(kind.item) ? "blocking" : kind.element === "scene_text" && kind.defect === "unreadable" ? "warning" : severity;
+    return [{ severity: graded, what: format?.trim() ? `${format.trim()}: ${what}` : what, kind }];
+  });
+}
+var KeepRead = z2.object({
+  format: z2.string().trim().min(1),
+  element: z2.number().int().min(1),
+  carried: z2.boolean(),
+  what: z2.string().default("")
+});
+var VITAL_GONE = {
+  stop: "what stopped the scroll in the proven ad is gone",
+  proof: "the proof of the proven ad is gone"
+};
+function vitalFindings(json, vital, formats) {
+  if (vital.length === 0) return [];
+  const raw = json?.keeps;
+  if (!Array.isArray(raw)) {
+    return [
+      {
+        severity: "warning",
+        what: `The finished ad was not checked one by one for what its proven ad won on (${vital.map((v) => v.keep).join("; ")}): look for it on every size yourself.`
+      }
+    ];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return raw.flatMap((entry) => {
+    const read = KeepRead.safeParse(entry);
+    if (!read.success || read.data.carried) return [];
+    const { format, element } = read.data;
+    const kept = vital[element - 1];
+    if (!kept || !formats.includes(format) || seen.has(`${format}:${element}`)) return [];
+    seen.add(`${format}:${element}`);
+    const what = read.data.what.trim().replace(/\.$/, "");
+    return [
+      {
+        severity: "blocking",
+        what: `${format}: ${VITAL_GONE[kept.job]}: ${kept.keep}.${what ? ` ${what.charAt(0).toUpperCase()}${what.slice(1)}.` : ""}`,
+        kind: { item: "concept", element: "picture", defect: "missing", edges: [], job: kept.job }
+      }
+    ];
+  });
+}
+var CopyRead = z2.object({
+  format: z2.string().trim().min(1),
+  string: z2.string(),
+  /** What the model read where the string should be; null when it found nothing like it. */
+  seen: z2.string().nullable()
+});
+function comparableCopy(text) {
+  return text.replace(/[‘’‚′]/g, "'").replace(/[“”„″]/g, '"').replace(/[‐-―−]/g, "-").replace(/…/g, "...").replace(/[«»]/g, '"').replace(/\s*[·•]\s*/g, " ").replace(/\s+/g, " ").replace(/ (?=[%€$£:;!?])/g, "").replace(/(?<=[€$£]) (?=\d)/g, "").trim().replace(/^"([^"]*)"$/, "$1").trim().toLowerCase();
+}
+function copyFindings(json, copy, formats, scrolled = {}) {
+  if (copy.length === 0) return [];
+  const raw = json?.copy;
+  const reads = Array.isArray(raw) ? raw.flatMap((entry) => {
+    const parsed = CopyRead.safeParse(entry);
+    return parsed.success ? [parsed.data] : [];
+  }) : [];
+  return formats.flatMap((format) => {
+    const forFormat = reads.filter((r) => r.format === format);
+    if (forFormat.length === 0) {
+      return [
+        {
+          severity: "blocking",
+          what: `${format}: the copy could not be read back; look at every word yourself.`
+        }
+      ];
+    }
+    const gone = scrolled[format] ?? [];
+    return copy.flatMap((expected) => {
+      if (gone.includes(expected)) return [];
+      const read = forFormat.find((r) => comparableCopy(r.string) === comparableCopy(expected));
+      const seen = read?.seen ?? null;
+      if (seen === null) {
+        return [{ severity: "blocking", what: `${format}: Text: "${expected}" is missing.` }];
+      }
+      if (comparableCopy(seen) === comparableCopy(expected)) return [];
+      return [{ severity: "blocking", what: `${format}: Text: "${expected}" reads "${seen}".` }];
+    });
+  });
+}
+var EDGE_WORDS = {
+  top: "the top of the screen",
+  bottom: "the bottom of the screen",
+  left: "the left edge",
+  right: "the right edge"
+};
+function blockName(v, under) {
+  if (v.kind === "logo") return "the logo";
+  return under > 0 ? `"${v.text}" and the ${under === 1 ? "line" : `${under} lines`} under it` : `"${v.text}"`;
+}
+function outsideBand({ violation: v, under }, placement, surface, storiesToo) {
+  const what = blockName(v, under);
+  const sits = under > 0 ? "sit" : "sits";
+  const it = under > 0 ? "them" : "it";
+  const edges = v.edges.map((e) => EDGE_WORDS[e]).join(" and ");
+  if (placement === "reels" || placement === "stories" || placement === "vertical") {
+    if (v.reelsOnly)
+      return `${what} ${sits} where Reels' caption and buttons cover ${it} (${edges}): unseen by everyone the ad reaches in Reels, though Stories shows ${it}.`;
+    const names = placement === "reels" && storiesToo ? ["Stories", ...surface.split(" and ")] : surface.split(" and ");
+    const apps = names.length > 1 ? `${names.slice(0, -1).join(", ")} and ${names.at(-1)}` : surface;
+    return `${what} ${sits} where ${apps} ${names.length > 1 ? "cover" : "covers"} ${it} (${edges}).`;
+  }
+  if (placement === "master") return `${what} ${sits} outside the space every size keeps clear (${edges}).`;
+  return `${what} ${under > 0 ? "run" : "runs"} off the edge of the picture (${edges}).`;
+}
+function bandSeverity(v, placement) {
+  if (placement === "master" || v.clearance <= FRAME_CUT) return "blocking";
+  if (placement === "feed") return null;
+  if (!v.covered) return null;
+  return "blocking";
+}
+var EDGE_ORDER = ["top", "bottom", "left", "right"];
+function oneLogo(violations) {
+  const logo = violations.filter((v) => v.kind === "logo");
+  if (logo.length <= 1) return [...violations];
+  const edges = EDGE_ORDER.filter((e) => logo.some((v) => v.edges.includes(e)));
+  const merged = {
+    text: "",
+    kind: "logo",
+    edges,
+    overshoot: Math.max(...logo.map((v) => v.overshoot)),
+    clearance: Math.min(...logo.map((v) => v.clearance)),
+    covered: logo.some((v) => v.covered),
+    // `every` holds on no pieces at all: only a covered logo can be covered by Reels alone.
+    reelsOnly: logo.some((v) => v.covered) && logo.filter((v) => v.covered).every((v) => v.reelsOnly)
+  };
+  const first = violations.indexOf(logo[0]);
+  const rest = violations.filter((v) => v.kind !== "logo");
+  return [...rest.slice(0, first), merged, ...rest.slice(first)];
+}
+var SEPARATE = 0.1;
+function apart(a, b) {
+  const across = Math.max(0, b.x0 - a.x1, a.x0 - b.x1);
+  const down = Math.max(0, b.y0 - a.y1, a.y0 - b.y1);
+  return Math.max(across, down) > SEPARATE;
+}
+function misplacedBlocks(boxes, check, supports = () => false) {
+  const checked = readingOrder(boxes).map((box) => ({ box, violation: check(box) }));
+  const clearLogos = checked.filter((c) => c.box.kind === "logo" && !c.violation).map((c) => c.box);
+  const past = checked.flatMap(
+    ({ box, violation }) => violation && !(box.kind === "logo" && clearLogos.length > 0 && clearLogos.every((l) => apart(l, box))) ? [{ box, violation }] : []
+  );
+  const logos = oneLogo(past.filter((p) => p.violation.kind === "logo").map((p) => p.violation));
+  const blocks = [];
+  for (const { box, violation } of past.filter((p) => p.violation.kind !== "logo")) {
+    const open = blocks[blocks.length - 1];
+    const same = open && continuesColumn(open.last, box) !== null && open.first.covered === violation.covered && Boolean(open.first.reelsOnly) === Boolean(violation.reelsOnly) && open.first.edges.join() === violation.edges.join();
+    if (open && same) {
+      open.last = box;
+      open.under++;
+      open.supporting = open.supporting && supports(box);
+      if (violation.clearance < open.worst.clearance) open.worst = violation;
+      continue;
+    }
+    blocks.push({ last: box, first: violation, under: 0, worst: violation, supporting: supports(box) });
+  }
+  return [
+    ...blocks.map((b) => ({
+      violation: { ...b.first, clearance: b.worst.clearance },
+      under: b.under,
+      supporting: b.supporting
+    })),
+    ...logos.map((violation) => ({ violation, under: 0 }))
+  ];
+}
+function measuredFindings(input) {
+  const { format } = input;
+  const text = textMismatch(input.lines, input.boxes, { allowed: input.allowed });
+  const area = staticSafeArea(format, input.placements);
+  const placement = input.band ? "master" : area.placement;
+  const names = (input.logoWords ?? input.allowed ?? []).filter((n) => normalizeCopy(n).length > 0);
+  const placed = withWordmark(input.boxes, names);
+  const bandOpts = {
+    ...input.placements ? { placements: input.placements } : {},
+    ...input.band ? { band: input.band } : {}
+  };
+  const copyBoxes = new Set(input.lines.flatMap((line) => boxesOfLine(line, input.boxes)));
+  const shown = shownBoxes(placed, input.lines, (box) => bandViolations([box], format, bandOpts).length === 0).filter(
+    (s) => !(input.native && s.box.kind === "text" && interfaceWord(s.box.text, input.allowed))
+  );
+  const supporting = new Set(shown.filter((s) => s.supporting).map((s) => s.box));
+  const blockers = blockingPlacements(input.placements);
+  const storiesToo = blockers.includes("stories");
+  const storiesAlone = blockers.filter((p) => p !== "reels");
+  const misplaced = misplacedBlocks(
+    shown.map((s) => s.box),
+    (box) => {
+      const v = bandViolations([box], format, bandOpts)[0];
+      if (!v?.covered || placement !== "reels" || !storiesToo) return v;
+      const inStories = bandViolations([box], format, { placements: storiesAlone })[0];
+      return inStories?.covered ? v : { ...v, reelsOnly: true };
+    },
+    (box) => supporting.has(box)
+  );
+  const blocking = (what) => ({ severity: "blocking", what: `${format}: ${what}` });
+  const small = leadTooSmall(format, input.lines, input.boxes);
+  const scale = typeScaleFindings(format, input.lines, placed);
+  const logos = input.expectLogo ? logoCountFinding(placed) : null;
+  const said = (l) => l.read === null ? `Text: "${l.text}" is missing.` : `Text: "${l.text}" reads "${l.read}".`;
+  const misspelt = misspeltNames([...placed.filter((b) => b.kind === "logo").map((b) => b.text), ...text.extra], names);
+  const unasked = text.extra.filter(
+    (chunk) => (
+      // A symbol with no word or number ("€", "%") is a mark beside one, never copy (Oct 2026 bench).
+      /[\p{L}\p{N}]/u.test(chunk) && !misspelt.some((m) => m.chunk === chunk) && // The logo read in pieces ("EALDE", then "Business School" under it) is the logo.
+      !fragmentOf(chunk, names, { share: 1, cut: input.native === true }) && !(input.native && (fragmentOf(chunk, input.allowed ?? [], { cut: true }) || crumb(chunk)))
+    )
+  );
+  const copyTexts = input.lines.map((l) => l.text);
+  const echoes = unasked.filter((chunk) => fragmentOf(chunk, copyTexts, { share: 0.8, cut: input.native === true }));
+  const twice = echoes.filter((chunk) => mostOfALine(chunk, copyTexts));
+  const extra = unasked.filter((chunk) => !echoes.includes(chunk));
+  return [
+    ...text.lines.flatMap((l) => {
+      if (input.native && l.read !== null) return [];
+      if (!input.adapted || loadBearing(l)) return [blocking(said(l))];
+      return l.similarity >= MEANING_MATCH ? [] : [{ severity: "warning", what: `${format}: ${said(l)}` }];
+    }),
+    ...extraWordFindings(format, extra, input.boxes, [...copyBoxes], input.offers ?? /* @__PURE__ */ new Set()),
+    ...twice.map(
+      (t) => ({ severity: "warning", what: `${format}: "${t}" is on the ad twice; keep it once.` })
+    ),
+    ...misspelt.map((m) => blocking(`the brand's name reads "${m.read}", not "${m.name}".`)),
+    ...unbadgedClaims(input.lines, input.boxes, input.cited).map(
+      (c) => blocking(
+        `"${c.line}" names ${c.platform}, but ${c.platform}'s logo is not on the ad: show its real badge, or drop the claim.`
+      )
+    ),
+    // A native screen is laid out as its app lays it out: only what the interface really covers is a defect.
+    ...(input.native ? misplaced.filter((m) => m.violation.covered) : misplaced).flatMap((m) => {
+      const severity = bandSeverity(m.violation, placement);
+      if (!severity) return [];
+      const what = `${format}: ${outsideBand(m, placement, area.surface, storiesToo)}`;
+      const optional = severity === "blocking" && m.supporting && placement !== "master" && m.violation.clearance > FRAME_CUT;
+      return optional ? [{ severity: "warning", what: `${what} Fine for a supporting line nobody has to read.` }] : [{ severity, what }];
+    }),
+    ...small ? [blocking(`the lead line "${small}" is too small to read at the size the feed shows the ad.`)] : [],
+    ...scale.map((what) => ({ severity: "warning", what: `${format}: ${what}` })),
+    ...logos ? [{ severity: "warning", what: `${format}: ${logos}` }] : [],
+    ...(input.offBrand ?? []).map(
+      (ink) => ({
+        severity: "warning",
+        what: `${format}: "${ink.text}" is set in a colour that is not one of the brand's.`
+      })
+    )
+  ];
+}
+function leadLine(lines) {
+  return lines.find((l) => FIGURE_ROLES.has(roleKey(l.role))) ?? lines.find((l) => HEADLINE_ROLES2.has(roleKey(l.role)));
+}
+var FIGURE_ROLES = /* @__PURE__ */ new Set(["price", "stat", "figure", "number", "discount"]);
+var HEADLINE_ROLES2 = /* @__PURE__ */ new Set(["headline", "title"]);
+var LEAD_MIN_PX = 9;
+function leadTooSmall(format, lines, boxes) {
+  const ratio = ratioOf(format);
+  if (ratio === null) return null;
+  const lead = lines.find((l) => FIGURE_ROLES.has(roleKey(l.role))) ?? lines.find((l) => HEADLINE_ROLES2.has(roleKey(l.role)));
+  if (!lead) return null;
+  const found = boxesOfLine(lead, boxes);
+  if (found.length === 0) return null;
+  const tallest2 = Math.max(...found.map((b) => b.y1 - b.y0));
+  const thumbnailHeight = THUMBNAIL_WIDTH / ratio;
+  return tallest2 * thumbnailHeight < LEAD_MIN_PX ? lead.text : null;
+}
+var LOAD_BEARING_ROLES = /* @__PURE__ */ new Set([
+  ...FIGURE_ROLES,
+  ...HEADLINE_ROLES2,
+  "cta",
+  "button",
+  "call_to_action",
+  "offer",
+  "claim",
+  "rating",
+  "quote",
+  "testimonial",
+  "attribution",
+  "badge",
+  "fine_print",
+  "legal",
+  "disclaimer",
+  "footnote"
+]);
+var MEANING_MATCH = 0.8;
+function loadBearing(line) {
+  return LOAD_BEARING_ROLES.has(roleKey(line.role)) || /[\d%€$£]/.test(line.text);
+}
+var folded = (text) => normalizeCopy(text).normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "");
+var MISSPELT_NAME = 0.7;
+function misspeltNames(texts, names) {
+  const out = [];
+  const distinct = names.filter((name, i) => names.findIndex((n) => folded(n) === folded(name)) === i);
+  for (const chunk of texts) {
+    const words = folded(chunk).split(" ").filter(Boolean);
+    for (const name of distinct) {
+      const want = folded(name);
+      const size = want.split(" ").length;
+      if (want.length < 4) continue;
+      for (let i = 0; i + size <= words.length; i++) {
+        const read = words.slice(i, i + size).join(" ");
+        if (read === want || copySimilarity(read, want) < MISSPELT_NAME) continue;
+        out.push({ chunk, read, name });
+        break;
+      }
+    }
+  }
+  return out;
+}
+function unbadgedClaims(lines, boxes, cited) {
+  return lines.flatMap((line) => {
+    const platform = citedBy(line.text, cited);
+    if (!platform) return [];
+    const naming = boxes.filter((b) => b.kind === "text" && namedPlatform(b.text) === platform);
+    const mentions = new RegExp(platform.pattern.source, `${platform.pattern.flags}g`);
+    const said = lines.reduce((n, l) => n + (l.text.match(mentions) ?? []).length, 0);
+    const badge = boxes.some((b) => b.kind === "logo" && namedPlatform(b.text) === platform) || naming.length > said && naming.some((b) => normalizeCopy(b.text).split(" ").length <= 3);
+    return badge ? [] : [{ line: line.text, platform: platform.name }];
+  });
+}
+var BUTTON_ROLES = /* @__PURE__ */ new Set(["cta", "button", "call_to_action"]);
+var FINE_PRINT_ROLES = /* @__PURE__ */ new Set(["fine_print", "legal", "disclaimer", "footnote"]);
+var PHONE_WIDTH = 400;
+var LINE_MIN_PX = 6;
+var INVERTED = 1.15;
+var tallest = (line, boxes) => {
+  const found = boxesOfLine(line, boxes);
+  return found.length > 0 ? Math.max(...found.map((b) => b.y1 - b.y0)) : null;
+};
+function typeScaleFindings(format, lines, boxes) {
+  const ratio = ratioOf(format);
+  if (ratio === null) return [];
+  const lead = leadLine(lines);
+  const leadsWithHeadline = lead !== void 0 && HEADLINE_ROLES2.has(roleKey(lead.role));
+  const supporting = lines.filter(
+    (l) => l !== lead && !(leadsWithHeadline && HEADLINE_ROLES2.has(roleKey(l.role))) && l.lettering === "designed" && !BUTTON_ROLES.has(roleKey(l.role)) && !FINE_PRINT_ROLES.has(roleKey(l.role))
+  );
+  const out = [];
+  const leadHeight = lead ? tallest(lead, boxes) : null;
+  if (lead && leadHeight !== null) {
+    const bigger = supporting.map((l) => ({ l, h: tallest(l, boxes) })).filter((x) => x.h !== null && x.h > leadHeight * INVERTED).sort((a, b) => b.h - a.h)[0];
+    if (bigger)
+      out.push(`the main line "${lead.text}" is smaller than "${bigger.l.text}", so people read the wrong line first.`);
+  }
+  const phoneHeight = PHONE_WIDTH / ratio;
+  const small = supporting.filter((line) => {
+    const h = tallest(line, boxes);
+    return h !== null && h * phoneHeight < LINE_MIN_PX;
+  });
+  const [only] = small;
+  if (small.length === 1 && only) out.push(`"${only.text}" is hard to read on a phone; make it bigger.`);
+  if (small.length > 1) {
+    out.push(
+      `${small.length} lines are hard to read on a phone (${small.map((l) => `"${l.text}"`).join(", ")}); make them bigger.`
+    );
+  }
+  return out;
+}
+var SCENE_MARK_SHARE = 0.25;
+var LOGO_GAP = 0.05;
+function logoCountFinding(boxes) {
+  const logos = boxes.filter((b) => b.kind === "logo");
+  const near = (a, b) => Math.max(a.x0 - b.x1, b.x0 - a.x1, 0) <= LOGO_GAP && Math.max(a.y0 - b.y1, b.y0 - a.y1, 0) <= LOGO_GAP;
+  const clusters = [];
+  for (const box of logos) {
+    const joined = clusters.filter((c) => c.some((b) => near(b, box)));
+    const merged = [box, ...joined.flat()];
+    for (const c of joined) clusters.splice(clusters.indexOf(c), 1);
+    clusters.push(merged);
+  }
+  if (clusters.length === 0) return "the brand's logo is not on it.";
+  const area = (c) => (Math.max(...c.map((b) => b.x1)) - Math.min(...c.map((b) => b.x0))) * (Math.max(...c.map((b) => b.y1)) - Math.min(...c.map((b) => b.y0)));
+  const largest = Math.max(...clusters.map(area));
+  const set = clusters.filter((c) => area(c) >= largest * SCENE_MARK_SHARE).length;
+  return set > 1 ? `the logo is on the ad ${set} times; keep it once.` : null;
+}
+function staticVerdict(findings) {
+  if (findings === null) return "not_reviewed";
+  if (findings.some((f) => f.severity === "blocking")) return "needs_fixes";
+  return findings.length > 0 ? "ready_with_notes" : "ready";
+}
+function textInstructions(copy, measured) {
+  const wordless = "This ad has no words on purpose: the picture is the ad. Do not report missing copy, a missing headline or a missing call to action.";
+  if (measured) {
+    return [
+      ...copy.length === 0 ? [wordless] : [],
+      "The words were already read back and measured by another check: do not transcribe them or report their spelling, extra words or position.",
+      "1. TEXT: garbled or malformed letters, or letters that do not read as words (a brand name inside a drawn logo is fine)."
+    ];
+  }
+  if (copy.length > 0) {
+    return [
+      "First, transcribe the copy. On every full-size image, find each of these strings and copy out EXACTLY what is printed there, character for character (accents, case, punctuation), or null when nothing like it is there:",
+      copy.map((c) => `- "${c}"`).join("\n"),
+      "1. TEXT: extra words that are not in the list, a string shown twice, or garbled letters (a brand name inside a drawn logo is fine)."
+    ];
+  }
+  return [wordless, "1. TEXT: any letters or words that appear anyway (invented or garbled text is blocking)."];
+}
+function storiesItem(opts) {
+  if (opts.measured || !opts.formats.includes("9:16")) return [];
+  const vertical = staticSafeArea("9:16");
+  const name = vertical.placement === "reels" ? "REELS AND STORIES" : vertical.surface.toUpperCase();
+  return [
+    `4. ${name}: on the 9:16 image, text, a logo or a button that exists clearly inside the top ${Math.round(vertical.top * 100)}% or the bottom ${Math.round(vertical.bottom * 100)}% of the frame (measure it; an element that starts below the top line is fine).`
+  ];
+}
+var VITAL_ROLE = { stop: "what stops the scroll", proof: "the proof" };
+function conceptItem(opts) {
+  const concept = opts.concept && opts.concept.mustKeep.length > 0 ? opts.concept : void 0;
+  if (concept) {
+    const vital = concept.vital ?? [];
+    return [
+      `8. CONCEPT: the last image is the ad this one is built on, shown only to compare (never judge its words, brand or people, which are another advertiser's). On every size, check the finished ad still carries each of these: ${concept.mustKeep.join("; ")}${concept.idea ? `, and still works by the same trick: ${concept.idea}` : ""}. Judge each by the role it plays, never by the form the reference gave it (a newspaper on a desk carries a newspaper held in hands; other words carry the same pain): an element is carried when the ad does its job, and what people are doing, how many there are, the setting or the visual style is never a finding. The trick is how the ad persuades, never a look it must have. One element missing is blocking: name it, in a sentence a marketer reads (what the ad no longer does), never a list of details.`,
+      ...vital.length > 0 ? [
+        `8a. WHAT IT WON ON: for every size, answer in "keeps" whether the finished ad still has each of these, doing the job it does in the last image: ${vital.map((v, i) => `${i + 1}. ${VITAL_ROLE[v.job]}: ${v.keep}`).join("; ")}. "carried" is false when it is not there, or is there but no longer does that job (marks gone from a checklist, a face too small to stop anyone); then say in "what", in a sentence a marketer reads, what the ad no longer does.`
+      ] : []
+    ];
+  }
+  return opts.mechanisms && opts.mechanisms.length > 0 ? [`8. CONCEPT: the ad no longer carries these devices it is built on (warning): ${opts.mechanisms.join("; ")}.`] : [];
+}
+function contextItems(opts) {
+  return {
+    // The pre-render viewer check read the copy and a description of the picture; this reads
+    // the picture. A warning: the render is paid for, and the copy already passed that viewer.
+    viewer: opts.viewer ? [
+      `9. VIEWER: seen by ${opts.viewer}, the finished ad does not show what is offered, to whom, and what to do next (warning).`
+    ] : [],
+    // Measured, the lead's size is checked on its boxes (`leadTooSmall`): the model's call was wrong on most flags.
+    thumbnail: opts.measured ? [] : [
+      opts.thumbnails ? "7. THUMBNAIL: at thumbnail size the lead line (the largest words) cannot be read. Judge only whether those words can be read, nothing else. That is blocking: most people only ever see the ad that small." : "7. THUMBNAIL: the lead line (the largest words) would be unreadable on a phone feed. That is blocking."
+    ],
+    sizes: opts.formats.length > 1 ? [
+      "12. SIZES: one size loses what the others are built on: the letter sheet, the email or chat window, the post card, the comic's panels and their order, the product the ad is about (blocking; report it on the size that differs). A size that shows more of the scene (words on a prop now readable, more of the room), or is arranged, sized or decorated differently for its shape (a title without its frame, an extra brand shape filling the height), is never a finding."
+    ] : []
+  };
+}
+var FINDING_FIELDS = `For each finding also give: "item", the item above it answers, in lower case (TEXT \u2192 "text", ONE IDEA \u2192 "one_idea", the 9:16 safe-zone item \u2192 "safe_zone"); "element", what on the ad it is about ("copy" the ad's own words, "button", "logo", "scene_text" words or figures printed on something in the picture that are not the copy, "picture" anything else drawn, else "other"); "defect" ("cut" when the frame's edge cuts it, "missing" when it is not there, "unreadable" when it is too blurred or small to read, else "other"); "edges", the frame edges that cut it, [] unless "cut". Write "what" without a label.`;
+function buildStaticReviewPrompt(opts) {
+  const brand = opts.brand ? ` for ${opts.brand}` : "";
+  const order = opts.formats.join(", ");
+  const shown = opts.thumbnails ? `These are the finished versions of ONE static advertisement${brand}, in this order: ${order}. After them come the same versions again, in the same order, shrunk to phone-feed thumbnail size (about 240px wide).` : `These are the finished versions of ONE static advertisement${brand}, in this order: ${order}.`;
+  const text = textInstructions(opts.copy, opts.measured === true);
+  const logo = opts.native ? `2. LOGO: the brand's logo appears where ${opts.native} shows it (an avatar, a sender's picture, a summary card), possibly more than once: report it only when distorted or cut.` : opts.logo ? "2. LOGO: the brand logo distorted, redrawn in another style, cut off, or set twice as the ad's logo. The brand's mark printed on something in the scene (clothing, a bag, a van, packaging) is the scene, never a second logo; call it mirrored only when its letters read backwards." : "2. LOGO: this ad carries no logo on purpose (the platform shows the brand's name and picture); never report a missing logo. A made-up logo or wordmark in the picture is blocking.";
+  const { viewer, thumbnail, sizes } = contextItems(opts);
+  const copyShape = opts.copy.length > 0 && !opts.measured ? ',"copy":[{"format":"4:5","string":"<a listed string>","seen":"<what is printed>|null"}]' : "";
+  const keepsShape = opts.concept?.vital?.length ? ',"keeps":[{"format":"4:5","element":1,"carried":true,"what":""}]' : "";
+  return [
+    shown,
+    ...text,
+    "",
+    "Then report, per format, only what is actually wrong:",
+    logo,
+    "3. LAYOUT: anything the ad shows clipped by the frame edge (part of a word, the logo, a button, the product or a face cut away; an element whole but near the edge is not clipped, and scenery the frame crops as any photo does is the picture), overlapping, or unreadable against what is behind it.",
+    ...storiesItem(opts),
+    // Tier 0, Oct 2026: the real defects were where a size was extended; 8 of 8 hand claims checked were wrong.
+    "5. PICTURE: a ghost, a smear, a seam, a blurred strip, a duplicated or mirrored object, or garbled pseudo-text in focus where a viewer reads it, typically where the picture was extended to fill a size (blocking). Text out of focus in the background (a screen, a shelf of books) is the scene; an ordinary object a viewer would not stop at on a phone is not malformed.",
+    "5a. SUBJECT: the ad's subject (its pet, person or product) shown more than once as visibly different ones where the ad means one, or a second, different subject beside it that leaves a viewer asking whose story it is (blocking).",
+    ...opts.uncastPeople && opts.uncastPeople.length > 0 ? [
+      `5c. PERSON: the copy names ${opts.uncastPeople.join(" and ")}, real, and this ad was given no photo of them: a face shown as them or beside their name is a stranger wearing that name (blocking).`
+    ] : [],
+    ...opts.castsNobody ? [
+      "5d. PERSON: this ad casts nobody: any person in the picture (a face or a body, not a tiny round avatar inside an interface) is a stranger nobody cast (blocking)."
+    ] : [],
+    "5b. PEOPLE: a person's hands, face or body drawn so wrong a viewer would notice at a glance on a phone (warning). Never a detail you have to zoom in to see.",
+    "6. ONE IDEA: two or more elements compete equally for the eye, so no single promise leads (warning).",
+    ...thumbnail,
+    ...conceptItem(opts),
+    ...viewer,
+    "11. PROOF: stars, a rating or reviews shown while the ad names no source for them anywhere (a review platform, a survey such as CSAT or NPS, a study), so the rating has no source (blocking).",
+    ...sizes,
+    ...opts.native ? [
+      `13. NATIVE: this ad is ${opts.native}, drawn exactly as the platform shows it: its interface, names, handles, times and counts are meant to be there, and whatever of them it leaves out is left out on purpose (never report the interface as wrong, incomplete or clipped); on a 9:16 the app fills the screen as a phone shows it, its bars and the card with the brand's headline included, and a chat's earliest messages scrolled up under the header are meant; on a wall of reviews the cards piled behind and cut by the frame's edges are the pile, never cut-off copy; the platform prints its own button under the ad, so never report a missing call to action. Report a photo in it that looks AI-made or staged rather than a real person's (blocking when a face is plainly AI-made), or that does not show what the words say (warning).`
+    ] : [],
+    "Blocking = it cannot ship as is (a broken logo, clipped content, a ghost or smear in the picture). Warning = it can ship but should improve.",
+    "Never report an element as missing because ads usually have one: judge only what this concept holds. An empty findings list is the right answer for a clean ad. Keep each item under twenty words.",
+    FINDING_FIELDS,
+    `Reply with only this JSON: {"findings":[{"severity":"blocking|warning","format":"4:5","item":"${STATIC_REVIEW_ITEMS.join("|")}","element":"${FINDING_ELEMENTS.join("|")}","defect":"${FINDING_DEFECTS.join("|")}","edges":["${FRAME_EDGES.join("|")}"],"what":"..."}]${copyShape}${keepsShape}}`
+  ].join("\n");
+}
+var SCENE_PRINT_SCALE = 0.45;
+var SCENE_BLOCK_LINES = 3;
+var LINE_REPEAT_SHARE = 0.6;
+function mostOfALine(chunk, copy) {
+  const wordsOf = (text) => normalizeCopy(text).split(" ").filter((w) => /[\p{L}\p{N}]/u.test(w));
+  const said = new Set(wordsOf(chunk));
+  return copy.some((line) => {
+    const words = wordsOf(line);
+    return words.length > 0 && words.filter((w) => said.has(w)).length / words.length >= LINE_REPEAT_SHARE;
+  });
+}
+var SIGN_CLAIM = /[%\p{Sc}]/u;
+var PRICE = /[€$£]\s?\d|\d\s?[€$£]/;
+var COPY_SIZE_SHARE = 0.8;
+var HEADLINE_SIZE_SHARE = 0.8;
+function extraWordFindings(format, extra, boxes, copyBoxes, offers) {
+  if (extra.length === 0) return [];
+  const heights = copyBoxes.map((b) => b.y1 - b.y0).filter((h) => h > 0);
+  const smallest = heights.length > 0 ? Math.min(...heights) : 0;
+  const boxOf = (chunk) => boxes.find((b) => b.kind === "text" && normalizeCopy(b.text).includes(normalizeCopy(chunk)));
+  const height = (chunk) => {
+    const box = boxOf(chunk);
+    return box === void 0 ? null : box.y1 - box.y0;
+  };
+  const sorted = [...heights].sort((a, b) => a - b);
+  const usual = sorted[Math.floor(sorted.length / 2)] ?? 0;
+  const tallest2 = sorted.at(-1) ?? 0;
+  const underCopy = extra.filter((chunk) => (height(chunk) ?? 0) < usual * COPY_SIZE_SHARE);
+  const scenery = (chunk) => {
+    const h = height(chunk);
+    return h !== null && h < smallest * SCENE_PRINT_SCALE || underCopy.length >= SCENE_BLOCK_LINES && underCopy.includes(chunk);
+  };
+  const belowHeadline = (chunk) => (height(chunk) ?? 0) < tallest2 * HEADLINE_SIZE_SHARE;
+  const offered = new Set([...offers].map(normalizeCopy));
+  const claims = (chunk) => SIGN_CLAIM.test(chunk) || offered.has(normalizeCopy(chunk));
+  const printed = (chunk) => usual > 0 && belowHeadline(chunk) && (!claims(chunk) || underCopy.includes(chunk) && scenery(chunk));
+  const quote = (chunks) => chunks.map((e) => `"${e}"`).join(", ");
+  const asCopy = extra.filter((chunk) => !printed(chunk));
+  const prices = extra.filter((chunk) => printed(chunk) && PRICE.test(chunk));
+  const inScene = extra.filter((chunk) => printed(chunk) && !prices.includes(chunk));
+  return [
+    ...asCopy.length > 0 ? [
+      {
+        severity: "blocking",
+        // `static-autofix.ts` EXTRA_WORDS reads this sentence to erase them.
+        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",
+        what: `${format}: words drawn in the scene, not in the copy: ${quote(inScene)}. Fine if they belong there.`
+      }
+    ] : []
+  ];
+}
+var SAME_PICTURE_BITS = 4;
+function hammingHex(a, b) {
+  let bits = 0;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    let x = Number.parseInt(a[i] ?? "0", 16) ^ Number.parseInt(b[i] ?? "0", 16);
+    while (x) {
+      bits += x & 1;
+      x >>= 1;
+    }
+  }
+  return bits;
+}
+async function nearIdenticalFindings(current, previous) {
+  const hash = async (source) => perceptualHash(await bytesOf(source).catch(() => Buffer.alloc(0)));
+  const out = [];
+  for (const image of current) {
+    const before = previous.find((p) => p.format === image.format);
+    if (!before) continue;
+    const [a, b] = await Promise.all([hash(image.path), hash(before.path)]);
+    if (a === null || b === null || hammingHex(a, b) > SAME_PICTURE_BITS) continue;
+    out.push({
+      severity: "warning",
+      what: `${image.format}: near-identical to the previous attempt: this retry changed nothing. Change what prompt.json asks for, or use a different fix, rather than running it again.`
+    });
+  }
+  return out;
+}
+async function samePictureSizes(current, previous) {
+  const digest = async (source) => createHash("sha256").update(await bytesOf(source).catch(() => Buffer.from(source))).digest("hex");
+  const same = [];
+  for (const image of current) {
+    const before = previous.find((p) => p.format === image.format);
+    if (before && await digest(image.path) === await digest(before.path)) same.push(image.format);
+  }
+  return same;
+}
+var AT_EDGE = 0.025;
+var clearanceTo = (b, edge) => edge === "top" ? b.y0 : edge === "bottom" ? 1 - b.y1 : edge === "left" ? b.x0 : 1 - b.x1;
+function measuredBoxes(element, boxes, buttons) {
+  if (element === "logo") return boxes.filter((b) => b.kind === "logo");
+  if (element === "button") return buttons.flatMap((l) => boxesOfLine(l, boxes));
+  return element === "copy" ? boxes.filter((b) => b.kind === "text") : [];
+}
+function corroborateEdgeClaims(findings, boxesByFormat, lines) {
+  const buttons = lines.filter((l) => /^(cta|button|call_to_action)$/.test(roleKey(l.role)));
+  return findings.map((f) => {
+    if (f.severity !== "blocking" || !f.kind || !cutByFrame(f)) return f;
+    const format = f.what.match(/^([\d.]+:[\d.]+):/)?.[1];
+    const boxes = format ? boxesByFormat[format] : void 0;
+    if (!boxes) return f;
+    const { element } = f.kind;
+    const measured = measuredBoxes(element, boxes, buttons);
+    if (measured.length === 0) return f;
+    const named = f.kind.edges.length > 0 ? f.kind.edges : ["top", "bottom", "left", "right"];
+    const pad = element === "button" ? BUTTON_PAD : 0;
+    const atEdge = measured.some((b) => named.some((edge) => clearanceTo(b, edge) - pad * (b.y1 - b.y0) <= AT_EDGE));
+    return atEdge ? f : { ...f, severity: "warning" };
+  });
+}
+async function bytesOf(source) {
+  if (!/^https?:\/\//i.test(source)) return await readFile(source);
+  const res = await fetch(source);
+  if (!res.ok) throw new Error(`fetch ${res.status}`);
+  return Buffer.from(await res.arrayBuffer());
+}
+var THUMBNAIL_WIDTH = 240;
+async function jpegFor(bytes, width) {
+  const resized = width ? sharp3(bytes).resize({ width, withoutEnlargement: true }) : sharp3(bytes).resize(1024, 1024, { fit: "inside", withoutEnlargement: true });
+  const jpeg = await resized.jpeg({ quality: 85 }).toBuffer();
+  return jpeg.toString("base64");
+}
+async function stillOf(source) {
+  try {
+    return await jpegFor(await bytesOf(source));
+  } catch {
+    return null;
+  }
+}
+async function designedInks(image, lines, boxes) {
+  const inks = [];
+  for (const line of lines.filter((l) => l.lettering === "designed")) {
+    const [box] = boxesOfLine(line, boxes);
+    const hex = box ? await inkOf(image, box) : null;
+    if (hex) inks.push({ text: line.text, hex });
+  }
+  return inks;
+}
+function interfaceWord(text, own = []) {
+  const read = normalizeCopy(text);
+  return crumb(text) || own.some((o) => normalizeCopy(o) === read);
+}
+function crumb(text) {
+  return normalizeCopy(text).split(" ").every((w) => w.length <= 2);
+}
+function fragmentOf(chunk, own, opts = {}) {
+  const share = opts.share ?? 0.5;
+  const words = normalizeCopy(chunk).split(" ").filter((w) => w.length > 1);
+  if (words.length === 0) return opts.cut === true;
+  return own.some((text) => {
+    const theirs = new Set(normalizeCopy(text).split(" "));
+    const shared = words.filter(
+      (w) => theirs.has(w) || opts.cut === true && [...theirs].some((t) => t.length > w.length && t.includes(w))
+    ).length;
+    return shared / words.length >= share;
+  });
+}
+var OFFER_MADE = 0.35;
+var OFFER_QUESTION = "Does `words` make an offer of its own: something free, a discount, a sale, a promotion, a deal or a price, in whatever language it is written? A sign, a label, a name or a screen's words are not an offer.";
+var offerQuestion = (words) => ({ instructions: { words, question: OFFER_QUESTION } });
+async function offersAmong(chunks, judge) {
+  const worded = chunks.filter((c) => new RegExp("\\p{L}", "u").test(c));
+  if (worded.length === 0) return /* @__PURE__ */ new Set();
+  const judged = await judge(worded);
+  return new Set(worded.filter((_, i) => (judged?.[i] ?? 0) >= OFFER_MADE));
+}
+async function checkStaticImage(image, opts) {
+  const reading = await (opts.read ?? ((bytes) => readTextBoxes(bytes, { onSpend: opts.onSpend })))(image);
+  if (reading.status === "not_checked") return reading;
+  const palette = opts.palette ?? [];
+  const inks = palette.length > 0 ? await designedInks(image, opts.lines, reading.boxes) : [];
+  const boxes = opts.toFrame ? opts.toFrame(reading.boxes) : reading.boxes;
+  const offers = await offersAmong(
+    textMismatch(opts.lines, boxes, { allowed: opts.allowed }).extra,
+    opts.judgeOffers ?? ((chunks) => askJev(chunks.map(offerQuestion), opts.onSpend))
+  );
+  const findings = measuredFindings({
+    format: opts.format,
+    boxes,
+    lines: opts.lines,
+    ...opts.allowed ? { allowed: opts.allowed } : {},
+    ...opts.logoWords ? { logoWords: opts.logoWords } : {},
+    ...opts.adapted ? { adapted: true } : {},
+    ...opts.expectLogo ? { expectLogo: true } : {},
+    ...opts.native ? { native: true } : {},
+    ...opts.placements ? { placements: opts.placements } : {},
+    ...opts.band ? { band: opts.band } : {},
+    offBrand: offBrandInks(inks, palette),
+    offers,
+    cited: opts.cited ?? await citedPlatforms(
+      opts.lines.map((l) => l.text),
+      opts.judgeCitations ?? jevCitationJudge(opts.onSpend)
+    )
+  });
+  return { status: "checked", findings, boxes };
+}
+async function loadDelivered(images) {
+  const measured = [];
+  const originals = [];
+  const stills = [];
+  const thumbs = [];
+  for (const image of images) {
+    try {
+      const bytes = await bytesOf(image.path);
+      const meta = await sharp3(bytes).metadata();
+      const still = await jpegFor(bytes);
+      const thumb = await jpegFor(bytes, THUMBNAIL_WIDTH);
+      measured.push({ format: image.format, width: meta.width ?? 0, height: meta.height ?? 0 });
+      originals.push(bytes);
+      stills.push(still);
+      thumbs.push(thumb);
+    } catch {
+    }
+  }
+  return { measured, originals, stills, thumbs };
+}
+function unreviewed(shape, measured) {
+  const known = [...shape, ...measured];
+  if (known.some((f) => f.severity === "blocking")) return known;
+  return shape.length > 0 ? shape : null;
+}
+function reviewPromptOpts(opts, formats, read, referenceShown) {
+  return {
+    copy: opts.copy,
+    formats,
+    brand: opts.brand,
+    logo: opts.logo,
+    thumbnails: !read,
+    mechanisms: opts.mechanisms,
+    viewer: opts.viewer,
+    ...referenceShown && opts.concept ? {
+      concept: {
+        mustKeep: opts.concept.mustKeep,
+        ...opts.concept.idea ? { idea: opts.concept.idea } : {},
+        ...opts.concept.vital?.length ? { vital: opts.concept.vital } : {}
+      }
+    } : {},
+    ...opts.native ? { native: opts.native } : {},
+    measured: read,
+    ...opts.uncastPeople && opts.uncastPeople.length > 0 ? { uncastPeople: opts.uncastPeople } : {},
+    ...opts.castsNobody ? { castsNobody: true } : {}
+  };
+}
+function scrolledOff(checks, gone) {
+  return {
+    ...checks,
+    lines: checks.lines.filter((l) => !gone.includes(l.text)),
+    allowed: [...checks.allowed ?? [], ...gone]
+  };
+}
+function everySizeChecks(opts) {
+  const logoWords = [...opts.brand ? [opts.brand] : [], ...opts.lockup ?? []];
+  return {
+    allowed: [...logoWords, ...opts.sceneText ?? []],
+    logoWords,
+    ...opts.expectLogo ? { expectLogo: true } : {},
+    ...opts.native ? { native: true } : {},
+    ...opts.placements ? { placements: opts.placements } : {},
+    ...opts.palette ? { palette: opts.palette } : {},
+    onSpend: opts.onSpend
+  };
+}
+async function reviewRenderedStatic(opts) {
+  const { measured, originals, stills, thumbs } = await loadDelivered(opts.images);
+  if (measured.length === 0) return null;
+  const ruling = rulesChecked(
+    stills,
+    measured.map((m) => m.format),
+    opts.rules ?? [],
+    opts.onSpend
+  );
+  const reference = opts.concept ? await stillOf(opts.concept.reference) : null;
+  const shape = ratioFindings(measured);
+  const formats = measured.map((m) => m.format);
+  const lines = opts.lines ?? opts.copy.map((text2) => ({ text: text2, lettering: "designed" }));
+  const every = { lines, ...everySizeChecks(opts) };
+  const ask = (measuredRead) => {
+    const prompt = buildStaticReviewPrompt(reviewPromptOpts(opts, formats, measuredRead, reference !== null));
+    const shown = [...measuredRead ? stills : [...stills, ...thumbs], ...reference ? [reference] : []];
+    return askAboutStills(shown, prompt, opts.onSpend);
+  };
+  const asking = ask(true);
+  const cited = await citedPlatforms(
+    lines.map((l) => l.text),
+    jevCitationJudge(opts.onSpend)
+  );
+  const checks = await Promise.all(
+    originals.map(
+      (bytes, i) => checkStaticImage(bytes, {
+        ...scrolledOff(every, opts.scrolled?.[formats[i] ?? ""] ?? []),
+        format: formats[i] ?? "",
+        adapted: opts.masterFormat !== void 0 && formats[i] !== opts.masterFormat,
+        cited
+      })
+    )
+  );
+  const read = checks.every((c) => c.status === "checked");
+  const measuredText = read ? checks.flatMap((c) => c.status === "checked" ? c.findings : []) : [];
+  if (!read) void asking.catch(() => null);
+  const first = read ? await asking : null;
+  const answer = first ?? await ask(read);
+  const ruled = await ruling;
+  if (answer === null) return unreviewed(shape, [...measuredText, ...ruled]);
+  const text = 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]] : [])) : {};
+  const judged = corroborateEdgeClaims(classifyStaticFindings(answer), boxesByFormat, lines);
+  const confirmed = await confirmBlocking(
+    judged,
+    stills,
+    formats,
+    (images, prompt) => askAboutStills(images, prompt, opts.onSpend)
+  );
+  const vital = reference && opts.concept?.vital ? vitalFindings(answer, opts.concept.vital, formats) : [];
+  return [...shape, ...text, ...confirmed, ...vital, ...ruled];
+}
+async function rulesChecked(stills, formats, rules, onSpend) {
+  if (reviewedRules(rules).length === 0) return [];
+  const found = await reviewAgainstRules({ stills, formats, rules, ...onSpend ? { onSpend } : {} }).catch(() => null);
+  return found ?? [
+    {
+      severity: "warning",
+      what: "The finished ad was not checked against the company's rules (the model did not answer): read it against `rules` in the brief yourself."
+    }
+  ];
+}
+
+export {
+  staticSafeArea,
+  videoSafeArea,
+  safeRectPx,
+  blockingArea,
+  blockingPlacements,
+  nativeLayoutInsets,
+  FRAME_CUT,
+  bandViolations,
+  normalizeCopy,
+  textMismatch,
+  roleKey,
+  withWordmark,
+  boxesOfLine,
+  headlineBox,
+  isButtonLine,
+  buttonShape,
+  shownBoxes,
+  readTextBoxes,
+  parseJudgeScores,
+  judgeWinner,
+  staticVerdict,
+  nearIdenticalFindings,
+  samePictureSizes,
+  bytesOf,
+  checkStaticImage,
+  reviewRenderedStatic
+};
+//# sourceMappingURL=chunk-ZJOXRK2G.js.map