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

package/dist/chunk-JGSEHX2Q.js

@@ -0,0 +1,3107 @@
+import {
+  LOGO_POSITIONS,
+  SubjectBoxSchema,
+  chooseLogoSpot,
+  deliveredSize,
+  designerSpots,
+  greyTable,
+  imageOf,
+  isRead,
+  logoSlotLine,
+  pngOf,
+  rawOf,
+  readSubjectBoxes,
+  spreadUnder,
+  straightEdgeIn,
+  subjectsStep,
+  timedStep
+} from "./chunk-Z5BG47PO.js";
+import {
+  FRAME_CUT,
+  bandViolations,
+  blockingArea,
+  blockingPlacements,
+  boxesOfLine,
+  buttonShape,
+  bytesOf,
+  isButtonLine,
+  readTextBoxes,
+  roleKey,
+  shownBoxes,
+  withWordmark
+} from "./chunk-LAMSUL26.js";
+import {
+  askAboutImages
+} from "./chunk-GRX3JXSR.js";
+import {
+  IMAGE_GENERATE_MODELS,
+  IMAGE_TIER_CREDITS,
+  MODEL_REGISTRY,
+  SIZE_MATCH_MODEL,
+  imagePictureCredits,
+  modelIdsAccepted,
+  supportedAspectRatios
+} from "./chunk-F3CZFUXZ.js";
+import {
+  ImageRef,
+  callBackendExec,
+  defineNode,
+  delegated
+} from "./chunk-CBVUO7SK.js";
+
+// src/engine/nodes/remote/image.ts
+import { z as z2 } from "zod";
+
+// src/engine/nodes/remote/registry-params.ts
+import { z } from "zod";
+function registryParamShape(kind, overrides = {}) {
+  const specs = Object.values(MODEL_REGISTRY[kind]);
+  const byParam = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    for (const [name, schema] of Object.entries(spec.params)) {
+      byParam.set(name, [...byParam.get(name) ?? [], schema]);
+    }
+  }
+  const shape = {};
+  for (const [name, schemas] of byParam) {
+    const type = overrides[name] ?? unionOf(schemas);
+    const requiredByAll = specs.every((spec) => spec.required.includes(name));
+    shape[name] = requiredByAll ? type : type.optional();
+  }
+  return shape;
+}
+function unionOf(schemas) {
+  const kinds = [...new Set(schemas.map((schema) => schema.kind))];
+  if (kinds.length > 1) {
+    const [first, second, ...rest] = kinds.map((k) => unionOf(schemas.filter((s) => s.kind === k)));
+    return z.union([first, second, ...rest]);
+  }
+  switch (kinds[0]) {
+    case "string":
+      return stringUnion(schemas);
+    case "number":
+      return numberUnion(schemas);
+    case "boolean":
+      return z.boolean();
+    default:
+      return z.unknown();
+  }
+}
+function stringUnion(schemas) {
+  if (schemas.some((schema) => !schema.enum)) return z.string();
+  const values = [...new Set(schemas.flatMap((schema) => schema.enum ?? []))];
+  return z.enum(values);
+}
+function numberUnion(schemas) {
+  if (schemas.some((schema) => !schema.enum)) return z.number();
+  const values = [...new Set(schemas.flatMap((schema) => schema.enum ?? []))].sort((a, b) => a - b);
+  return z.literal(values);
+}
+
+// src/engine/nodes/remote/image.ts
+var imageModelEnum = z2.enum(IMAGE_GENERATE_MODELS.flatMap(modelIdsAccepted));
+var ImageGenerateParams = z2.object({
+  model: imageModelEnum,
+  ...registryParamShape("image_generate", {
+    prompt: z2.string().min(1),
+    // Recraft v4 vector controls, sent as the provider's own `controls` block. The
+    // registry types them as JSON; this is their shape.
+    rgb_colors: z2.array(z2.array(z2.number().int().min(0).max(255))),
+    background_rgb_color: z2.array(z2.number().int().min(0).max(255))
+  })
+}).strict();
+var PRO_QUALITY = "max";
+function creditsPerImage(params) {
+  return params.quality === PRO_QUALITY ? IMAGE_TIER_CREDITS.pro : imagePictureCredits(String(params.model));
+}
+function imagesPerCall(params) {
+  return "n" in params && typeof params.n === "number" ? params.n : 1;
+}
+var imageGenerateNode = delegated({
+  id: "image_generate",
+  version: "2.2.0",
+  category: "image",
+  summary: "Generate images for ad creatives. Curated model set: GPT Image 2.5, Gemini 3.1 Flash Image, Gemini 3 Pro Image, Recraft v4.1 Pro Vector. Per-model param support comes from the canvas-engine model registry.",
+  when_to_use: "Use for hero shots, product photography, illustrations, and vector logos. `recraft/recraft-v4.1-pro-vector` for crisp vector / logo work; `openai/gpt-image-2` for photorealistic and in-image text (NOTE: it has no `image_size`, and no 4:5 / 5:4 \u2014 route portrait ad formats through Gemini or `image_aspect_adapt`); Gemini variants for fast iteration, extreme ratios, and editing via the `reference` input. `reference` accepts ONE image or an ARRAY of images \u2014 wire several to combine references in a single generation (e.g. a subject sheet + a font specimen + the original ad). Every reference is forwarded to the model in array order. `n` (only on models that declare it, e.g. `openai/gpt-image-2.5-sunburst`) returns several candidates of the same brief from one call, billed per image like separate calls; wire the whole `images` array into `image_select` to keep the best.",
+  // `reference` is one image or an ordered array of images. The backend forwards
+  // each as a separate `image_url` to the provider (OpenRouter accepts many).
+  inputs: z2.object({ reference: z2.union([ImageRef, z2.array(ImageRef).min(1)]).optional() }).loose(),
+  params: ImageGenerateParams,
+  outputs: z2.object({ images: z2.array(ImageRef).min(1) }).strict(),
+  outputKinds: { images: "image" },
+  // Per image: `n` asks one call for several, and the provider bills each (measured: n=3
+  // cost exactly 3x n=1, prompt tokens included). Usage-billed, so this is only the pre-run
+  // quote; the charge is the provider's reported cost.
+  cost: ({ params }) => ({
+    credits: creditsPerImage(params) * imagesPerCall(params),
+    seconds_estimate: 10
+  })
+});
+
+// src/engine/nodes/local/staticFormat.ts
+import sharp2 from "sharp";
+import { z as z3 } from "zod";
+
+// src/engine/nodes/local/lib/plate-panels.ts
+var READ_WIDTH = 288;
+var FLAT = 2;
+var STEP = 3;
+var RANGE = 12;
+var MIN_AREA = 0.015;
+var MIN_FILL = 0.6;
+function blockMean(img, x, y, f, c) {
+  let sum = 0;
+  for (let dy = 0; dy < f; dy++) {
+    for (let dx = 0; dx < f; dx++) sum += img.data[((y + dy) * img.width + x + dx) * img.channels + c] ?? 0;
+  }
+  return sum / (f * f);
+}
+function shrunk(img, f) {
+  const width = Math.floor(img.width / f);
+  const height = Math.floor(img.height / f);
+  const data = Buffer.alloc(width * height * 3);
+  for (let i = 0; i < width * height; i++) {
+    const x = i % width;
+    const y = (i - x) / width;
+    for (let c = 0; c < 3; c++) data[i * 3 + c] = Math.round(blockMean(img, x * f, y * f, f, c));
+  }
+  return { data, width, height, channels: 3 };
+}
+function spreadAt(grey, width, x, y) {
+  let sum = 0;
+  let squares = 0;
+  for (let dy = -2; dy <= 2; dy++) {
+    for (let dx = -2; dx <= 2; dx++) {
+      const v = grey[(y + dy) * width + x + dx] ?? 0;
+      sum += v;
+      squares += v * v;
+    }
+  }
+  const mean = sum / 25;
+  return Math.sqrt(Math.max(0, squares / 25 - mean * mean));
+}
+function flatOf(img) {
+  const { width, height } = img;
+  const grey = new Float32Array(width * height);
+  for (let i = 0; i < grey.length; i++)
+    grey[i] = 0.299 * (img.data[i * 3] ?? 0) + 0.587 * (img.data[i * 3 + 1] ?? 0) + 0.114 * (img.data[i * 3 + 2] ?? 0);
+  const flat = new Uint8Array(width * height);
+  for (let y = 2; y < height - 2; y++) {
+    for (let x = 2; x < width - 2; x++) flat[y * width + x] = spreadAt(grey, width, x, y) < FLAT ? 1 : 0;
+  }
+  return flat;
+}
+function take(r, img, i, x, y) {
+  r.count++;
+  r.x0 = Math.min(r.x0, x);
+  r.x1 = Math.max(r.x1, x);
+  r.y0 = Math.min(r.y0, y);
+  r.y1 = Math.max(r.y1, y);
+  for (let c = 0; c < 3; c++) {
+    const v = img.data[i * 3 + c] ?? 0;
+    r.lo[c] = Math.min(r.lo[c] ?? 255, v);
+    r.hi[c] = Math.max(r.hi[c] ?? 0, v);
+  }
+}
+var neighbours = (i, x, width, height) => [x > 0 ? i - 1 : -1, x < width - 1 ? i + 1 : -1, i - width, i + width].filter((j) => j >= 0 && j < width * height);
+function regionFrom(img, flat, seen, seed) {
+  const { width, height } = img;
+  const r = { x0: width, y0: height, x1: -1, y1: -1, count: 0, range: 0, lo: [255, 255, 255], hi: [0, 0, 0] };
+  const near = (a, b) => [0, 1, 2].every((c) => Math.abs((img.data[a * 3 + c] ?? 0) - (img.data[b * 3 + c] ?? 0)) <= STEP);
+  seen[seed] = 1;
+  const stack = [seed];
+  for (let i = stack.pop(); i !== void 0; i = stack.pop()) {
+    const x = i % width;
+    take(r, img, i, x, (i - x) / width);
+    for (const j of neighbours(i, x, width, height)) {
+      if (!flat[j] || seen[j] || !near(i, j)) continue;
+      seen[j] = 1;
+      stack.push(j);
+    }
+  }
+  const range = Math.max(...[0, 1, 2].map((c) => (r.hi[c] ?? 0) - (r.lo[c] ?? 0)));
+  return { x0: r.x0, y0: r.y0, x1: r.x1, y1: r.y1, count: r.count, range };
+}
+function isPanel(r, width, height) {
+  const inside = r.x0 > 2 && r.y0 > 2 && r.x1 < width - 3 && r.y1 < height - 3;
+  const box = (r.x1 - r.x0 + 1) * (r.y1 - r.y0 + 1);
+  return inside && box >= MIN_AREA * width * height && r.count >= MIN_FILL * box && r.range <= RANGE;
+}
+function platePanels(img) {
+  const f = Math.max(1, Math.round(img.width / READ_WIDTH));
+  const small = f > 1 || img.channels !== 3 ? shrunk(img, f) : img;
+  const flat = flatOf(small);
+  const seen = new Uint8Array(flat.length);
+  const panels = [];
+  for (let i = 0; i < flat.length; i++) {
+    if (!flat[i] || seen[i]) continue;
+    const r = regionFrom(small, flat, seen, i);
+    if (!isPanel(r, small.width, small.height)) continue;
+    panels.push({
+      x0: r.x0 / small.width,
+      y0: r.y0 / small.height,
+      x1: (r.x1 + 1) / small.width,
+      y1: (r.y1 + 1) / small.height,
+      area: (r.x1 - r.x0 + 1) * (r.y1 - r.y0 + 1)
+    });
+  }
+  return panels.sort((a, b) => b.area - a.area).map(({ area: _area, ...span }) => span);
+}
+
+// src/engine/nodes/local/lib/subject-crop.ts
+var SUBJECT_PAD = 0.02;
+function ratioOf(ratio) {
+  const [w, h] = ratio.split(":").map(Number);
+  if (!w || !h || !Number.isFinite(w) || !Number.isFinite(h)) throw new Error(`not a W:H ratio: "${ratio}"`);
+  return w / h;
+}
+var unionOf2 = (spans) => spans.length === 0 ? null : { from: Math.min(...spans.map((s) => s.from)), to: Math.max(...spans.map((s) => s.to)) };
+function placeAxis(full, length, hard, soft, core) {
+  const clampFull = (v) => Math.min(full - length, Math.max(0, v));
+  const want = soft ? soft.to - soft.from <= length ? (soft.from + soft.to) / 2 - length / 2 : soft.from - SUBJECT_PAD * full : (core.from + core.to) / 2 - length / 2;
+  if (!hard) return { at: Math.round(clampFull(want)), fits: true };
+  const pad = SUBJECT_PAD * full;
+  for (const p of [pad, 0]) {
+    const lo = Math.max(0, hard.to + p - length);
+    const hi = Math.min(full - length, hard.from - p);
+    if (lo <= hi + 1e-6) return { at: Math.round(Math.min(hi, Math.max(lo, want))), fits: true };
+  }
+  return { at: Math.round(clampFull((hard.from + hard.to) / 2 - length / 2)), fits: false };
+}
+function subjectCrop(plate, format, subjects, opts = {}) {
+  const cards = (opts.panels ?? []).map((p) => ({ kind: "product", label: "card", ...p }));
+  if (cards.length > 0) {
+    const withCards = cropAround(plate, format, [...subjects ?? [], ...cards], opts);
+    if (withCards.fits) return withCards;
+  }
+  return cropAround(plate, format, subjects, opts);
+}
+function cropAround(plate, format, subjects, opts) {
+  const r = ratioOf(format);
+  let width = plate.width;
+  let height = Math.round(plate.width / r);
+  if (height > plate.height) {
+    height = plate.height;
+    width = Math.round(plate.height * r);
+  }
+  const boxes = subjects ?? [];
+  const px = (b) => ({ from: b.x0 * plate.width, to: b.x1 * plate.width });
+  const py = (b) => ({ from: b.y0 * plate.height, to: b.y1 * plate.height });
+  const hardY = boxes.map((b) => b.kind === "person" ? { from: py(b).from, to: py(b).from } : py(b));
+  const core = opts.core ?? { x0: 0, y0: 0, x1: 1, y1: 1 };
+  const x = placeAxis(plate.width, width, unionOf2(boxes.map(px)), unionOf2(boxes.map(px)), {
+    from: core.x0 * plate.width,
+    to: core.x1 * plate.width
+  });
+  const y = placeAxis(plate.height, height, unionOf2(hardY), unionOf2(boxes.map(py)), {
+    from: core.y0 * plate.height,
+    to: core.y1 * plate.height
+  });
+  const rect = { x: x.at, y: y.at, width, height };
+  const cut = boxes.filter((b, i) => {
+    const hy = hardY[i] ?? py(b);
+    return px(b).from < rect.x - 0.5 || px(b).to > rect.x + rect.width + 0.5 || hy.from < rect.y - 0.5 || hy.to > rect.y + rect.height + 0.5;
+  }).map((b) => b.label);
+  return { rect, render: renderRect(plate, rect, format, opts.renderRatios), fits: cut.length === 0, cut };
+}
+function renderRect(plate, rect, format, ratios) {
+  if (!ratios || ratios.includes(format)) return { ...rect, ratio: format };
+  const r = rect.width / rect.height;
+  let best = null;
+  for (const ratio of ratios) {
+    const c = ratioOf(ratio);
+    const width = c <= r ? rect.width : Math.round(rect.height * c);
+    const height = c <= r ? Math.round(rect.width / c) : rect.height;
+    if (width > plate.width || height > plate.height) continue;
+    const place = (from, length, inner, full) => Math.min(
+      Math.min(from, full - length),
+      Math.max(Math.max(0, from + inner - length), from - (length - inner) / 2)
+    );
+    const candidate = {
+      x: Math.round(place(rect.x, width, rect.width, plate.width)),
+      y: Math.round(place(rect.y, height, rect.height, plate.height)),
+      width,
+      height,
+      ratio
+    };
+    if (!best || width * height < best.width * best.height) best = candidate;
+  }
+  return best ?? { ...rect, ratio: format };
+}
+
+// src/engine/nodes/local/lib/picture-memo.ts
+var ids = /* @__PURE__ */ new WeakMap();
+var nextId = 0;
+function pictureId(picture) {
+  const known = ids.get(picture);
+  if (known !== void 0) return known;
+  const id = nextId++;
+  ids.set(picture, id);
+  return id;
+}
+function remembered() {
+  const readings = /* @__PURE__ */ new WeakMap();
+  return (picture, what, read) => {
+    const known = readings.get(picture) ?? /* @__PURE__ */ new Map();
+    readings.set(picture, known);
+    const kept = known.get(what);
+    if (kept !== void 0) return kept;
+    const value = read();
+    known.set(what, value);
+    return value;
+  };
+}
+
+// src/engine/nodes/local/lib/words-band.ts
+var GROUND_REACH = 0.06;
+var LAID = 24;
+var BAND_EDGE = 0.5;
+var BAND_CLEAR = 0.1;
+var SOLID = 0.7;
+var RING = 0.01;
+var LOOK_STRIP = 0.1;
+var greyAt = (img, i) => 0.299 * (img.data[i * img.channels] ?? 0) + 0.587 * (img.data[i * img.channels + 1] ?? 0) + 0.114 * (img.data[i * img.channels + 2] ?? 0);
+function laidMap(aligned, cut) {
+  const { width, height } = cut;
+  const laid = new Uint8Array(width * height);
+  for (let i = 0; i < laid.length; i++) laid[i] = Math.abs(greyAt(aligned, i) - greyAt(cut, i)) > LAID ? 1 : 0;
+  return { laid, width, height };
+}
+var rectOf = (s, width, height) => ({
+  x0: Math.floor(s.x0 * width),
+  y0: Math.floor(s.y0 * height),
+  x1: Math.ceil(s.x1 * width),
+  y1: Math.ceil(s.y1 * height)
+});
+var clipped = (r, width, height) => ({
+  x0: Math.max(0, r.x0),
+  y0: Math.max(0, r.y0),
+  x1: Math.min(width, r.x1),
+  y1: Math.min(height, r.y1)
+});
+var holds = (r, x, y) => x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1;
+function laidIn(m, r) {
+  const c = clipped(r, m.width, m.height);
+  let laid = 0;
+  for (let y = c.y0; y < c.y1; y++) for (let x = c.x0; x < c.x1; x++) laid += m.laid[y * m.width + x] ?? 0;
+  return { laid, area: Math.max(0, c.x1 - c.x0) * Math.max(0, c.y1 - c.y0) };
+}
+function share(m, r) {
+  const { laid, area: area2 } = laidIn(m, r);
+  return area2 > 0 ? laid / area2 : 0;
+}
+function laidAround(m, box) {
+  const reach = {
+    x0: box.x0 - GROUND_REACH,
+    y0: box.y0 - GROUND_REACH,
+    x1: box.x1 + GROUND_REACH,
+    y1: box.y1 + GROUND_REACH
+  };
+  const outer = laidIn(m, rectOf(reach, m.width, m.height));
+  const inner = laidIn(m, rectOf(box, m.width, m.height));
+  const ring = outer.area - inner.area;
+  return ring > 0 ? (outer.laid - inner.laid) / ring : 0;
+}
+function past(r, side, depth) {
+  if (side === 0) return { ...r, y0: r.y0 - depth, y1: r.y0 };
+  if (side === 1) return { ...r, y0: r.y1, y1: r.y1 + depth };
+  if (side === 2) return { ...r, x0: r.x0 - depth, x1: r.x0 };
+  return { ...r, x0: r.x1, x1: r.x1 + depth };
+}
+function grown(r, side) {
+  if (side === 0) return { ...r, y0: r.y0 - 1 };
+  if (side === 1) return { ...r, y1: r.y1 + 1 };
+  if (side === 2) return { ...r, x0: r.x0 - 1 };
+  return { ...r, x1: r.x1 + 1 };
+}
+var atFrameEdge = (m, r, side) => side === 0 ? r.y0 <= 0 : side === 1 ? r.y1 >= m.height : side === 2 ? r.x0 <= 0 : r.x1 >= m.width;
+function bandUnder(m, box) {
+  const block = clipped(rectOf(box, m.width, m.height), m.width, m.height);
+  const inset = Math.min(Math.floor((block.y1 - block.y0) / 4), Math.floor((block.x1 - block.x0 - 1) / 2));
+  const start = { x0: block.x0 + inset, y0: block.y0 + inset, x1: block.x1 - inset, y1: block.y1 - inset };
+  let r = start;
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (let side = 0; side < 4; side++) {
+      if (atFrameEdge(m, r, side) || share(m, past(r, side, 1)) < BAND_EDGE) continue;
+      r = grown(r, side);
+      grew = true;
+    }
+  }
+  const outgrown = [r.y0 < start.y0, r.y1 > start.y1, r.x0 < start.x0, r.x1 > start.x1];
+  const depth = Math.max(2, Math.round(RING * Math.max(m.width, m.height)));
+  for (let side = 0; side < 4; side++) {
+    if (!(outgrown[side] || atFrameEdge(m, r, side)) || share(m, past(r, side, depth)) >= BAND_CLEAR) return null;
+  }
+  if (share(m, r) < SOLID) return null;
+  return { x0: r.x0 / m.width, y0: r.y0 / m.height, x1: r.x1 / m.width, y1: r.y1 / m.height };
+}
+function sumsOf(g, strip, skip, ch) {
+  const { width } = g.cut;
+  const sums = { n: 0, x: 0, y: 0, xx: 0, xy: 0 };
+  for (let y = strip.y0; y < strip.y1; y++) {
+    for (let x = strip.x0; x < strip.x1; x++) {
+      if (skip.some((r) => holds(r, x, y))) continue;
+      const i = y * width + x;
+      const u = g.cut.data[i * g.cut.channels + ch] ?? 0;
+      const v = g.aligned.data[i * g.aligned.channels + ch] ?? 0;
+      sums.n++;
+      sums.x += u;
+      sums.y += v;
+      sums.xx += u * u;
+      sums.xy += u * v;
+    }
+  }
+  return sums;
+}
+function toneOf(g, strip, skip) {
+  const c = clipped(strip, g.cut.width, g.cut.height);
+  return [0, 1, 2].map((ch) => {
+    const s = sumsOf(g, c, skip, ch);
+    if (s.n === 0) return { a: 0, b: 0 };
+    const spread = s.xx - s.x * s.x / s.n;
+    const a = spread > s.n ? Math.min(1, Math.max(0, (s.xy - s.x * s.y / s.n) / spread)) : 0;
+    return { a, b: (s.y - a * s.x) / s.n };
+  });
+}
+var LIGHT_DEPTH = 0.02;
+function ringPast(r, dx, dy, depth) {
+  if (dy < 0) return { ...r, y0: r.y1, y1: r.y1 + depth };
+  if (dy > 0) return { ...r, y0: r.y0 - depth, y1: r.y0 };
+  if (dx < 0) return { ...r, x0: r.x1, x1: r.x1 + depth };
+  return { ...r, x0: r.x0 - depth, x1: r.x0 };
+}
+function lightOn(g, ring) {
+  const { width, height } = g.cut;
+  const c = clipped(ring, width, height);
+  return [0, 1, 2].map((ch) => {
+    const ratios = [];
+    for (let y = c.y0; y < c.y1; y++) {
+      for (let x = c.x0; x < c.x1; x++) {
+        const i = y * width + x;
+        const under = g.cut.data[i * g.cut.channels + ch] ?? 0;
+        if (under >= 16) ratios.push((g.aligned.data[i * g.aligned.channels + ch] ?? 0) / under);
+      }
+    }
+    ratios.sort((a, b) => a - b);
+    return Math.min(2, Math.max(0.5, ratios[Math.floor(ratios.length / 2)] ?? 1));
+  });
+}
+function edgeLeft(r, dx, dy, width, height) {
+  const deep = Math.max(1, Math.round(LOOK_STRIP * (r.y1 - r.y0)));
+  const wide = Math.max(1, Math.round(LOOK_STRIP * (r.x1 - r.x0)));
+  const across2 = r.x0 <= 2 && r.x1 >= width - 2;
+  const down = r.y0 <= 2 && r.y1 >= height - 2;
+  if (dy < 0 && across2 && r.y1 >= height - 2)
+    return { strip: { ...r, y0: r.y1 - deep }, zone: { ...r, y0: r.y1 + dy } };
+  if (dy > 0 && across2 && r.y0 <= 2) return { strip: { ...r, y1: r.y0 + deep }, zone: { ...r, y1: r.y0 + dy } };
+  if (dx < 0 && down && r.x1 >= width - 2) return { strip: { ...r, x0: r.x1 - wide }, zone: { ...r, x0: r.x1 + dx } };
+  if (dx > 0 && down && r.x0 <= 2) return { strip: { ...r, x1: r.x0 + wide }, zone: { ...r, x1: r.x0 + dx } };
+  return null;
+}
+var CORNER = 0.5;
+function floodCorner(shape, w, c, reach, bare) {
+  const near = (x, y) => (x - c.x) * c.sx >= 0 && (x - c.x) * c.sx < reach && (y - c.y) * c.sy >= 0 && (y - c.y) * c.sy < reach;
+  shape[c.y * w + c.x] = 0;
+  const stack = [c.y * w + c.x];
+  for (let at = stack.pop(); at !== void 0; at = stack.pop()) {
+    const x = at % w;
+    const y = (at - x) / w;
+    for (const [nx, ny] of [
+      [x + 1, y],
+      [x - 1, y],
+      [x, y + 1],
+      [x, y - 1]
+    ]) {
+      if (!near(nx, ny) || shape[ny * w + nx] === 0 || !bare(nx, ny)) continue;
+      shape[ny * w + nx] = 0;
+      stack.push(ny * w + nx);
+    }
+  }
+}
+function shapeOf(g, r) {
+  const w = r.x1 - r.x0;
+  const h = r.y1 - r.y0;
+  const shape = new Uint8Array(Math.max(0, w * h)).fill(1);
+  if (w <= 0 || h <= 0) return shape;
+  const reach = Math.floor(CORNER * Math.min(w, h));
+  const bare = (x, y) => {
+    const i = (r.y0 + y) * g.cut.width + r.x0 + x;
+    return Math.abs(greyAt(g.aligned, i) - greyAt(g.cut, i)) <= LAID;
+  };
+  const corners = [
+    { x: 0, y: 0, sx: 1, sy: 1, open: r.x0 > 0 && r.y0 > 0 },
+    { x: w - 1, y: 0, sx: -1, sy: 1, open: r.x1 < g.cut.width && r.y0 > 0 },
+    { x: 0, y: h - 1, sx: 1, sy: -1, open: r.x0 > 0 && r.y1 < g.cut.height },
+    { x: w - 1, y: h - 1, sx: -1, sy: -1, open: r.x1 < g.cut.width && r.y1 < g.cut.height }
+  ];
+  for (const c of corners) if (c.open && bare(c.x, c.y)) floodCorner(shape, w, c, reach, bare);
+  return shape;
+}
+function eachOf(r, shape, at) {
+  const w = r.x1 - r.x0;
+  for (let k = 0; k < shape.length; k++) if (shape[k]) at(r.x0 + k % w, r.y0 + Math.floor(k / w));
+}
+var SOFT_EDGE = 3e-3;
+function eachIn(r, at) {
+  for (let y = r.y0; y < r.y1; y++) for (let x = r.x0; x < r.x1; x++) at(x, y);
+}
+function moveBand(g, move) {
+  const { width, height } = g.cut;
+  const r = clipped(rectOf(move.band, width, height), width, height);
+  const soft = Math.max(1, Math.round(SOFT_EDGE * Math.max(width, height)));
+  const left = clipped({ x0: r.x0 - soft, y0: r.y0 - soft, x1: r.x1 + soft, y1: r.y1 + soft }, width, height);
+  const dx = Math.round(move.dx * width);
+  const dy = Math.round(move.dy * height);
+  const data = Buffer.alloc(width * height * 3);
+  if (g.out.channels === 3) g.out.data.copy(data, 0, 0, width * height * 3);
+  else
+    for (let i = 0; i < width * height; i++) g.out.data.copy(data, i * 3, i * g.out.channels, i * g.out.channels + 3);
+  const shape = shapeOf(g, r);
+  const edge = edgeLeft(r, dx, dy, width, height);
+  const tone = edge ? toneOf(
+    g,
+    edge.strip,
+    move.words.map((w) => rectOf(w, width, height))
+  ) : [];
+  const light = lightOn(g, ringPast(left, dx, dy, Math.max(4, Math.round(LIGHT_DEPTH * height))));
+  eachIn(left, (x, y) => {
+    const i = y * width + x;
+    const band = edge !== null && holds(edge.zone, x, y);
+    for (let ch = 0; ch < 3; ch++) {
+      const under = g.cut.data[i * g.cut.channels + ch] ?? 0;
+      const t = tone[ch] ?? { a: 0, b: 0 };
+      const v = band ? t.a * under + t.b : under * (light[ch] ?? 1);
+      data[i * 3 + ch] = Math.max(0, Math.min(255, Math.round(v)));
+    }
+  });
+  eachOf(r, shape, (x, y) => {
+    const to = { x: x + dx, y: y + dy };
+    if (to.x < 0 || to.y < 0 || to.x >= width || to.y >= height) return;
+    const from = y * width + x;
+    g.aligned.data.copy(data, (to.y * width + to.x) * 3, from * g.aligned.channels, from * g.aligned.channels + 3);
+  });
+  return { data, width, height, channels: 3 };
+}
+
+// src/engine/nodes/local/lib/safe-fit.ts
+import sharp from "sharp";
+var FIT_HEADROOM = 0.01;
+var MIN_FIT_SCALE = 0.85;
+var MIN_FLAT_FIT_SCALE = 0.65;
+function boxesToPlace(boxes, format, opts = {}) {
+  if (!opts.copy) return [...boxes];
+  const placements = blockingPlacements(opts.placements);
+  const past2 = (box) => bandViolations([box], format, { placements })[0];
+  const cut = (box) => (past2(box)?.clearance ?? 1) <= FRAME_CUT;
+  const logoWords = opts.copy.filter((l) => roleKey(l.role) === "logo").map((l) => l.text);
+  const read = withWordmark(boxes, logoWords);
+  const buttons = new Set(opts.copy.filter(isButtonLine).flatMap((line) => boxesOfLine(line, read)));
+  return shownBoxes(read, opts.copy, (box) => !past2(box)).filter((shown) => !shown.supporting || cut(shown.box)).map((shown) => buttons.has(shown.box) ? buttonShape(shown.box) : shown.box);
+}
+function targetArea(format, placements) {
+  const area2 = blockingArea(format, placements);
+  const covered = area2.covered;
+  if (!covered) return area2;
+  return { ...area2, top: covered.top, bottom: covered.bottom, ...covered.rail ? { rail: covered.rail } : {} };
+}
+function planSafeFit(boxes, format, opts = {}) {
+  const area2 = targetArea(format, opts.placements);
+  const violations = bandViolations(boxes, format, { placements: blockingPlacements(opts.placements) });
+  if (!violations.some((v) => v.covered || v.clearance <= FRAME_CUT)) return null;
+  const rail = area2.rail && boxes.some((b) => b.y1 > (area2.rail?.from ?? 1)) ? area2.rail.width : 0;
+  const union = {
+    x0: Math.min(...boxes.map((b) => b.x0)),
+    y0: Math.min(...boxes.map((b) => b.y0)),
+    x1: Math.max(...boxes.map((b) => b.x1)),
+    y1: Math.max(...boxes.map((b) => b.y1))
+  };
+  const band = {
+    x0: area2.left + FIT_HEADROOM,
+    y0: area2.top + FIT_HEADROOM,
+    x1: 1 - Math.max(area2.right, rail) - FIT_HEADROOM,
+    y1: 1 - area2.bottom - FIT_HEADROOM
+  };
+  const scale = Math.min(1, (band.y1 - band.y0) / (union.y1 - union.y0), (band.x1 - band.x0) / (union.x1 - union.x0));
+  if (opts.contain) return containedFit(union, band, opts.minScale ?? MIN_FIT_SCALE, scale);
+  if (scale < (opts.minScale ?? MIN_FIT_SCALE)) return null;
+  return {
+    scale,
+    x: offset(scale, union.x0, union.x1, band.x0, band.x1),
+    y: offset(scale, union.y0, union.y1, band.y0, band.y1)
+  };
+}
+var CONTAIN_STEP = 5e-3;
+function containedFit(union, band, minScale, from) {
+  const start = (scale, lo0, hi0, b0, b1) => {
+    const lo = Math.max(0, b0 - scale * lo0);
+    const hi = Math.min(1 - scale, b1 - scale * hi0);
+    if (lo > hi + 1e-9) return null;
+    return Math.min(hi, Math.max(lo, 0));
+  };
+  for (let scale = Math.min(1, from); scale >= minScale - 1e-9; scale -= CONTAIN_STEP) {
+    const x = start(scale, union.x0, union.x1, band.x0, band.x1);
+    const y = start(scale, union.y0, union.y1, band.y0, band.y1);
+    if (x !== null && y !== null) {
+      const cx = Math.min(
+        Math.min(1 - scale, band.x1 - scale * union.x1),
+        Math.max(Math.max(0, band.x0 - scale * union.x0), (1 - scale) / 2)
+      );
+      return { scale, x: cx, y };
+    }
+  }
+  return null;
+}
+function offset(scale, from, to, bandFrom, bandTo) {
+  const lo = bandFrom - scale * from;
+  const hi = bandTo - scale * to;
+  if (lo > hi) return (lo + hi) / 2;
+  return Math.min(hi, Math.max(lo, (1 - scale) / 2));
+}
+var PLAIN_DEPTH = 0.03;
+var PLAIN_DEPTH_STEP = 36;
+var PLAIN_JUMP = 60;
+var PLAIN_JUMPS = 2;
+function edgeBorders(img, side) {
+  const along = side === "top" || side === "bottom" ? img.width : img.height;
+  const across2 = side === "top" || side === "bottom" ? img.height : img.width;
+  const depth = Math.max(1, Math.round(PLAIN_DEPTH * across2));
+  const at = (i, d) => {
+    const inward = side === "top" || side === "left" ? d : across2 - 1 - d;
+    const [x, y] = side === "top" || side === "bottom" ? [i, inward] : [inward, i];
+    return (y * img.width + x) * img.channels;
+  };
+  const step = (a, b) => {
+    let sum = 0;
+    for (let c = 0; c < Math.min(3, img.channels); c++)
+      sum += Math.abs((img.data[a + c] ?? 0) - (img.data[b + c] ?? 0));
+    return sum;
+  };
+  let jumps = 0;
+  for (let i = 0; i < along; i++) {
+    for (let d = 1; d <= depth; d++) if (step(at(i, 0), at(i, d)) > PLAIN_DEPTH_STEP) return null;
+    if (i > 0 && step(at(i - 1, 0), at(i, 0)) > PLAIN_JUMP) jumps++;
+  }
+  return jumps;
+}
+function plainEdge(img, side) {
+  const borders = edgeBorders(img, side);
+  return borders !== null && borders <= PLAIN_JUMPS;
+}
+async function minFitScale(image) {
+  const { data, info } = await sharp(image).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const raw = { data, width: info.width, height: info.height, channels: info.channels };
+  const flat = ["top", "bottom", "left", "right"].every((side) => edgeBorders(raw, side) === 0);
+  return flat ? MIN_FLAT_FIT_SCALE : MIN_FIT_SCALE;
+}
+async function fitPicture(image, fit) {
+  const { width = 0, height = 0 } = await sharp(image).metadata();
+  const sw = Math.max(1, Math.round(width * fit.scale));
+  const sh = Math.max(1, Math.round(height * fit.scale));
+  const px = Math.round(fit.x * width);
+  const py = Math.round(fit.y * height);
+  const left = Math.max(0, -px);
+  const top = Math.max(0, -py);
+  const w = Math.min(sw, width - px) - left;
+  const h = Math.min(sh, height - py) - top;
+  const shrunk2 = await sharp(image).removeAlpha().resize(sw, sh, { fit: "fill", kernel: "lanczos3" }).extract({ left, top, width: w, height: h }).raw().toBuffer({ resolveWithObject: true });
+  const pad = { left: Math.max(0, px), top: Math.max(0, py) };
+  const extend = { ...pad, right: width - pad.left - w, bottom: height - pad.top - h };
+  const raw = { data: shrunk2.data, width: w, height: h, channels: shrunk2.info.channels };
+  const sides = ["top", "bottom", "left", "right"].filter((side) => extend[side] > 0);
+  if (!sides.every((side) => plainEdge(raw, side))) return null;
+  return sharp(shrunk2.data, { raw: { width: w, height: h, channels: shrunk2.info.channels } }).extend({ ...extend, extendWith: "copy" }).png().toBuffer();
+}
+
+// src/engine/nodes/local/lib/words-layer.ts
+var inSpans = (spans, fx, fy) => spans.some((s) => fx >= s.x0 && fx <= s.x1 && fy >= s.y0 && fy <= s.y1);
+function centresIn(lo, hi, size) {
+  const inside = new Uint8Array(size);
+  for (let t = 0; t < size; t++) {
+    const f = (t + 0.5) / size;
+    inside[t] = f >= lo && f <= hi ? 1 : 0;
+  }
+  return inside;
+}
+function spanMask(spans, width, height) {
+  const mask = new Uint8Array(width * height);
+  for (const s of spans) {
+    const across2 = centresIn(s.x0, s.x1, width);
+    const down = centresIn(s.y0, s.y1, height);
+    for (let y = 0; y < height; y++) {
+      if (down[y]) for (let x = 0; x < width; x++) mask[y * width + x] ||= across2[x] ?? 0;
+    }
+  }
+  return mask;
+}
+function taps(u, v, width, height) {
+  const x = Math.min(width - 1, Math.max(0, u));
+  const y = Math.min(height - 1, Math.max(0, v));
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const x1 = Math.min(width - 1, x0 + 1);
+  const y1 = Math.min(height - 1, y0 + 1);
+  const fx = x - x0;
+  const fy = y - y0;
+  return {
+    at: [y0 * width + x0, y0 * width + x1, y1 * width + x0, y1 * width + x1],
+    w: [(1 - fx) * (1 - fy), fx * (1 - fy), (1 - fx) * fy, fx * fy]
+  };
+}
+function tapped(values, t, stride = 1, c = 0, missing = 0) {
+  let sum = 0;
+  for (let k = 0; k < 4; k++) sum += (t.w[k] ?? 0) * (values[(t.at[k] ?? 0) * stride + c] ?? missing);
+  return sum;
+}
+function grayOf(img) {
+  const data = new Float32Array(img.width * img.height);
+  for (let i = 0; i < data.length; i++) {
+    const o = i * img.channels;
+    data[i] = 0.299 * (img.data[o] ?? 0) + 0.587 * (img.data[o + 1] ?? 0) + 0.114 * (img.data[o + 2] ?? 0);
+  }
+  return { data, width: img.width, height: img.height };
+}
+function shrink(g, edge) {
+  const f = Math.max(1, Math.ceil(Math.max(g.width, g.height) / edge));
+  if (f === 1) return g;
+  const width = Math.floor(g.width / f);
+  const height = Math.floor(g.height / f);
+  const data = new Float32Array(width * height);
+  for (let i = 0; i < width * height; i++) {
+    const x = i % width * f;
+    const y = Math.floor(i / width) * f;
+    let sum = 0;
+    for (let j = 0; j < f; j++) {
+      const row = (y + j) * g.width + x;
+      for (let k = 0; k < f; k++) sum += g.data[row + k] ?? 0;
+    }
+    data[i] = sum / (f * f);
+  }
+  return { data, width, height };
+}
+var JUDGED_MAX = 2e4;
+function judgedPixels(g, exclude) {
+  const mx = Math.ceil(g.width * 0.04);
+  const my = Math.ceil(g.height * 0.04);
+  const step = g.width * g.height > JUDGED_MAX ? 2 : 1;
+  const out = [];
+  for (let i = 0; i < g.width * g.height; i++) {
+    const x = i % g.width;
+    const y = Math.floor(i / g.width);
+    if (x % step !== 0 || y % step !== 0) continue;
+    if (x < mx || y < my || x >= g.width - mx || y >= g.height - my) continue;
+    if (!inSpans(exclude, x / g.width, y / g.height)) out.push(i);
+  }
+  const rows = [];
+  const starts = [];
+  out.forEach((i, j) => {
+    const y = Math.floor(i / g.width);
+    if (rows[rows.length - 1] === y) return;
+    rows.push(y);
+    starts.push(j);
+  });
+  starts.push(out.length);
+  return {
+    at: Int32Array.from(out),
+    xs: Int32Array.from(out, (i) => i % g.width),
+    rows: Int32Array.from(rows),
+    starts: Int32Array.from(starts)
+  };
+}
+function axisOf(origin, scale, count, size) {
+  const near = new Int32Array(count);
+  const at = new Int32Array(count);
+  const frac = new Float64Array(count);
+  for (let t = 0; t < count; t++) {
+    const p = origin + scale * t;
+    near[t] = Math.min(size - 1, Math.max(0, Math.round(p)));
+    const q = Math.min(size - 1.001, Math.max(0, p));
+    at[t] = q | 0;
+    frac[t] = q - (at[t] ?? 0);
+  }
+  return { near, at, frac };
+}
+var MISFIT_CAP = 40;
+var LINEUP_FLAT = 1.5;
+function withFlat(g) {
+  const flat = new Uint8Array(g.width * g.height);
+  for (let i = 0; i < flat.length; i++) {
+    const x = i % g.width;
+    const y = (i - x) / g.width;
+    if (x === 0 || y === 0 || x === g.width - 1 || y === g.height - 1) continue;
+    let sum = 0;
+    let square = 0;
+    for (let k = 0; k < 9; k++) {
+      const v = g.data[(y + Math.floor(k / 3) - 1) * g.width + x + k % 3 - 1] ?? 0;
+      sum += v;
+      square += v * v;
+    }
+    flat[i] = Math.sqrt(Math.max(0, square / 9 - (sum / 9) ** 2)) < LINEUP_FLAT ? 1 : 0;
+  }
+  return { ...g, flat };
+}
+function misfit(cut, render, judged, k, c, cap = MISFIT_CAP, beat = Number.POSITIVE_INFINITY, above = Number.POSITIVE_INFINITY) {
+  const cx = cut.width / 2;
+  const cy = cut.height / 2;
+  const ox = cx - c.scale * cx + c.dx * k;
+  const oy = cy - c.scale * cy + c.dy * k;
+  const cols = axisOf(ox, c.scale, cut.width, render.width);
+  const rows = axisOf(oy, c.scale, cut.height, render.height);
+  const look = { cut, render, judged, cols, most: cap * cap };
+  const count = judged.at.length;
+  const acc = { sum: 0, n: 0 };
+  for (let r = 0; r < judged.rows.length; r++) {
+    const from = judged.starts[r] ?? 0;
+    const least = acc.sum / (acc.n + count - from);
+    if (least >= beat || least > above) return Number.POSITIVE_INFINITY;
+    rowMisfit(look, rows, judged.rows[r] ?? 0, from, judged.starts[r + 1] ?? count, acc);
+  }
+  return acc.n > 0 ? acc.sum / acc.n : Number.POSITIVE_INFINITY;
+}
+function bilinear(data, i, width, fx, fy) {
+  const top = (data[i] ?? 0) * (1 - fx) + (data[i + 1] ?? 0) * fx;
+  const bottom = (data[i + width] ?? 0) * (1 - fx) + (data[i + width + 1] ?? 0) * fx;
+  return top * (1 - fy) + bottom * fy;
+}
+function rowMisfit(s, rows, y, from, to, acc) {
+  const { width, data, flat } = s.render;
+  const { near, at, frac } = s.cols;
+  const flatRow = (rows.near[y] ?? 0) * width;
+  const row = (rows.at[y] ?? 0) * width;
+  const fy = rows.frac[y] ?? 0;
+  for (let j = from; j < to; j++) {
+    const x = s.judged.xs[j] ?? 0;
+    if (flat?.[flatRow + (near[x] ?? 0)]) continue;
+    const d = (s.cut.data[s.judged.at[j] ?? 0] ?? 0) - bilinear(data, row + (at[x] ?? 0), width, frac[x] ?? 0, fy);
+    acc.sum += Math.min(d * d, s.most);
+    acc.n++;
+  }
+}
+var MAX_SHIFT = 0.03;
+var MAX_SCALE_OFF = 0.03;
+var LEVELS = [
+  { edge: 128, scales: [-0.03, -0.02, -0.01, 0, 0.01, 0.02, 0.03], reach: null },
+  { edge: 256, scales: [-5e-3, 0, 5e-3], reach: 2 },
+  { edge: 512, scales: [-25e-4, 0, 25e-4], reach: 1 }
+];
+function searchLevel(cut, render, k, level, centre, exclude) {
+  const judged = judgedPixels(cut, exclude);
+  const reach = level.reach ?? Math.ceil(MAX_SHIFT * Math.max(cut.width, cut.height));
+  let best = centre;
+  let score = Number.POSITIVE_INFINITY;
+  const atCentre = misfit(cut, render, judged, k, centre);
+  const side = 2 * reach + 1;
+  for (const ds of level.scales) {
+    const scale = centre.scale + ds;
+    if (Math.abs(scale - 1) > MAX_SCALE_OFF + 1e-9) continue;
+    for (let s = 0; s < side * side; s++) {
+      const c = { scale, dx: centre.dx + (s % side - reach) / k, dy: centre.dy + (Math.floor(s / side) - reach) / k };
+      const m = misfit(cut, render, judged, k, c, MISFIT_CAP, score, atCentre);
+      if (m < score) {
+        score = m;
+        best = c;
+      }
+    }
+  }
+  return { best, score };
+}
+function registerToSource(render, cut, exclude) {
+  return lineUps(render, `${pictureId(cut)} ${JSON.stringify(exclude)}`, () => lineUp(render, cut, exclude));
+}
+var lineUps = remembered();
+var warps = remembered();
+function lineUp(render, cut, exclude) {
+  const full = { cut: grayOf(cut), render: grayOf(render) };
+  let best = { scale: 1, dx: 0, dy: 0 };
+  let finest = { cut: full.cut, render: full.render, k: 1 };
+  for (const level of LEVELS) {
+    const c = shrink(full.cut, level.edge);
+    const r = withFlat(shrink(full.render, level.edge));
+    const k = c.width / cut.width;
+    best = searchLevel(c, r, k, level, best, exclude).best;
+    finest = { cut: c, render: r, k };
+  }
+  const judged = judgedPixels(finest.cut, exclude);
+  const residual = misfit(finest.cut, finest.render, judged, finest.k, best, Number.POSITIVE_INFINITY);
+  return { ...best, residual: Math.sqrt(residual) };
+}
+function bilinearAxis(centre, scale, shift, size) {
+  const lo = new Int32Array(size);
+  const hi = new Int32Array(size);
+  const frac = new Float64Array(size);
+  for (let t = 0; t < size; t++) {
+    const p = Math.min(size - 1, Math.max(0, centre + scale * (t - centre) + shift));
+    lo[t] = Math.floor(p);
+    hi[t] = Math.min(size - 1, (lo[t] ?? 0) + 1);
+    frac[t] = p - (lo[t] ?? 0);
+  }
+  return { lo, hi, frac };
+}
+function warpToCut(render, fit) {
+  return warps(render, `${fit.scale} ${fit.dx} ${fit.dy}`, () => warped(render, fit));
+}
+function warped(render, fit) {
+  const { width, height } = render;
+  const out = Buffer.alloc(width * height * 3);
+  const cols = bilinearAxis(width / 2, fit.scale, fit.dx, width);
+  const rows = bilinearAxis(height / 2, fit.scale, fit.dy, height);
+  for (let y = 0; y < height; y++) {
+    const row = { y, top: (rows.lo[y] ?? 0) * width, bottom: (rows.hi[y] ?? 0) * width, fy: rows.frac[y] ?? 0 };
+    warpRow(render, out, cols, row);
+  }
+  return { data: out, width, height, channels: 3 };
+}
+function warpRow(render, out, cols, row) {
+  const { width, channels, data } = render;
+  const { fy } = row;
+  for (let x = 0; x < width; x++) {
+    const fx = cols.frac[x] ?? 0;
+    const w = [(1 - fx) * (1 - fy), fx * (1 - fy), (1 - fx) * fy, fx * fy];
+    const lo = cols.lo[x] ?? 0;
+    const hi = cols.hi[x] ?? 0;
+    const a = [
+      (row.top + lo) * channels,
+      (row.top + hi) * channels,
+      (row.bottom + lo) * channels,
+      (row.bottom + hi) * channels
+    ];
+    const o = (row.y * width + x) * 3;
+    for (let c = 0; c < 3; c++) {
+      out[o + c] = Math.round(
+        w[0] * (data[a[0] + c] ?? 0) + w[1] * (data[a[1] + c] ?? 0) + w[2] * (data[a[2] + c] ?? 0) + w[3] * (data[a[3] + c] ?? 0)
+      );
+    }
+  }
+}
+function emptyLayer(width, height) {
+  return {
+    width,
+    height,
+    alpha: new Float32Array(width * height),
+    ink: new Float32Array(width * height),
+    pixels: Buffer.alloc(width * height * 3),
+    gain: new Float32Array(width * height * 3).fill(1)
+  };
+}
+var CELL = 8;
+var CHANGED = 14;
+var MATTE_LO = 8;
+var MATTE_HI = 32;
+var BOX_PAD = 0.3;
+var TOUCH = 0.02;
+var GAIN_MAX = 4;
+var TONE_MIN_PIXELS = CELL * CELL / 4;
+var padded = (b, width, height) => {
+  const pad = BOX_PAD * (b.y1 - b.y0);
+  const padX = pad * height / width;
+  return { x0: b.x0 - padX, y0: b.y0 - pad, x1: b.x1 + padX, y1: b.y1 + pad };
+};
+function gridOf(width, height) {
+  const gw = Math.ceil(width / CELL);
+  const gh = Math.ceil(height / CELL);
+  return {
+    gw,
+    gh,
+    cell: (x, y) => Math.floor(y / CELL) * gw + Math.floor(x / CELL),
+    span: (g) => {
+      const gx = g % gw;
+      const gy = Math.floor(g / gw);
+      return {
+        x0: gx * CELL / width,
+        y0: gy * CELL / height,
+        x1: (gx + 1) * CELL / width,
+        y1: (gy + 1) * CELL / height
+      };
+    }
+  };
+}
+function neighbours2(g, grid) {
+  const gx = g % grid.gw;
+  const gy = Math.floor(g / grid.gw);
+  const out = [];
+  for (let k = 0; k < 9; k++) {
+    const nx = gx + k % 3 - 1;
+    const ny = gy + Math.floor(k / 3) - 1;
+    if (k !== 4 && nx >= 0 && ny >= 0 && nx < grid.gw && ny < grid.gh) out.push(ny * grid.gw + nx);
+  }
+  return out;
+}
+function addPixel(s, aligned, cut, i, g, tone) {
+  let d = 0;
+  for (let c = 0; c < 3; c++) {
+    const a = aligned.data[i * aligned.channels + c] ?? 0;
+    const b = cut.data[i * cut.channels + c] ?? 0;
+    d = Math.max(d, Math.abs(a - b));
+    if (!tone) continue;
+    s.meanA[g * 3 + c] = (s.meanA[g * 3 + c] ?? 0) + a;
+    s.meanC[g * 3 + c] = (s.meanC[g * 3 + c] ?? 0) + b;
+  }
+  return d;
+}
+function cellStats(aligned, cut, words, grid) {
+  const cells = grid.gw * grid.gh;
+  const s = {
+    diff: new Float32Array(cells),
+    pixelDiff: new Float32Array(cut.width * cut.height),
+    meanA: new Float32Array(cells * 3),
+    meanC: new Float32Array(cells * 3),
+    toneCount: new Float32Array(cells)
+  };
+  const count = new Float32Array(cells);
+  for (let i = 0; i < cut.width * cut.height; i++) {
+    const x = i % cut.width;
+    const y = Math.floor(i / cut.width);
+    const g = grid.cell(x, y);
+    const tone = !words[i];
+    const d = addPixel(s, aligned, cut, i, g, tone);
+    s.pixelDiff[i] = d;
+    s.diff[g] = (s.diff[g] ?? 0) + d;
+    count[g] = (count[g] ?? 0) + 1;
+    if (tone) s.toneCount[g] = (s.toneCount[g] ?? 0) + 1;
+  }
+  for (let k = 0; k < cells * 3; k++) {
+    const g = Math.floor(k / 3);
+    if (k % 3 === 0) s.diff[g] = (s.diff[g] ?? 0) / (count[g] || 1);
+    s.meanA[k] = (s.meanA[k] ?? 0) / (s.toneCount[g] || 1);
+    s.meanC[k] = (s.meanC[k] ?? 0) / (s.toneCount[g] || 1);
+  }
+  return s;
+}
+var isChanged = (diff, g) => (diff[g] ?? 0) >= CHANGED;
+function flood(start, id, diff, region, grid) {
+  region[start] = id;
+  const stack = [start];
+  while (stack.length > 0) {
+    const g = stack.pop() ?? 0;
+    const next = neighbours2(g, grid).filter((n) => isChanged(diff, n) && (region[n] ?? -1) < 0);
+    for (const n of next) region[n] = id;
+    stack.push(...next);
+  }
+}
+function changedRegions(diff, grid) {
+  const region = new Int32Array(diff.length).fill(-1);
+  let count = 0;
+  for (let start = 0; start < diff.length; start++) {
+    if (!isChanged(diff, start) || (region[start] ?? -1) >= 0) continue;
+    flood(start, count, diff, region, grid);
+    count++;
+  }
+  return { region, count };
+}
+function cellGain(s, g) {
+  if ((s.toneCount[g] ?? 0) < TONE_MIN_PIXELS) return null;
+  return [0, 1, 2].map((c) => {
+    const ratio = ((s.meanA[g * 3 + c] ?? 0) + 8) / ((s.meanC[g * 3 + c] ?? 0) + 8);
+    return Math.min(GAIN_MAX, Math.max(1 / GAIN_MAX, ratio));
+  });
+}
+function neighbourGain(gain, known, g, grid) {
+  const around = neighbours2(g, grid).filter((n) => known[n]);
+  if (around.length === 0) return null;
+  return [0, 1, 2].map((c) => around.reduce((sum, n) => sum + (gain[n * 3 + c] ?? 1), 0) / around.length);
+}
+function spreadGains(gain, known, grid) {
+  const filled = [];
+  for (let g = 0; g < known.length; g++) {
+    const from = known[g] ? null : neighbourGain(gain, known, g, grid);
+    if (from) filled.push([g, from]);
+  }
+  for (const [g, value] of filled) {
+    gain.set(value, g * 3);
+    known[g] = 1;
+  }
+  return filled.length;
+}
+function toneGains(s, grid) {
+  const cells = grid.gw * grid.gh;
+  const gain = new Float32Array(cells * 3).fill(1);
+  const known = new Uint8Array(cells);
+  for (let g = 0; g < cells; g++) {
+    const own = cellGain(s, g);
+    if (!own) continue;
+    gain.set(own, g * 3);
+    known[g] = 1;
+  }
+  let spread = 1;
+  while (spread > 0) spread = spreadGains(gain, known, grid);
+  return gain;
+}
+function smoothGains(gains, grid) {
+  const out = new Float32Array(gains.length);
+  for (let g = 0; g < grid.gw * grid.gh; g++) {
+    const around = [g, ...neighbours2(g, grid)];
+    for (let c = 0; c < 3; c++) {
+      out[g * 3 + c] = around.reduce((sum, n) => sum + (gains[n * 3 + c] ?? 1), 0) / around.length;
+    }
+  }
+  return out;
+}
+var STRUCTURAL = 16;
+function toneMisfit(aligned, cut, gains, words, grid) {
+  const sum = new Float32Array(grid.gw * grid.gh);
+  const count = new Float32Array(grid.gw * grid.gh);
+  for (let i = 0; i < cut.width * cut.height; i++) {
+    const x = i % cut.width;
+    const y = (i - x) / cut.width;
+    if (words[i]) continue;
+    const g = grid.cell(x, y);
+    let d = 0;
+    for (let c = 0; c < 3; c++) {
+      const want = Math.min(255, (cut.data[i * cut.channels + c] ?? 0) * (gains[g * 3 + c] ?? 1));
+      d = Math.max(d, Math.abs((aligned.data[i * aligned.channels + c] ?? 0) - want));
+    }
+    sum[g] = (sum[g] ?? 0) + d;
+    count[g] = (count[g] ?? 0) + 1;
+  }
+  return sum.map((v, g) => count[g] ? v / (count[g] ?? 1) : 0);
+}
+function cellTaps(grid, x, y) {
+  return taps((x + 0.5) / CELL - 0.5, (y + 0.5) / CELL - 0.5, grid.gw, grid.gh);
+}
+function wordsLayer(aligned, cut, designed, opts = {}) {
+  const { width, height } = cut;
+  const grid = gridOf(width, height);
+  const boxes = designed.map((b) => padded(b, width, height));
+  const tight = designed.map((b) => ({ ...b }));
+  const inBoxes2 = spanMask(boxes, width, height);
+  const stats = cellStats(aligned, cut, inBoxes2, grid);
+  const kept = keptChange(stats.diff, boxes, grid, TOUCH * width / height);
+  const gains = smoothGains(toneGains(stats, grid), grid);
+  const misfit2 = opts.boxesOnly ? null : toneMisfit(aligned, cut, gains, inBoxes2, grid);
+  const tone = kept.tone.map((t, g) => t > 0 && misfit2 && (misfit2[g] ?? 0) < STRUCTURAL ? 1 : 0);
+  const dropped = kept.tone.reduce((n, t, g) => n + (t > 0 && !tone[g] ? 1 : 0), 0);
+  const reverted = kept.reverted + dropped / kept.tone.length;
+  const look = {
+    aligned,
+    stats,
+    grid,
+    boxes: inBoxes2,
+    tone,
+    gains,
+    tight: spanMask(tight, width, height),
+    subjects: spanMask(opts.subjects ?? [], width, height),
+    keepOut: spanMask(opts.keepOut ?? [], width, height)
+  };
+  const layer = emptyLayer(width, height);
+  for (let i = 0; i < width * height; i++) setLayerPixel(layer, look, i);
+  return { layer, reverted };
+}
+var overlaps = (a, b) => a.x0 < b.x1 && a.x1 > b.x0 && a.y0 < b.y1 && a.y1 > b.y0;
+function keptChange(diff, boxes, grid, touchY) {
+  const { region, count } = changedRegions(diff, grid);
+  const near = boxes.map((b) => ({ x0: b.x0 - TOUCH, y0: b.y0 - touchY, x1: b.x1 + TOUCH, y1: b.y1 + touchY }));
+  const kept = new Uint8Array(count);
+  for (let g = 0; g < region.length; g++) {
+    const id = region[g] ?? -1;
+    if (id >= 0 && near.some((b) => overlaps(grid.span(g), b))) kept[id] = 1;
+  }
+  const tone = new Float32Array(region.length);
+  let reverted = 0;
+  for (let g = 0; g < region.length; g++) {
+    const id = region[g] ?? -1;
+    if (id < 0) continue;
+    if (kept[id]) tone[g] = 1;
+    else if (!boxes.some((b) => overlaps(grid.span(g), b))) reverted++;
+  }
+  return { tone, reverted: reverted / region.length };
+}
+function setLayerPixel(layer, look, i) {
+  const x = i % layer.width;
+  const y = Math.floor(i / layer.width);
+  const onSubject = look.subjects[i] === 1;
+  const inBox = (onSubject ? look.tight : look.boxes)[i] === 1;
+  if (!inBox && look.keepOut[i]) return;
+  const near = look.tone[look.grid.cell(x, y)] ? cellTaps(look.grid, x, y) : void 0;
+  const toned = near ? tapped(look.tone, near, 1, 0, 1) : 0;
+  const changed = ((look.stats.pixelDiff[i] ?? 0) - MATTE_LO) / (MATTE_HI - MATTE_LO);
+  const matte = inBox ? Math.min(1, Math.max(0, changed)) : 0;
+  const a = Math.max(matte, toned);
+  if (a <= 0) return;
+  layer.alpha[i] = a;
+  layer.ink[i] = inBox ? 1 : 0;
+  const cells = near ?? cellTaps(look.grid, x, y);
+  for (let c = 0; c < 3; c++) {
+    layer.pixels[i * 3 + c] = look.aligned.data[i * look.aligned.channels + c] ?? 0;
+    layer.gain[i * 3 + c] = tapped(look.gains, cells, 3, c, 1);
+  }
+}
+function protectFaces(layer, faces) {
+  if (faces.length === 0) return { layer, covered: 0 };
+  const alpha = Float32Array.from(layer.alpha);
+  const ink = Float32Array.from(layer.ink);
+  let onFace = 0;
+  let covered = 0;
+  for (let i = 0; i < alpha.length; i++) {
+    const fx = (i % layer.width + 0.5) / layer.width;
+    const fy = (Math.floor(i / layer.width) + 0.5) / layer.height;
+    if (!inSpans(faces, fx, fy)) continue;
+    onFace++;
+    const k = ink[i] ?? 0;
+    if (k <= 0 || (alpha[i] ?? 0) <= 0) continue;
+    covered++;
+    alpha[i] = (alpha[i] ?? 0) * (1 - k);
+    ink[i] = 0;
+  }
+  return { layer: { ...layer, alpha, ink }, covered: onFace > 0 ? covered / onFace : 0 };
+}
+var HIDDEN = 0.5;
+function coveredSubjects(layer, subjects) {
+  return subjects.filter((b) => b.kind === "product" || b.kind === "animal").filter((b) => {
+    const x0 = Math.max(0, Math.floor(b.x0 * layer.width));
+    const x1 = Math.min(layer.width, Math.ceil(b.x1 * layer.width));
+    const y0 = Math.max(0, Math.floor(b.y0 * layer.height));
+    const y1 = Math.min(layer.height, Math.ceil(b.y1 * layer.height));
+    let covered = 0;
+    for (let y = y0; y < y1; y++) {
+      for (let x = x0; x < x1; x++) if ((layer.alpha[y * layer.width + x] ?? 0) >= 0.5) covered++;
+    }
+    const all = (x1 - x0) * (y1 - y0);
+    return all > 0 && covered / all > HIDDEN;
+  }).map((b) => b.label);
+}
+function compose(cut, layer) {
+  const { width, height } = cut;
+  const out = Buffer.alloc(width * height * 3);
+  for (let k = 0; k < width * height * 3; k++) {
+    const i = Math.floor(k / 3);
+    const c = k % 3;
+    const base = cut.data[i * cut.channels + c] ?? 0;
+    const a = layer.alpha[i] ?? 0;
+    if (a <= 0) {
+      out[k] = base;
+      continue;
+    }
+    const ink = layer.ink[i] ?? 0;
+    const toned = Math.min(255, base * (layer.gain[k] ?? 1));
+    out[k] = Math.round(base * (1 - a) + (ink * (layer.pixels[k] ?? 0) + (1 - ink) * toned) * a);
+  }
+  return { data: out, width, height, channels: 3 };
+}
+function identityOutside(out, cut, alpha) {
+  let sum = 0;
+  let n = 0;
+  for (let k = 0; k < cut.width * cut.height * 3; k++) {
+    const i = Math.floor(k / 3);
+    if ((alpha[i] ?? 0) > 0) continue;
+    sum += Math.abs((out.data[i * out.channels + k % 3] ?? 0) - (cut.data[i * cut.channels + k % 3] ?? 0));
+    n++;
+  }
+  return n > 0 ? sum / n : 0;
+}
+var MIN_WORDS_SCALE = 0.8;
+var MAX_WORDS_MOVE = 0.12;
+var MAX_BAND_MOVE = 0.25;
+var GROUP_GAP = 0.04;
+var SCALE_STEP = 0.05;
+var MOVE_STEP = 5e-3;
+var into = (from, to, lo, hi) => Math.max(lo - from, 0) + Math.min(hi - to, 0);
+var unionOf3 = (boxes) => ({
+  x0: Math.min(...boxes.map((b) => b.x0)),
+  y0: Math.min(...boxes.map((b) => b.y0)),
+  x1: Math.max(...boxes.map((b) => b.x1)),
+  y1: Math.max(...boxes.map((b) => b.y1))
+});
+var overlap = (a, b) => a.x0 < b.x1 && a.x1 > b.x0 && a.y0 < b.y1 && a.y1 > b.y0;
+function clearAreas(format, placements, bottom) {
+  const area2 = blockingArea(format, placements);
+  const rail = area2.rail && bottom > area2.rail.from ? area2.rail.width : 0;
+  const band = {
+    x0: area2.left + FIT_HEADROOM,
+    y0: area2.top + FIT_HEADROOM,
+    x1: 1 - Math.max(area2.right, rail) - FIT_HEADROOM,
+    y1: 1 - area2.bottom - FIT_HEADROOM
+  };
+  const covered = area2.covered;
+  if (!covered) return [band];
+  const drawn = covered.rail && bottom > covered.rail.from ? covered.rail.width : 0;
+  return [
+    band,
+    {
+      x0: band.x0,
+      y0: covered.top + FIT_HEADROOM,
+      x1: 1 - Math.max(area2.right, drawn) - FIT_HEADROOM,
+      y1: 1 - covered.bottom - FIT_HEADROOM
+    }
+  ];
+}
+function wordGroups(words) {
+  const sorted = [...words].sort((a, b) => a.y0 - b.y0);
+  const groups = [];
+  for (const box of sorted) {
+    const last = groups.at(-1);
+    if (last && box.y0 - Math.max(...last.map((b) => b.y1)) < GROUP_GAP) last.push(box);
+    else groups.push([box]);
+  }
+  return groups;
+}
+function placed(union, fit, area2, p, withFaces) {
+  const m = movedSpan(union, fit);
+  const inArea = m.x0 >= area2.x0 - 1e-9 && m.x1 <= area2.x1 + 1e-9 && m.y0 >= area2.y0 - 1e-9 && m.y1 <= area2.y1 + 1e-9;
+  return inArea && !p.others.some((o) => overlap(m, o)) && !(withFaces && p.faces.some((f) => overlap(m, f)));
+}
+function shiftInto(union, at, area2, p, withFaces) {
+  const half = at.scale * (union.x1 - union.x0) / 2;
+  const dx = into(at.cx - half, at.cx + half, area2.x0, area2.x1);
+  const steps = Math.round(p.reach / MOVE_STEP);
+  for (let k = 0; k <= 2 * steps; k++) {
+    const dy = (k % 2 === 0 ? 1 : -1) * Math.ceil(k / 2) * MOVE_STEP;
+    const fit = { ...at, dx, dy };
+    if (placed(union, fit, area2, p, withFaces)) return fit;
+  }
+  return null;
+}
+function blockMove(union, p, withFaces) {
+  const cx = (union.x0 + union.x1) / 2;
+  const cy = (union.y0 + union.y1) / 2;
+  for (let scale = 1; scale >= p.minScale - 1e-9; scale -= SCALE_STEP) {
+    for (const area2 of p.areas) {
+      const fit = shiftInto(union, { scale, cx, cy }, area2, p, withFaces);
+      if (fit) return fit;
+    }
+  }
+  return null;
+}
+var unmoved = (fit) => fit.scale === 1 && fit.dx === 0 && fit.dy === 0;
+var across = (area2, union) => ({
+  ...area2,
+  x0: Math.min(area2.x0, union.x0),
+  x1: Math.max(area2.x1, union.x1)
+});
+function planWordsShift(words, format, opts = {}) {
+  const faces = opts.faces ?? [];
+  const obstacles = [...faces, ...opts.keepOut ?? []];
+  const groups = wordGroups(words).map((g) => ({ boxes: g, union: unionOf3(g) }));
+  const moves = [];
+  let reason;
+  for (const [i, group] of groups.entries()) {
+    const violations = bandViolations(group.boxes, format, { placements: blockingPlacements(opts.placements) });
+    const past2 = violations.length > 0;
+    const onFace = faces.some((f) => overlap(group.union, f));
+    if (!past2 && !onFace) continue;
+    const sideways = violations.some((v) => v.edges.includes("left") || v.edges.includes("right"));
+    const p = {
+      areas: clearAreas(format, opts.placements, group.union.y1).map((a) => sideways ? a : across(a, group.union)),
+      faces: obstacles,
+      others: groups.filter((_, j) => j !== i).map((g) => g.union),
+      minScale: opts.minScale ?? MIN_WORDS_SCALE,
+      reach: past2 ? MAX_BAND_MOVE : MAX_WORDS_MOVE
+    };
+    const step = stepOf(group.union, past2, p);
+    if (typeof step === "string") reason ??= step;
+    else if (step) moves.push({ group: group.union, fit: step });
+  }
+  return reason ? { moves, reason } : { moves };
+}
+function stepOf(union, past2, p) {
+  const fit = blockMove(union, p, true);
+  if (fit) return unmoved(fit) ? null : fit;
+  return blockMove(union, p, false) || !past2 ? "words_over_face" : "band_too_far";
+}
+function movedSpan(b, fit) {
+  const at = (v, c, d) => c + fit.scale * (v - c) + d;
+  return {
+    ...b,
+    x0: at(b.x0, fit.cx, fit.dx),
+    y0: at(b.y0, fit.cy, fit.dy),
+    x1: at(b.x1, fit.cx, fit.dx),
+    y1: at(b.y1, fit.cy, fit.dy)
+  };
+}
+var GROUP_REACH = 0.03;
+function blockAt(layer, moves, i) {
+  const fx = (i % layer.width + 0.5) / layer.width;
+  const fy = (Math.floor(i / layer.width) + 0.5) / layer.height;
+  return moves.findIndex(
+    (m) => fx >= m.group.x0 - GROUP_REACH && fx <= m.group.x1 + GROUP_REACH && fy >= m.group.y0 - GROUP_REACH && fy <= m.group.y1 + GROUP_REACH
+  );
+}
+function owners(layer, moves) {
+  const { width } = layer;
+  const own = new Int16Array(width * layer.height).fill(-1);
+  for (let i = 0; i < own.length; i++) if ((layer.alpha[i] ?? 0) > 0) own[i] = blockAt(layer, moves, i);
+  spreadOwners(own, layer.alpha, width);
+  return own;
+}
+function spreadOwners(own, alpha, width) {
+  const { stack, seeds } = seedsOf(own);
+  let top = seeds;
+  const free = (n) => n >= 0 && n < own.length && (own[n] ?? -1) < 0 && (alpha[n] ?? 0) > 0;
+  while (top > 0) {
+    const i = stack[--top] ?? 0;
+    const block = own[i] ?? -1;
+    for (const n of touching(i, width)) {
+      if (!free(n)) continue;
+      own[n] = block;
+      stack[top++] = n;
+    }
+  }
+}
+function seedsOf(own) {
+  const stack = new Int32Array(own.length);
+  let seeds = 0;
+  for (let i = 0; i < own.length; i++) if ((own[i] ?? -1) >= 0) stack[seeds++] = i;
+  return { stack, seeds };
+}
+function touching(i, width) {
+  const x = i % width;
+  return [x > 0 ? i - 1 : -1, x < width - 1 ? i + 1 : -1, i - width, i + width];
+}
+function takePixel(out, to, layer, t) {
+  const a = tapped(layer.alpha, t);
+  if (a <= (out.alpha[to] ?? 0)) return;
+  out.alpha[to] = a;
+  out.ink[to] = tapped(layer.ink, t);
+  for (let c = 0; c < 3; c++) {
+    out.pixels[to * 3 + c] = Math.round(tapped(layer.pixels, t, 3, c));
+    out.gain[to * 3 + c] = tapped(layer.gain, t, 3, c, 1);
+  }
+}
+function moveBlock(out, layer, own, k, fit) {
+  const { width, height } = layer;
+  const back = (p, c, d, size) => c * size + (p + 0.5 - c * size - d * size) / fit.scale - 0.5;
+  for (let i = 0; i < width * height; i++) {
+    const u = back(i % width, fit.cx, fit.dx, width);
+    const v = back(Math.floor(i / width), fit.cy, fit.dy, height);
+    const inside = u >= 0 && v >= 0 && u <= width - 1 && v <= height - 1;
+    if (inside && own[Math.round(v) * width + Math.round(u)] === k) takePixel(out, i, layer, taps(u, v, width, height));
+  }
+}
+function movedPart(layer, moves) {
+  const own = owners(layer, moves);
+  const out = emptyLayer(layer.width, layer.height);
+  for (let i = 0; i < own.length; i++) {
+    if ((own[i] ?? -1) >= 0) takePixel(out, i, layer, { at: [i, i, i, i], w: [1, 0, 0, 0] });
+  }
+  return out;
+}
+function moveLayer(layer, moves) {
+  const own = owners(layer, moves);
+  const out = emptyLayer(layer.width, layer.height);
+  for (let i = 0; i < own.length; i++) {
+    if ((own[i] ?? -1) < 0 && (layer.alpha[i] ?? 0) > 0)
+      takePixel(out, i, layer, { at: [i, i, i, i], w: [1, 0, 0, 0] });
+  }
+  for (const [k, { fit }] of moves.entries()) moveBlock(out, layer, own, k, fit);
+  return out;
+}
+function cropLayer(layer, rect) {
+  const out = emptyLayer(rect.width, rect.height);
+  for (let y = 0; y < rect.height; y++) {
+    const from = (rect.y + y) * layer.width + rect.x;
+    const to = y * rect.width;
+    out.alpha.set(layer.alpha.subarray(from, from + rect.width), to);
+    out.ink.set(layer.ink.subarray(from, from + rect.width), to);
+    out.gain.set(layer.gain.subarray(from * 3, (from + rect.width) * 3), to * 3);
+    layer.pixels.copy(out.pixels, to * 3, from * 3, (from + rect.width) * 3);
+  }
+  return out;
+}
+
+// src/engine/nodes/local/lib/whole-render.ts
+var inSpans2 = (spans, fx, fy) => spans.some((s) => fx >= s.x0 && fx <= s.x1 && fy >= s.y0 && fy <= s.y1);
+function blurLine(src, out, start, step, n, r) {
+  const last = start + (n - 1) * step;
+  let acc = 0;
+  for (let k = -r; k <= r; k++) acc += src[k <= 0 ? start : k >= n - 1 ? last : start + k * step] ?? 0;
+  for (let k = 0; k < n; k++) {
+    out[start + k * step] = acc / (2 * r + 1);
+    const enter = k + r + 1;
+    const leave = k - r;
+    acc += (src[enter >= n - 1 ? last : start + enter * step] ?? 0) - (src[leave <= 0 ? start : start + leave * step] ?? 0);
+  }
+}
+function blurColumns(src, out, width, height, r) {
+  const acc = new Float64Array(width);
+  const row = (k) => (k <= 0 ? 0 : k >= height - 1 ? height - 1 : k) * width;
+  for (let k = -r; k <= r; k++) {
+    const from = row(k);
+    for (let x = 0; x < width; x++) acc[x] = (acc[x] ?? 0) + (src[from + x] ?? 0);
+  }
+  for (let k = 0; k < height; k++) {
+    const to = k * width;
+    const enter = row(k + r + 1);
+    const leave = row(k - r);
+    for (let x = 0; x < width; x++) {
+      out[to + x] = (acc[x] ?? 0) / (2 * r + 1);
+      acc[x] = (acc[x] ?? 0) + ((src[enter + x] ?? 0) - (src[leave + x] ?? 0));
+    }
+  }
+}
+function boxBlur(src, width, height, r) {
+  if (r < 1) return Float32Array.from(src);
+  const along = new Float32Array(width * height);
+  for (let y = 0; y < height; y++) blurLine(src, along, y * width, 1, width, r);
+  const out = new Float32Array(width * height);
+  blurColumns(along, out, width, height, r);
+  return out;
+}
+var soften = (src, width, height, r) => boxBlur(boxBlur(src, width, height, r), width, height, r);
+function channelOf(img, c) {
+  const out = new Float32Array(img.width * img.height);
+  for (let i = 0; i < out.length; i++) out[i] = img.data[i * img.channels + c] ?? 0;
+  return out;
+}
+var STRUCTURE_RADIUS = 8e-3;
+var GAIN_MAX2 = 2.5;
+var FLAT2 = 2.5;
+var STILL = 14;
+var MOVED = 28;
+function flatOf2(img) {
+  const { width, height } = img;
+  const grey = new Float32Array(width * height);
+  for (let i = 0; i < grey.length; i++) {
+    const o = i * img.channels;
+    grey[i] = 0.299 * (img.data[o] ?? 0) + 0.587 * (img.data[o + 1] ?? 0) + 0.114 * (img.data[o + 2] ?? 0);
+  }
+  const squares = new Float32Array(grey.length);
+  for (let i = 0; i < grey.length; i++) squares[i] = (grey[i] ?? 0) * (grey[i] ?? 0);
+  const mean = boxBlur(grey, width, height, 2);
+  const square = boxBlur(squares, width, height, 2);
+  const flat = new Uint8Array(mean.length);
+  for (let i = 0; i < mean.length; i++) {
+    const m = mean[i] ?? 0;
+    flat[i] = Math.sqrt(Math.max(0, (square[i] ?? 0) - m * m)) < FLAT2 ? 1 : 0;
+  }
+  return flat;
+}
+var gridOver = (width, height, size) => ({
+  size,
+  gw: Math.ceil(width / size),
+  gh: Math.ceil(height / size)
+});
+function cellOf(grid, i, width) {
+  const x = i % width;
+  return Math.floor((i - x) / width / grid.size) * grid.gw + Math.floor(x / grid.size);
+}
+function cellsNear(grid, g, reach) {
+  const gx = g % grid.gw;
+  const gy = (g - gx) / grid.gw;
+  const out = [];
+  for (let ny = Math.max(0, gy - reach); ny <= Math.min(grid.gh - 1, gy + reach); ny++) {
+    for (let nx = Math.max(0, gx - reach); nx <= Math.min(grid.gw - 1, gx + reach); nx++) out.push(ny * grid.gw + nx);
+  }
+  return out;
+}
+var SURFACE_CELL = 8;
+function laidCells(flat, structure, width, grid) {
+  const laid = new Float32Array(grid.gw * grid.gh);
+  const count = new Float32Array(grid.gw * grid.gh);
+  for (let i = 0; i < flat.length; i++) {
+    const g = cellOf(grid, i, width);
+    count[g] = (count[g] ?? 0) + 1;
+    if (flat[i] && (structure[i] ?? 0) > MOVED) laid[g] = (laid[g] ?? 0) + 1;
+  }
+  return Uint8Array.from(laid, (n, g) => n >= (count[g] ?? 1) / 2 ? 1 : 0);
+}
+function wordCells(words, width, height, grid) {
+  const out = [];
+  for (let g = 0; g < grid.gw * grid.gh; g++) {
+    const gx = g % grid.gw;
+    const gy = (g - gx) / grid.gw;
+    const x0 = gx * grid.size / width;
+    const y0 = gy * grid.size / height;
+    const x1 = (gx + 1) * grid.size / width;
+    const y1 = (gy + 1) * grid.size / height;
+    if (words.some((w) => w.x0 < x1 && w.x1 > x0 && w.y0 < y1 && w.y1 > y0)) out.push(g);
+  }
+  return out;
+}
+function flood2(seeds, open, grid) {
+  const reached = new Uint8Array(grid.gw * grid.gh);
+  for (const g of seeds) reached[g] = 1;
+  const stack = [...seeds];
+  while (stack.length > 0) {
+    const next = cellsNear(grid, stack.pop() ?? 0, 1).filter((n) => !reached[n] && open[n]);
+    for (const n of next) reached[n] = 1;
+    stack.push(...next);
+  }
+  return reached;
+}
+function surfaceOf(flat, structure, width, height, words) {
+  const grid = gridOver(width, height, SURFACE_CELL);
+  const reached = flood2(wordCells(words, width, height, grid), laidCells(flat, structure, width, grid), grid);
+  const surface = new Uint8Array(structure.length);
+  for (let y = 0; y < height; y++) {
+    const row = Math.floor(y / grid.size) * grid.gw;
+    for (let x = 0; x < width; x++) {
+      const i = y * width + x;
+      surface[i] = reached[row + Math.floor(x / grid.size)] && (structure[i] ?? 0) > MOVED ? 1 : 0;
+    }
+  }
+  return surface;
+}
+var GROUND_LINE = 3;
+var CARD_TONE = 16;
+var CARD_RUN = 0.6;
+var inTone = (img, i, tone) => [0, 1, 2].every((c) => Math.abs((img.data[i * img.channels + c] ?? 0) - (tone[c] ?? 0)) <= CARD_TONE);
+function* pixelsOf(r, width, height) {
+  for (let y = Math.max(0, r.y0); y < Math.min(height, r.y1); y++) {
+    for (let x = Math.max(0, r.x0); x < Math.min(width, r.x1); x++) yield y * width + x;
+  }
+}
+var stripsPast = (r, depth) => [
+  { ...r, y0: r.y0 - depth, y1: r.y0 },
+  { ...r, y0: r.y1, y1: r.y1 + depth },
+  { ...r, x0: r.x0 - depth, x1: r.x0 },
+  { ...r, x0: r.x1, x1: r.x1 + depth }
+];
+var inBoxes = (boxes, i, width) => {
+  const x = i % width;
+  const y = (i - x) / width;
+  return boxes.some((b) => x >= b.x0 && x < b.x1 && y >= b.y0 && y < b.y1);
+};
+function cardTone(img, flat, box, others = []) {
+  const { width, height } = img;
+  const around = stripsPast(box, GROUND_LINE).flatMap((s) => [...pixelsOf(s, width, height)]).filter((i) => !inBoxes(others, i, width));
+  const flatOnes = around.filter((i) => flat[i]);
+  if (around.length === 0 || flatOnes.length < around.length / 2) return null;
+  return [0, 1, 2].map((c) => {
+    const values = flatOnes.map((i) => img.data[i * img.channels + c] ?? 0).sort((a, b) => a - b);
+    return values[Math.floor(values.length / 2)] ?? 0;
+  });
+}
+var grownBy = (r, side, by) => side === 0 ? { ...r, y0: r.y0 - by } : side === 1 ? { ...r, y1: r.y1 + by } : side === 2 ? { ...r, x0: r.x0 - by } : { ...r, x1: r.x1 + by };
+function cardAround(img, box, tone) {
+  const { width, height } = img;
+  const share2 = (s) => {
+    const px = [...pixelsOf(s, width, height)];
+    return px.length > 0 ? px.filter((i) => inTone(img, i, tone)).length / px.length : 0;
+  };
+  const runs = (r2, side) => {
+    for (let by = 1; by <= GROUND_LINE + 1; by++)
+      if (share2(stripsPast(grownBy(r2, side, by - 1), 1)[side] ?? r2) >= CARD_RUN) return by;
+    return 0;
+  };
+  let r = box;
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (let side = 0; side < 4; side++) {
+      const by = runs(r, side);
+      if (by === 0) continue;
+      r = grownBy(r, side, by);
+      grew = true;
+    }
+  }
+  return r;
+}
+function groundOf(aligned, flat, words) {
+  const { width, height } = aligned;
+  const toned = new Float32Array(width * height);
+  const inCard = new Uint8Array(width * height);
+  const boxes = words.map((w) => ({
+    x0: Math.max(0, Math.floor(w.x0 * width)),
+    y0: Math.max(0, Math.floor(w.y0 * height)),
+    x1: Math.min(width, Math.ceil(w.x1 * width)),
+    y1: Math.min(height, Math.ceil(w.y1 * height))
+  }));
+  for (const box of boxes) {
+    const tone = cardTone(
+      aligned,
+      flat,
+      box,
+      boxes.filter((b) => b !== box)
+    );
+    if (!tone) continue;
+    for (const i of pixelsOf(cardAround(aligned, box, tone), width, height)) {
+      inCard[i] = 1;
+      if (inTone(aligned, i, tone)) toned[i] = 1;
+    }
+  }
+  const near = boxBlur(toned, width, height, GROUND_LINE);
+  return Uint8Array.from(near, (v, i) => v > 0 && inCard[i] ? 1 : 0);
+}
+function trustOf(width, height, words) {
+  const trust = new Float32Array(width * height);
+  for (let i = 0; i < trust.length; i++) {
+    const x = i % width;
+    trust[i] = inSpans2(words, (x + 0.5) / width, ((i - x) / width + 0.5) / height) ? 0 : 1;
+  }
+  return trust;
+}
+var cutPlanes = remembered();
+var shrunkCuts = remembered();
+function planesOf(img, r1) {
+  const own = [0, 1, 2].map((c) => channelOf(img, c));
+  return {
+    own,
+    low: own.map((p) => soften(p, img.width, img.height, r1)),
+    fine: own.map((p) => boxBlur(p, img.width, img.height, 1))
+  };
+}
+var LIGHT_CELL = 0.015;
+var LIGHT_REACH = 3;
+function cellSums(a, b, open, width, grid) {
+  const sums = new Float32Array(grid.gw * grid.gh * 7);
+  const own = [...a.own, ...b.own];
+  for (let i = 0; i < open.length; i++) {
+    if (!open[i]) continue;
+    const g = cellOf(grid, i, width) * 7;
+    for (let c = 0; c < 6; c++) sums[g + c] = (sums[g + c] ?? 0) + (own[c]?.[i] ?? 0);
+    sums[g + 6] = (sums[g + 6] ?? 0) + 1;
+  }
+  return sums;
+}
+function cellRatios(a, b, open, width, grid) {
+  const sums = cellSums(a, b, open, width, grid);
+  const ratio = new Float32Array(grid.gw * grid.gh * 3).fill(Number.NaN);
+  for (let g = 0; g < grid.gw * grid.gh; g++) {
+    const n = sums[g * 7 + 6] ?? 0;
+    if (n < grid.size * grid.size / 4) continue;
+    for (let c = 0; c < 3; c++) {
+      ratio[g * 3 + c] = ((sums[g * 7 + c] ?? 0) / n + 8) / ((sums[g * 7 + 3 + c] ?? 0) / n + 8);
+    }
+  }
+  return ratio;
+}
+function medianNear(values, near, c, scratch) {
+  let known = 0;
+  for (const n of near) {
+    const v = values[n * 3 + c] ?? Number.NaN;
+    if (!Number.isNaN(v)) scratch[known++] = v;
+  }
+  if (known === 0) return 1;
+  const sorted = scratch.subarray(0, known).sort();
+  return sorted[Math.floor(known / 2)] ?? 1;
+}
+function medianLight(ratio, grid) {
+  const cells = grid.gw * grid.gh;
+  const median = new Float32Array(cells * 3);
+  const scratch = new Float64Array((2 * LIGHT_REACH + 1) ** 2);
+  for (let g = 0; g < cells; g++) {
+    const near = cellsNear(grid, g, LIGHT_REACH);
+    for (let c = 0; c < 3; c++) median[g * 3 + c] = medianNear(ratio, near, c, scratch);
+  }
+  const smooth = new Float32Array(cells * 3);
+  for (let k = 0; k < cells * 3; k++) {
+    const near = cellsNear(grid, Math.floor(k / 3), 1);
+    smooth[k] = near.reduce((sum, n) => sum + (median[n * 3 + k % 3] ?? 1), 0) / near.length;
+  }
+  return smooth;
+}
+function lightOf(a, b, open, width, height) {
+  const grid = gridOver(width, height, Math.max(8, Math.round(width * LIGHT_CELL)));
+  const light = medianLight(cellRatios(a, b, open, width, grid), grid);
+  const gain = enlarge(light, { width: grid.gw, height: grid.gh }, { width, height }, 3);
+  const kept = new Float32Array(gain.length);
+  for (let i = 0; i < gain.length; i++) kept[i] = Math.min(GAIN_MAX2, Math.max(1 / GAIN_MAX2, gain[i] ?? 0));
+  return kept;
+}
+function compared(a, b, gain, n) {
+  const structure = new Float32Array(n);
+  const detail = new Float32Array(n);
+  for (let c = 0; c < 3; c++) {
+    const [aLow, bLow, aFine, bFine] = [a.low[c], b.low[c], a.fine[c], b.fine[c]];
+    for (let i = 0; i < n; i++) {
+      const g = gain[i * 3 + c] ?? 1;
+      structure[i] = Math.max(structure[i] ?? 0, Math.abs((aLow?.[i] ?? 0) - g * (bLow?.[i] ?? 0)));
+      detail[i] = Math.max(detail[i] ?? 0, Math.abs((aFine?.[i] ?? 0) - g * (bFine?.[i] ?? 0)));
+    }
+  }
+  return { structure, detail };
+}
+function renderDiff(aligned, cut, words) {
+  const { width, height } = cut;
+  const r1 = Math.max(2, Math.round(width * STRUCTURE_RADIUS));
+  const a = planesOf(aligned, r1);
+  const b = cutPlanes(cut, String(r1), () => planesOf(cut, r1));
+  const gain = lightOf(a, b, trustOf(width, height, words), width, height);
+  const { structure, detail } = compared(a, b, gain, width * height);
+  const flat = flatOf2(aligned);
+  const surface = surfaceOf(flat, structure, width, height, words);
+  let ground;
+  return {
+    width,
+    height,
+    structure,
+    detail,
+    flat,
+    surface,
+    gain,
+    // Read only to put a subject back: a render refused is never read for it.
+    get ground() {
+      ground ??= groundOf(aligned, flat, words);
+      return ground;
+    }
+  };
+}
+function subjectDrift(diff, subject, words) {
+  const { width, height } = diff;
+  const x0 = Math.max(0, Math.floor(subject.x0 * width));
+  const x1 = Math.min(width, Math.ceil(subject.x1 * width));
+  const y0 = Math.max(0, Math.floor(subject.y0 * height));
+  const y1 = Math.min(height, Math.ceil(subject.y1 * height));
+  const n = { all: 0, open: 0, covered: 0, moved: 0, drift: 0, held: 0 };
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      n.all++;
+      if (!inSpans2(words, (x + 0.5) / width, (y + 0.5) / height)) countDrift(n, diff, y * width + x);
+    }
+  }
+  return {
+    shown: n.all > 0 ? (n.open - n.covered) / n.all : 0,
+    moved: n.open > 0 ? n.moved / n.open : 0,
+    drift: n.held > 0 ? n.drift / n.held : 0
+  };
+}
+function countDrift(n, diff, i) {
+  n.open++;
+  if ((diff.structure[i] ?? 0) <= MOVED) {
+    n.drift += diff.detail[i] ?? 0;
+    n.held++;
+  } else if (diff.surface[i]) n.covered++;
+  else n.moved++;
+}
+var DRIFTED = 3;
+var MIN_KEPT = 0.75;
+var MAX_CARRIED = 5e-3;
+var REDRAWN = 0.2;
+var WHOLE_PROBLEMS = ["picture_moved", "subject_redrawn", "words_lost", "words_over_face"];
+function wholeVerdict(r) {
+  if (r.kept < MIN_KEPT || r.carried > MAX_CARRIED) return { ok: false, problem: "picture_moved", what: [] };
+  const redrawn = r.subjects.filter((s) => s.moved > REDRAWN).map((s) => s.label);
+  if (redrawn.length > 0) return { ok: false, problem: "subject_redrawn", what: redrawn };
+  if (r.lost.length > 0) return { ok: false, problem: "words_lost", what: [...r.lost] };
+  if (r.onFace.length > 0) return { ok: false, problem: "words_over_face", what: [...r.onFace] };
+  return { ok: true, restore: r.subjects.filter((s) => s.drift > DRIFTED).map((s) => s.label) };
+}
+function greyOf(img, f) {
+  const width = Math.max(1, Math.floor(img.width / f));
+  const height = Math.max(1, Math.floor(img.height / f));
+  const data = new Float32Array(width * height);
+  for (let i = 0; i < width * height; i++) {
+    const x = i % width * f;
+    const y = Math.floor(i / width) * f;
+    let sum = 0;
+    for (let j = 0; j < f; j++) {
+      for (let k = 0; k < f; k++) {
+        const o = ((y + j) * img.width + x + k) * img.channels;
+        sum += 0.299 * (img.data[o] ?? 0) + 0.587 * (img.data[o + 1] ?? 0) + 0.114 * (img.data[o + 2] ?? 0);
+      }
+    }
+    data[i] = sum / (f * f);
+  }
+  return { data, width, height };
+}
+function likeness(render, cut, box, place) {
+  const cx = box.x + box.width / 2;
+  const cy = box.y + box.height / 2;
+  const n = { count: 0, a: 0, c: 0, aa: 0, cc: 0, ac: 0 };
+  for (let y = box.y; y < box.y + box.height; y++) {
+    for (let x = box.x; x < box.x + box.width; x++) {
+      const u = Math.round(cx + place.scale * (x - cx) + place.dx);
+      const v = Math.round(cy + place.scale * (y - cy) + place.dy);
+      if (u < 0 || v < 0 || u >= render.width || v >= render.height) return -1;
+      const a = render.data[v * render.width + u] ?? 0;
+      const c = cut.data[y * cut.width + x] ?? 0;
+      n.count++;
+      n.a += a;
+      n.c += c;
+      n.aa += a * a;
+      n.cc += c * c;
+      n.ac += a * c;
+    }
+  }
+  const va = n.aa - n.a * n.a / n.count;
+  const vc = n.cc - n.c * n.c / n.count;
+  return va > 1e-6 && vc > 1e-6 ? (n.ac - n.a * n.c / n.count) / Math.sqrt(va * vc) : -1;
+}
+function boxIn(s, g, inset) {
+  const w = (s.x1 - s.x0) * g.width;
+  const h = (s.y1 - s.y0) * g.height;
+  const x = Math.max(0, Math.round(s.x0 * g.width + inset * w));
+  const y = Math.max(0, Math.round(s.y0 * g.height + inset * h));
+  return {
+    x,
+    y,
+    width: Math.max(1, Math.min(g.width - x, Math.round(w * (1 - 2 * inset)))),
+    height: Math.max(1, Math.min(g.height - y, Math.round(h * (1 - 2 * inset))))
+  };
+}
+function bestPlace(render, cut, box, places) {
+  let best = { dx: 0, dy: 0, scale: 1, score: -2 };
+  for (const place of places) {
+    const score = likeness(render, cut, box, place);
+    if (score > best.score) best = { ...place, score };
+  }
+  return best;
+}
+var TRACK_REACH = 0.25;
+var TRACK_SCALES = [0.85, 0.92, 1, 1.08, 1.15];
+var TRACK_WIDTH = 180;
+function* placesNear(around, reach, scales) {
+  for (const scale of scales) {
+    for (let dy = -reach; dy <= reach; dy++) {
+      for (let dx = -reach; dx <= reach; dx++) yield { dx: around.dx + dx, dy: around.dy + dy, scale };
+    }
+  }
+}
+function tracked(aligned, cut, subject) {
+  const f = Math.max(1, Math.round(cut.width / TRACK_WIDTH));
+  const coarse = { render: greyOf(aligned, f), cut: greyOf(cut, f) };
+  const reach = Math.round(TRACK_REACH * coarse.cut.width);
+  const found = bestPlace(
+    coarse.render,
+    coarse.cut,
+    boxIn(subject, coarse.cut, 0.1),
+    placesNear({ dx: 0, dy: 0, scale: 1 }, reach, TRACK_SCALES)
+  );
+  const fine = { render: greyOf(aligned, 1), cut: greyOf(cut, 1) };
+  const near = [found.scale - 0.03, found.scale, found.scale + 0.03];
+  const refined = bestPlace(
+    fine.render,
+    fine.cut,
+    boxIn(subject, fine.cut, 0.1),
+    placesNear({ dx: found.dx * f, dy: found.dy * f, scale: 1 }, f, near)
+  );
+  return {
+    dx: refined.dx / cut.width,
+    dy: refined.dy / cut.height,
+    scale: refined.scale,
+    score: refined.score
+  };
+}
+var FACE_EDGE = 0.15;
+function wordsOnFaces(words, faces) {
+  return facesUnder(words, faces).map((f) => f.label);
+}
+function facesUnder(words, faces) {
+  return faces.filter((f) => {
+    const dx = FACE_EDGE * (f.x1 - f.x0);
+    const dy = FACE_EDGE * (f.y1 - f.y0);
+    return words.some((w) => w.x0 < f.x1 - dx && w.x1 > f.x0 + dx && w.y0 < f.y1 - dy && w.y1 > f.y0 + dy);
+  });
+}
+var FRAME_MARGIN = 0.01;
+function wordsLost(words, format, placements, keepOut = []) {
+  const cut = words.filter(
+    (b) => b.x0 < FRAME_MARGIN || b.y0 < FRAME_MARGIN || b.x1 > 1 - FRAME_MARGIN || b.y1 > 1 - FRAME_MARGIN || keepOut.some((k) => overlaps2(b, k))
+  );
+  const covered = bandViolations(
+    words.filter((b) => !cut.includes(b)),
+    format,
+    { placements: blockingPlacements(placements) }
+  ).filter((v) => v.covered);
+  return [...cut.map((b) => b.text), ...covered.map((v) => v.text)];
+}
+var ZONE_MARGIN = 0.12;
+var FEATHER = 4e-3;
+function addZone(into2, zone, width, height) {
+  const x0 = zone.x0 * width;
+  const x1 = zone.x1 * width;
+  const y0 = zone.y0 * height;
+  const y1 = zone.y1 * height;
+  const margin = Math.max(4, ZONE_MARGIN * Math.max(x1 - x0, y1 - y0));
+  for (let y = Math.max(0, Math.floor(y0 - margin)); y < Math.min(height, Math.ceil(y1 + margin)); y++) {
+    for (let x = Math.max(0, Math.floor(x0 - margin)); x < Math.min(width, Math.ceil(x1 + margin)); x++) {
+      const dx = Math.max(0, x0 - (x + 0.5), x + 0.5 - x1);
+      const dy = Math.max(0, y0 - (y + 0.5), y + 0.5 - y1);
+      const t = 1 - Math.min(1, Math.sqrt(dx * dx + dy * dy) / margin);
+      const i = y * width + x;
+      into2[i] = Math.max(into2[i] ?? 0, t * t * (3 - 2 * t));
+    }
+  }
+}
+function restoreMask(diff, zones, words) {
+  const { width, height } = diff;
+  const zone = new Float32Array(width * height);
+  for (const z5 of zones) addZone(zone, z5, width, height);
+  const laid = boxBlur(
+    Float32Array.from(diff.flat, (f, i) => f && (diff.detail[i] ?? 0) > KEPT_DETAIL || diff.ground[i] ? 1 : 0),
+    width,
+    height,
+    1
+  );
+  const off = trustOf(width, height, words).map((t, i) => t > 0 && (laid[i] ?? 0) === 0 ? 0 : 1);
+  const held = zone.map(
+    (z5, i) => z5 > 0 && !off[i] ? z5 * Math.min(1, Math.max(0, (MOVED - (diff.structure[i] ?? 0)) / (MOVED - STILL))) : 0
+  );
+  const feathered = soften(held, width, height, Math.max(2, Math.round(width * FEATHER)));
+  return feathered.map((m, i) => off[i] ? 0 : m);
+}
+function restoreSubjects(aligned, cut, gain, mask) {
+  const { width, height } = cut;
+  const out = Buffer.alloc(width * height * 3);
+  for (let i = 0; i < width * height; i++) {
+    const m = mask[i] ?? 0;
+    for (let c = 0; c < 3; c++) {
+      const own = aligned.data[i * aligned.channels + c] ?? 0;
+      if (m <= 0) {
+        out[i * 3 + c] = own;
+        continue;
+      }
+      const back = Math.min(255, (cut.data[i * cut.channels + c] ?? 0) * (gain[i * 3 + c] ?? 1));
+      out[i * 3 + c] = Math.round(own * (1 - m) + back * m);
+    }
+  }
+  return { data: out, width, height, channels: 3 };
+}
+var KEPT_DETAIL = 24;
+function keptShare(diff, words) {
+  const { width, height } = diff;
+  let textured = 0;
+  let kept = 0;
+  for (let i = 0; i < width * height; i++) {
+    if (diff.flat[i] || diff.surface[i]) continue;
+    const x = i % width;
+    if (inSpans2(words, (x + 0.5) / width, ((i - x) / width + 0.5) / height)) continue;
+    textured++;
+    if ((diff.detail[i] ?? 0) < KEPT_DETAIL) kept++;
+  }
+  return textured > 0 ? kept / textured : 1;
+}
+function cropRaw(img, rect) {
+  const data = Buffer.alloc(rect.width * rect.height * 3);
+  for (let y = 0; y < rect.height; y++) {
+    const from = ((rect.y + y) * img.width + rect.x) * img.channels;
+    if (img.channels === 3) {
+      img.data.copy(data, y * rect.width * 3, from, from + rect.width * 3);
+      continue;
+    }
+    for (let x = 0; x < rect.width; x++) {
+      for (let c = 0; c < 3; c++) data[(y * rect.width + x) * 3 + c] = img.data[from + x * img.channels + c] ?? 0;
+    }
+  }
+  return { data, width: rect.width, height: rect.height, channels: 3 };
+}
+function carriedBy(fit, frame, width, height) {
+  const at = (x, y) => [
+    width / 2 + fit.scale * (x - width / 2) + fit.dx,
+    height / 2 + fit.scale * (y - height / 2) + fit.dy
+  ];
+  const [left = 0, top = 0] = at(frame.x, frame.y);
+  const [right = 0, bottom = 0] = at(frame.x + frame.width, frame.y + frame.height);
+  return Math.max(
+    0,
+    -left / frame.width,
+    -top / frame.height,
+    (right - width) / frame.width,
+    (bottom - height) / frame.height
+  );
+}
+var SHOWN_MIN = 0.5;
+var JUDGED_WIDTH = 720;
+function shrinkRaw(img, f) {
+  const width = Math.floor(img.width / f);
+  const height = Math.floor(img.height / f);
+  const data = Buffer.alloc(width * height * 3);
+  for (let i = 0; i < width * height; i++) {
+    const x = i % width * f;
+    const y = Math.floor(i / width) * f;
+    for (let c = 0; c < 3; c++) {
+      let sum = 0;
+      for (let j = 0; j < f; j++) {
+        const row = ((y + j) * img.width + x) * img.channels + c;
+        for (let k = 0; k < f; k++) sum += img.data[row + k * img.channels] ?? 0;
+      }
+      data[i * 3 + c] = Math.round(sum / (f * f));
+    }
+  }
+  return { data, width, height, channels: 3 };
+}
+function axisTaps(from, to) {
+  const near = new Int32Array(to);
+  const far = new Int32Array(to);
+  const t = new Float32Array(to);
+  for (let k = 0; k < to; k++) {
+    const u = Math.min(from - 1, Math.max(0, (k + 0.5) * from / to - 0.5));
+    near[k] = Math.floor(u);
+    far[k] = Math.min(from - 1, Math.floor(u) + 1);
+    t[k] = u - Math.floor(u);
+  }
+  return { near, far, t };
+}
+function enlargeRow(values, out, xs, row, stride) {
+  const { top, bottom, fy } = row;
+  for (let x = 0; x < row.width; x++) {
+    const left = xs.near[x] ?? 0;
+    const right = xs.far[x] ?? 0;
+    const fx = xs.t[x] ?? 0;
+    const o = (row.y * row.width + x) * stride;
+    for (let c = 0; c < stride; c++) {
+      const upper = (values[(top + left) * stride + c] ?? 0) * (1 - fx) + (values[(top + right) * stride + c] ?? 0) * fx;
+      const lower = (values[(bottom + left) * stride + c] ?? 0) * (1 - fx) + (values[(bottom + right) * stride + c] ?? 0) * fx;
+      out[o + c] = upper * (1 - fy) + lower * fy;
+    }
+  }
+}
+function enlarge(values, from, to, stride) {
+  if (from.width === to.width && from.height === to.height) return values;
+  const xs = axisTaps(from.width, to.width);
+  const ys = axisTaps(from.height, to.height);
+  const out = new Float32Array(to.width * to.height * stride);
+  for (let y = 0; y < to.height; y++) {
+    const top = (ys.near[y] ?? 0) * from.width;
+    const bottom = (ys.far[y] ?? 0) * from.width;
+    enlargeRow(values, out, xs, { y, top, bottom, fy: ys.t[y] ?? 0, width: to.width }, stride);
+  }
+  return out;
+}
+function moveOnRender(m, frame, width, height) {
+  const x = (v) => (frame.x + v * frame.width) / width;
+  const y = (v) => (frame.y + v * frame.height) / height;
+  return {
+    group: { x0: x(m.group.x0), y0: y(m.group.y0), x1: x(m.group.x1), y1: y(m.group.y1) },
+    fit: {
+      scale: m.fit.scale,
+      cx: x(m.fit.cx),
+      cy: y(m.fit.cy),
+      dx: m.fit.dx * frame.width / width,
+      dy: m.fit.dy * frame.height / height
+    }
+  };
+}
+var overlaps2 = (a, b) => a.x0 < b.x1 && a.x1 > b.x0 && a.y0 < b.y1 && a.y1 > b.y0;
+var shifted = (box, dx, dy) => ({
+  ...box,
+  x0: box.x0 + dx,
+  y0: box.y0 + dy,
+  x1: box.x1 + dx,
+  y1: box.y1 + dy
+});
+var moveOf = (box, moves) => moves.find((m) => inSpans2([m.group], (box.x0 + box.x1) / 2, (box.y0 + box.y1) / 2));
+var hull = (a, b) => ({
+  x0: Math.min(a.x0, b.x0),
+  y0: Math.min(a.y0, b.y0),
+  x1: Math.max(a.x1, b.x1),
+  y1: Math.max(a.y1, b.y1)
+});
+var BARE = 0.02;
+var frameSpan = (frame, width, height) => ({
+  x0: frame.x / width,
+  y0: frame.y / height,
+  x1: (frame.x + frame.width) / width,
+  y1: (frame.y + frame.height) / height
+});
+var CARD_CUT = 5e-3;
+function cardCut(band, f) {
+  const w = f.x1 - f.x0;
+  const h = f.y1 - f.y0;
+  const across2 = band.x0 <= f.x0 + FRAME_MARGIN * w && band.x1 >= f.x1 - FRAME_MARGIN * w;
+  const down = band.y0 <= f.y0 + FRAME_MARGIN * h && band.y1 >= f.y1 - FRAME_MARGIN * h;
+  const pastY = band.y0 < f.y0 - CARD_CUT * h || band.y1 > f.y1 + CARD_CUT * h;
+  const pastX = band.x0 < f.x0 - CARD_CUT * w || band.x1 > f.x1 + CARD_CUT * w;
+  return pastY && !across2 || pastX && !down;
+}
+function cutCardOf(laid, line, f) {
+  const band = bandUnder(laid, line);
+  return band && cardCut(band, f) ? band : null;
+}
+var unique = (boxes) => boxes.filter(
+  (b, i) => boxes.findIndex((o) => o.x0 === b.x0 && o.y0 === b.y0 && o.x1 === b.x1 && o.y1 === b.y1) === i
+);
+function merged(spans) {
+  const out = [];
+  for (const s of spans) {
+    let joined = s;
+    for (let i = out.length - 1; i >= 0; i--) {
+      const o = out[i];
+      if (o && overlaps2(o, joined)) {
+        joined = hull(o, joined);
+        out.splice(i, 1);
+      }
+    }
+    out.push(joined);
+  }
+  return out;
+}
+function carriersOf(m, laid, designed) {
+  const lines = designed.filter((b) => inSpans2([m.group], (b.x0 + b.x1) / 2, (b.y0 + b.y1) / 2));
+  const bands = lines.flatMap((b) => {
+    const band = bandUnder(laid, b);
+    return band ? [band] : [];
+  });
+  if (bands.length === 0) return "picture";
+  return bands.length < lines.length ? "mixed" : merged(bands);
+}
+function bandMoves(banded, moves, p, at) {
+  const faces = p.subjects.filter((s) => s.kind === "face");
+  const out = [];
+  for (const { move: m, band } of banded) {
+    if (m.fit.scale < 1 - 1e-9 || out.some((o) => overlaps2(o.band, band))) return null;
+    const { dx, dy } = m.fit;
+    const landing = shifted(band, dx, dy);
+    const carried = p.words.designed.filter((b) => inSpans2([band], (b.x0 + b.x1) / 2, (b.y0 + b.y1) / 2));
+    const others = p.words.designed.filter((b) => !carried.includes(b));
+    const ends = (b) => {
+      const own = moveOf(b, moves);
+      return own ? movedSpan(at.extent(b), own.fit) : at.extent(b);
+    };
+    const lost = wordsLost(
+      carried.map((b) => at.inFrame(shifted(b, dx, dy))),
+      p.format,
+      p.placements
+    );
+    const crossed = carried.some((b) => (moveOf(b, moves) ?? m) !== m) || others.some((b) => overlaps2(ends(b), hull(band, landing)));
+    if (lost.length > 0 || crossed || facesUnder([landing], faces).length > 0) return null;
+    out.push({ band, dx, dy, words: carried });
+  }
+  return out;
+}
+function wordsMoved(p, out, moves) {
+  const { layer } = wordsLayer(p.aligned, p.cut, p.words.designed, {
+    subjects: p.subjects,
+    keepOut: p.words.inScene
+  });
+  const part = movedPart(layer, moves);
+  const left = soften(
+    part.alpha.map((a) => a > 0 ? 1 : 0),
+    p.cut.width,
+    p.cut.height,
+    2
+  ).map((a, i) => Math.max(a, part.alpha[i] ?? 0));
+  return compose(restoreSubjects(out, p.cut, p.gain, left), moveLayer(part, moves));
+}
+function placeWords(p) {
+  const { width, height } = p.cut;
+  const inFrame = (b) => ({
+    ...b,
+    x0: (b.x0 * width - p.frame.x) / p.frame.width,
+    x1: (b.x1 * width - p.frame.x) / p.frame.width,
+    y0: (b.y0 * height - p.frame.y) / p.frame.height,
+    y1: (b.y1 * height - p.frame.y) / p.frame.height
+  });
+  const showing = (b) => b.x1 > 0 && b.y1 > 0 && b.x0 < 1 && b.y0 < 1;
+  const laid = laidMap(p.judged.aligned, p.judged.cut);
+  const f = frameSpan(p.frame, width, height);
+  const placed2 = p.words.designed.map((b) => {
+    const card = cutCardOf(laid, b, f);
+    return card ? { ...b, ...card } : b;
+  });
+  const plan = planWordsShift(unique(placed2).map(inFrame).filter(showing), p.format, {
+    ...p.placements ? { placements: p.placements } : {},
+    ...p.minScale !== void 0 ? { minScale: p.minScale } : {},
+    faces: p.subjects.filter((s) => s.kind === "face").map(inFrame).filter(showing),
+    // Never into the logo's slot, nor out of it: a block moved out of it had its band cut through the letters.
+    ...p.keepOut ? { keepOut: p.keepOut } : {}
+  });
+  if (plan.reason || plan.moves.length === 0) return null;
+  const moves = plan.moves.map((m) => moveOnRender(m, p.frame, width, height));
+  const under = moves.map((move) => ({ move, on: carriersOf(move, laid, p.words.designed) }));
+  const unsure = (u) => u.on === "mixed" || u.on === "picture" && laidAround(laid, u.move.group) > BARE;
+  if (under.some(unsure)) return null;
+  const banded = under.flatMap((u) => Array.isArray(u.on) ? u.on.map((band) => ({ move: u.move, band })) : []);
+  const bands = bandMoves(banded, moves, p, { inFrame, extent: (b) => bandUnder(laid, b) ?? b });
+  if (!bands) return null;
+  const loose = under.flatMap((u) => u.on === "picture" ? [u.move] : []);
+  let out = loose.length > 0 ? wordsMoved(p, p.out, loose) : p.out;
+  for (const band of bands) out = moveBand({ aligned: p.aligned, cut: p.cut, out }, band);
+  return { out, moves: plan.moves };
+}
+function takeWhole(input) {
+  const { render, cut, frame } = input;
+  const fit = registerToSource(render, cut, input.words?.designed ?? []);
+  const aligned = warpToCut(render, fit);
+  if (!input.words) {
+    const out2 = cropRaw(aligned, frame);
+    return { ok: true, out: out2, restored: [], covered: [], moves: [], kept: 1, residual: fit.residual };
+  }
+  const judging = judge(input, input.words, fit, aligned);
+  const { verdict, kept } = judging;
+  const misplaced = !verdict.ok && (verdict.problem === "words_lost" || verdict.problem === "words_over_face");
+  if (!verdict.ok && !misplaced) return { ...verdict, kept, residual: fit.residual };
+  const { out, gain, taken } = putBack(input, input.words, aligned, judging);
+  const done = { ...taken, kept, residual: fit.residual };
+  if (verdict.ok) return { ok: true, out: cropRaw(out, frame), moves: [], ...done };
+  const placed2 = placeWords({
+    aligned,
+    cut,
+    out,
+    gain: gain(),
+    judged: judging.judged,
+    frame,
+    words: input.words,
+    subjects: input.subjects,
+    format: input.format,
+    ...input.placements ? { placements: input.placements } : {},
+    ...input.minScale !== void 0 ? { minScale: input.minScale } : {},
+    ...input.keepOut ? { keepOut: input.keepOut } : {}
+  });
+  if (!placed2) return { ...verdict, kept, residual: fit.residual, whole: { out: cropRaw(out, frame), ...taken } };
+  return { ok: true, out: cropRaw(placed2.out, frame), moves: placed2.moves, ...done };
+}
+function judge(input, read, fit, aligned) {
+  const { cut, frame } = input;
+  const { width, height } = cut;
+  const words = read.designed.map((b) => padded(b, width, height));
+  const shrink2 = Math.max(1, Math.round(width / JUDGED_WIDTH));
+  const judged = shrink2 > 1 ? { aligned: shrinkRaw(aligned, shrink2), cut: shrunkCuts(cut, String(shrink2), () => shrinkRaw(cut, shrink2)) } : { aligned, cut };
+  const diff = renderDiff(judged.aligned, judged.cut, words);
+  const drifts = input.subjects.map((s) => ({ subject: s, ...subjectDrift(diff, s, words) }));
+  const inFrame = (b) => ({
+    ...b,
+    x0: (b.x0 * width - frame.x) / frame.width,
+    x1: (b.x1 * width - frame.x) / frame.width,
+    y0: (b.y0 * height - frame.y) / frame.height,
+    y1: (b.y1 * height - frame.y) / frame.height
+  });
+  const kept = keptShare(diff, words);
+  const gone = /* @__PURE__ */ new Set();
+  const laid = laidMap(judged.aligned, judged.cut);
+  const f = frameSpan(frame, width, height);
+  const carded = read.designed.filter((b) => cutCardOf(laid, b, f)).map((b) => b.text);
+  const lost = wordsLost(read.designed.map(inFrame), input.format, input.placements, input.keepOut);
+  const base = {
+    kept,
+    carried: carriedBy(fit, frame, width, height),
+    lost: [...lost, ...carded.filter((t) => !lost.includes(t))]
+  };
+  const faces = () => input.subjects.filter((s) => s.kind === "face" && !gone.has(s));
+  const readingNow = () => ({
+    ...base,
+    subjects: drifts.filter((d) => !gone.has(d.subject)).map((d) => ({ label: d.subject.label, moved: d.moved, drift: d.drift, shown: d.shown })),
+    onFace: wordsOnFaces(read.designed, faces())
+  });
+  let verdict = wholeVerdict(readingNow());
+  const relocated = [];
+  for (let round = 0; round < 2 && !verdict.ok && FOLLOWED.has(verdict.problem); round++) {
+    const suspects = verdict.problem === "subject_redrawn" ? drifts.filter((d) => !gone.has(d.subject) && d.moved > REDRAWN).map((d) => d.subject) : facesUnder(read.designed, faces());
+    const found = relocations(withTheirPeople(suspects, input.subjects), judged);
+    if (!found) break;
+    relocated.push(...found);
+    for (const r of found) gone.add(r.subject);
+    verdict = wholeVerdict(readingNow());
+  }
+  return { verdict, reading: readingNow(), kept, diff, judged, words, drifts, relocated };
+}
+function withTheirPeople(suspects, subjects) {
+  const holds2 = (outer, inner) => outer.x0 <= inner.x0 + 0.01 && outer.y0 <= inner.y0 + 0.01 && outer.x1 >= inner.x1 - 0.01 && outer.y1 >= inner.y1 - 0.01;
+  const people = subjects.filter(
+    (p) => p.kind === "person" && suspects.some((f) => f.kind === "face" && f.label === p.label && holds2(p, f))
+  );
+  return [.../* @__PURE__ */ new Set([...suspects, ...people])];
+}
+var FOLLOWED = /* @__PURE__ */ new Set(["subject_redrawn", "words_over_face"]);
+function putBack(input, read, aligned, j) {
+  const { cut } = input;
+  const full = { width: cut.width, height: cut.height };
+  const settled = j.verdict.ok ? j.verdict : wholeVerdict({ ...j.reading, lost: [], onFace: [] });
+  const restored = settled.ok ? settled.restore : [];
+  const back = input.subjects.filter((s) => restored.includes(s.label));
+  const zones = [...back, ...read.inScene.map((b) => padded(b, full.width, full.height))];
+  const covered = j.drifts.filter((d) => (d.subject.kind === "product" || d.subject.kind === "animal") && d.shown < SHOWN_MIN).map((d) => d.subject.label);
+  let enlarged;
+  const gain = () => {
+    enlarged ??= enlarge(j.diff.gain, j.diff, full, 3);
+    return enlarged;
+  };
+  let out = zones.length === 0 ? aligned : restoreSubjects(aligned, cut, gain(), enlarge(restoreMask(j.diff, zones, j.words), j.diff, full, 1));
+  for (const r of j.relocated) out = putMoved(out, cut, r, j);
+  const moved = j.relocated.map((r) => r.subject.label);
+  return { out, gain, taken: { restored: [.../* @__PURE__ */ new Set([...restored, ...moved])], covered } };
+}
+var TRACK_MAX_AREA = 0.06;
+var RELOCATED = 0.8;
+var STAYED = 5e-3;
+function relocations(subjects, judged) {
+  if (subjects.length === 0) return null;
+  const out = [];
+  for (const subject of subjects) {
+    if ((subject.x1 - subject.x0) * (subject.y1 - subject.y0) > TRACK_MAX_AREA) return null;
+    const place = tracked(judged.aligned, judged.cut, subject);
+    const stayed = Math.hypot(place.dx, place.dy) < STAYED && Math.abs(place.scale - 1) < 0.02;
+    if (place.score < RELOCATED || stayed) return null;
+    out.push({ subject, place });
+  }
+  return out;
+}
+function movedBox(box, place) {
+  const cx = (box.x0 + box.x1) / 2;
+  const cy = (box.y0 + box.y1) / 2;
+  return {
+    x0: cx + place.dx + place.scale * (box.x0 - cx),
+    y0: cy + place.dy + place.scale * (box.y0 - cy),
+    x1: cx + place.dx + place.scale * (box.x1 - cx),
+    y1: cy + place.dy + place.scale * (box.y1 - cy)
+  };
+}
+function cutMoved(cut, box, place) {
+  const { width, height } = cut;
+  const out = Buffer.alloc(width * height * 3);
+  if (cut.channels === 3) cut.data.copy(out, 0, 0, width * height * 3);
+  else for (let i = 0; i < width * height; i++) cut.data.copy(out, i * 3, i * cut.channels, i * cut.channels + 3);
+  const to = movedBox(box, place);
+  const margin = (ZONE_MARGIN + FEATHER) * Math.max((to.x1 - to.x0) * width, (to.y1 - to.y0) * height) + 4;
+  const cx = (box.x0 + box.x1) / 2 * width;
+  const cy = (box.y0 + box.y1) / 2 * height;
+  for (let y = Math.max(0, Math.floor(to.y0 * height - margin)); y < Math.min(height, to.y1 * height + margin); y++) {
+    for (let x = Math.max(0, Math.floor(to.x0 * width - margin)); x < Math.min(width, to.x1 * width + margin); x++) {
+      const u = Math.min(width - 1.001, Math.max(0, cx + (x - cx - place.dx * width) / place.scale));
+      const v = Math.min(height - 1.001, Math.max(0, cy + (y - cy - place.dy * height) / place.scale));
+      const x0 = Math.floor(u);
+      const y0 = Math.floor(v);
+      const fx = u - x0;
+      const fy = v - y0;
+      for (let c = 0; c < 3; c++) {
+        const at = (px, py) => cut.data[(py * width + px) * cut.channels + c] ?? 0;
+        const top = at(x0, y0) * (1 - fx) + at(x0 + 1, y0) * fx;
+        const bottom = at(x0, y0 + 1) * (1 - fx) + at(x0 + 1, y0 + 1) * fx;
+        out[(y * width + x) * 3 + c] = Math.round(top * (1 - fy) + bottom * fy);
+      }
+    }
+  }
+  return { data: out, width, height, channels: 3 };
+}
+function putMoved(out, cut, r, j) {
+  const full = { width: cut.width, height: cut.height };
+  const moved = cutMoved(cut, r.subject, r.place);
+  const judgedMoved = j.judged.cut.width === cut.width ? moved : shrinkRaw(moved, Math.round(cut.width / j.judged.cut.width));
+  const diff = renderDiff(j.judged.aligned, judgedMoved, j.words);
+  const mask = restoreMask(diff, [movedBox(r.subject, r.place)], j.words);
+  return restoreSubjects(out, moved, enlarge(diff.gain, diff, full, 3), enlarge(mask, diff, full, 1));
+}
+
+// src/engine/nodes/local/staticFormat.ts
+var Usage = z3.object({ model: z3.string(), inputTokens: z3.number(), outputTokens: z3.number(), costUsd: z3.number() }).strict();
+var Unit = z3.number().min(0).max(1);
+var SpanSchema = z3.object({ x0: Unit, y0: Unit, x1: Unit, y1: Unit }).strict();
+var Copy = z3.array(z3.object({ text: z3.string().min(1), role: z3.string().optional() }).strict());
+var Rect = z3.object({ x: z3.number(), y: z3.number(), width: z3.number(), height: z3.number() }).strict();
+var REASONS = [
+  "band_too_far",
+  "words_over_face",
+  "subject_covered",
+  "subject_cut",
+  "words_misaligned",
+  "words_not_read",
+  "not_read"
+];
+var FormatFacts = z3.object({
+  format: z3.string(),
+  lead: z3.boolean(),
+  plate: z3.object({ width: z3.number(), height: z3.number() }).strict(),
+  crop: Rect,
+  render_ratio: z3.string(),
+  upscale: z3.number(),
+  /** Each block of words code moved (into the band, off a face): its scale and shift, fractions of the size. */
+  moves: z3.array(z3.object({ scale: z3.number(), dx: z3.number(), dy: z3.number() }).strict()),
+  /** How far the words render sat from the cut once lined up (RMS grey levels): the spike's calibration of `MISALIGNED`. */
+  residual: z3.number().optional(),
+  reason: z3.enum(REASONS).optional(),
+  /** `subject_covered`: the products and animals the words hide most of in this size, as the reader names them. */
+  covered: z3.array(z3.string()).optional(),
+  /**
+   * How the words were laid: `whole`, the words model's whole render, its redrawn subjects put back
+   * from the picture; `masked`, only what it changed at the words, on the picture (when its render
+   * could not be taken whole twice). Absent when no words were set (`subject_cut`).
+   */
+  words_mode: z3.enum(["whole", "masked"]).optional(),
+  /** `whole`: the share of the picture's detail the render kept where it was (`keptShare`). */
+  kept: z3.number().optional(),
+  /** `whole`: the people, faces and products put back from the picture where the render redrew them. */
+  restored: z3.array(z3.string()).optional(),
+  /** Why the first render could not be taken whole, so the words were set a second time. */
+  retried: z3.enum(WHOLE_PROBLEMS).optional(),
+  /** `masked`: why the second render could not be taken whole either. */
+  refused: z3.enum(WHOLE_PROBLEMS).optional(),
+  reverted: z3.number(),
+  /** `masked`: the mean difference from the cut outside the words layer, 0 by construction. */
+  identity: z3.number().optional(),
+  steps: z3.array(
+    z3.object({
+      name: z3.enum(["subjects", "words", "words_again", "boxes"]),
+      cached: z3.boolean(),
+      credits: z3.number(),
+      ms: z3.number()
+    }).strict()
+  )
+}).strict();
+var Words = z3.object({
+  model: z3.string().min(1),
+  quality: z3.string().optional(),
+  prompt: z3.string().min(1),
+  /** A change to the words of this size (`--reword`, an autofix): the previous render (`inputs.previous`) leads. */
+  edit: z3.object({ instruction: z3.string().min(1) }).strict().optional()
+}).strict();
+var MISALIGNED = 40;
+var FormatParamsSchema = z3.object({
+  format: z3.string().regex(/^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/),
+  lead: z3.boolean().optional(),
+  placements: z3.array(z3.string().min(1)).optional(),
+  words: Words,
+  copy: Copy.optional(),
+  in_scene: z3.array(z3.string().min(1)).optional(),
+  /** The plan's subject zone, fractions of the plate: what the cut centres on when no subject was read. */
+  core: SpanSchema.optional(),
+  band_min_scale: z3.number().min(0.5).max(1).optional(),
+  /**
+   * The other sizes cut from the same picture (a variant's lead is checked against them): when
+   * one would cut a face, a product or a head, no words are paid for (`subject_cut`).
+   */
+  check_formats: z3.array(z3.string().regex(/^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/)).optional(),
+  /**
+   * The brand's logo file is placed on this size afterwards (`static_logo`): the words draw no logo
+   * and keep its slot empty, planned here inside the size's safe area off every face and product,
+   * from the logo's shape (`aspect`, width over height) and where the concept puts it (`position`).
+   */
+  logo_slot: z3.object({ aspect: z3.number().positive(), position: z3.enum(LOGO_POSITIONS).optional() }).strict().optional()
+}).strict();
+var staticFormatNode = defineNode({
+  id: "static_format",
+  version: "1.9.0",
+  category: "image",
+  location: "local",
+  billing: "reported",
+  summary: "One delivered size of a static ad, from the ad's picture (`plate`): cuts the size at one scale around the people and products (`subjects`), and around the cards the picture draws for its words when it can, has the image model set the ad's designed words, logo and button on the cut (`params.words`, one paid call), and takes its whole render, lined up with the cut, putting back from the picture each person, face and product it redrew (soft-edged, in the render's light). Words the frame cuts, the app covers or a face sits under are moved by code on the render, with the band, card or pill they sit on. A render that moved the picture or redrew a subject, or whose words no move clears, is set again once; when that one moved or redrew too, only what it changed at the words is kept on the picture, and when its words are out of place twice, it stays whole and says where they are. Outputs the size (`image`), the cut it was set on (`cut`), the model's render (`words_raw`), where the words were laid when only they were kept (`words_alpha`) and what it did (`facts`).",
+  when_to_use: "One per delivered size of a static ad built on one picture (`format_<size>`, role `static_format`). One image call at the words model's price (two when the first cannot be taken whole), kept apart from the free cut and compose: changing only the band, the placements or the node's version never pays for it again; `--regenerate format_<size>` does.",
+  inputs: z3.object({
+    plate: ImageRef,
+    subjects: z3.array(SubjectBoxSchema).optional(),
+    logo: ImageRef.optional(),
+    type: ImageRef.optional(),
+    style: ImageRef.optional(),
+    refs: z3.array(ImageRef).optional(),
+    previous: ImageRef.optional()
+  }).strict(),
+  params: FormatParamsSchema,
+  outputs: z3.object({
+    image: ImageRef,
+    cut: ImageRef,
+    words_raw: ImageRef.optional(),
+    words_alpha: ImageRef.optional(),
+    /** The slot the words left empty for the logo file, in the size's pixels (`params.logo_slot`). */
+    logo_slot: Rect.optional(),
+    facts: FormatFacts,
+    usage: z3.array(Usage).optional()
+  }).strict(),
+  outputKinds: { image: "image", cut: "image", words_raw: "image", words_alpha: "image" },
+  cost: ({ params }) => imageGenerateNode.cost?.({ params: wordsCallParams(params.words, "1:1") }) ?? {
+    credits: 0,
+    seconds_estimate: 60
+  },
+  async execute({ inputs, params, ctx }) {
+    return await formatSize(inputs, params, ctx);
+  }
+});
+function wordsCallParams(words, ratio) {
+  const prompt = words.edit ? `Edit: ${words.edit.instruction}
+
+${words.prompt}` : words.prompt;
+  return { model: words.model, prompt, aspect_ratio: ratio, ...words.quality ? { quality: words.quality } : {} };
+}
+var percent = (v) => Math.round(Math.max(0, Math.min(1, v)) * 100);
+function wordsAvoid(faces) {
+  if (faces.length === 0) return "";
+  const where = faces.map(
+    (f) => `a face ${percent(f.y0)}-${percent(f.y1)}% down, ${percent(f.x0)}-${percent(f.x1)}% across`
+  );
+  return `Keep every word, the logo and the button off ${where.join("; ")}.`;
+}
+function stripsOf(before, after, sides, depth) {
+  const cut = [
+    ...percent(before) >= 1 ? [{ share: percent(before), side: sides[0] }] : [],
+    ...percent(after) >= 1 ? [{ share: percent(after), side: sides[1] }] : []
+  ];
+  return cut.map(
+    (s, i) => i === 0 ? `a strip ${s.share}% ${depth} at its ${s.side}` : `${s.share}% at its ${s.side}`
+  );
+}
+function wordsFrame(frame, work, format) {
+  const down = stripsOf(frame.y / work.height, 1 - (frame.y + frame.height) / work.height, ["top", "bottom"], "deep");
+  const across2 = stripsOf(frame.x / work.width, 1 - (frame.x + frame.width) / work.width, ["left", "right"], "wide");
+  const strips = [down.join(" and "), across2.join(" and ")].filter(Boolean);
+  if (strips.length === 0) return "";
+  const many = down.length + across2.length > 1;
+  return `This picture is cut to ${format} afterwards: ${strips.join(", and ")} ${many ? "are" : "is"} cut away, so no word, logo or button comes near ${many ? "them" : "it"}.`;
+}
+function splitWordBoxes(boxes, copy, inScene) {
+  const logoWords = copy.filter((l) => /logo/i.test(l.role ?? "")).map((l) => l.text);
+  const read = withWordmark(boxes, logoWords);
+  const lines = copy.filter((l) => !/logo/i.test(l.role ?? ""));
+  const ours = new Set(lines.flatMap((line) => boxesOfLine(line, read)));
+  const unnamed = (b) => lines.length > 0 && b.kind === "text" && !ours.has(b);
+  const scene = /* @__PURE__ */ new Set([...inScene.flatMap((text) => boxesOfLine({ text }, read)), ...read.filter(unnamed)]);
+  const buttons = new Set(copy.filter(isButtonLine).flatMap((line) => boxesOfLine(line, read)));
+  return {
+    designed: read.filter((b) => !scene.has(b)).map((b) => buttons.has(b) ? buttonShape(b) : b),
+    inScene: read.filter((b) => scene.has(b))
+  };
+}
+function toFrame(b, frame, work) {
+  return {
+    ...b,
+    x0: (b.x0 * work.width - frame.x) / frame.width,
+    y0: (b.y0 * work.height - frame.y) / frame.height,
+    x1: (b.x1 * work.width - frame.x) / frame.width,
+    y1: (b.y1 * work.height - frame.y) / frame.height
+  };
+}
+function subjectIn(b, rect, plate) {
+  return {
+    ...b,
+    x0: (b.x0 * plate.width - rect.x) / rect.width,
+    y0: (b.y0 * plate.height - rect.y) / rect.height,
+    x1: (b.x1 * plate.width - rect.x) / rect.width,
+    y1: (b.y1 * plate.height - rect.y) / rect.height
+  };
+}
+var visible = (b) => b.x1 > 0 && b.y1 > 0 && b.x0 < 1 && b.y0 < 1;
+async function frameSize(plateBytes, crop, format) {
+  const delivered = deliveredSize(format);
+  const upscale = delivered.width / crop.rect.width;
+  const work = { width: Math.round(crop.render.width * upscale), height: Math.round(crop.render.height * upscale) };
+  const frame = {
+    x: Math.min(work.width - delivered.width, Math.max(0, Math.round((crop.rect.x - crop.render.x) * upscale))),
+    y: Math.min(work.height - delivered.height, Math.max(0, Math.round((crop.rect.y - crop.render.y) * upscale))),
+    width: delivered.width,
+    height: delivered.height
+  };
+  const region = { left: crop.render.x, top: crop.render.y, width: crop.render.width, height: crop.render.height };
+  const renderCut = await rawOf(await sharp2(plateBytes).extract(region).toBuffer(), work);
+  return { upscale, work, frame, renderCut, cutFrame: cropRaw(renderCut, frame) };
+}
+function slotOnWork(rect, frame, work) {
+  return {
+    x0: (frame.x + rect.x) / work.width,
+    y0: (frame.y + rect.y) / work.height,
+    x1: (frame.x + rect.x + rect.width) / work.width,
+    y1: (frame.y + rect.y + rect.height) / work.height
+  };
+}
+var LOGO_AVOIDS = /* @__PURE__ */ new Set(["person", "face", "product", "animal"]);
+var PLAIN_GROUND_SPREAD = 18;
+function sizeLogoSlot(params, frame, work, subjects, picture) {
+  if (!params.logo_slot) return void 0;
+  const avoid = subjects.filter((s) => LOGO_AVOIDS.has(s.kind)).map((s) => ({
+    x: Math.round(s.x0 * work.width - frame.x),
+    y: Math.round(s.y0 * work.height - frame.y),
+    width: Math.round((s.x1 - s.x0) * work.width),
+    height: Math.round((s.y1 - s.y0) * work.height)
+  }));
+  const size = { width: frame.width, height: frame.height };
+  const safe = blockingArea(params.format, params.placements);
+  const shape = {
+    aspect: params.logo_slot.aspect,
+    ...params.logo_slot.position ? { position: params.logo_slot.position } : {}
+  };
+  const spot = chooseLogoSpot(size, safe, {
+    ...shape,
+    subjects: avoid,
+    ...picture ? {
+      calm: (r) => spreadUnder(picture, r) <= PLAIN_GROUND_SPREAD,
+      crossesEdge: (r) => straightEdgeIn(picture, r)
+    } : {}
+  });
+  return spot?.slot ?? designerSpots(size, safe, shape)[0];
+}
+async function setWords(inputs, params, run, shown, again) {
+  const callParams = wordsCallParams(params.words, shown.ratio);
+  const prompt = [
+    callParams.prompt,
+    wordsAvoid(shown.faces),
+    wordsFrame(shown.frame, shown.work, params.format),
+    shown.logo ? logoSlotLine(slotOnWork(shown.logo.clear, shown.frame, shown.work), shown.logo.position) : "",
+    again
+  ].filter(Boolean).join("\n\n");
+  const references = [
+    ...inputs.previous && params.words.edit ? [inputs.previous] : [],
+    shown.cut,
+    ...[inputs.logo, inputs.type, inputs.style].filter((r) => r !== void 0),
+    ...inputs.refs ?? []
+  ];
+  const call = { ...callParams, prompt };
+  return await timedStep(
+    run,
+    again ? "words_again" : "words",
+    { params: call, references: references.map((r) => r.sha256) },
+    async (suffix, stepCtx) => {
+      const out = await callBackendExec({
+        nodeType: imageGenerateNode.id,
+        nodeVersion: imageGenerateNode.version,
+        params: imageGenerateNode.params.parse(call),
+        inputs: { reference: references },
+        outputKinds: { images: "image" },
+        ctx: stepCtx,
+        idempotencySuffix: suffix
+      });
+      const first = Array.isArray(out.images) ? out.images[0] : void 0;
+      if (!first) throw new Error("static_format: the words call returned no picture");
+      return first;
+    }
+  );
+}
+function wordsRead(reading, params) {
+  if (reading.status === "read") return splitWordBoxes(reading.boxes, params.copy ?? [], params.in_scene ?? []);
+  return { designed: [{ text: "", kind: "text", x0: 0, y0: 0, x1: 1, y1: 1 }], inScene: [] };
+}
+function liftWords(render, framing, words, subjects, params, keepOut = []) {
+  const faces = subjects.filter((b) => b.kind === "face");
+  const fit = registerToSource(render, framing.renderCut, words.read ? words.designed : []);
+  const misaligned = fit.residual > MISALIGNED;
+  const aligned = misaligned ? render : warpToCut(render, fit);
+  const { layer, reverted } = wordsLayer(aligned, framing.renderCut, words.designed, {
+    subjects,
+    keepOut: words.inScene,
+    boxesOnly: misaligned
+  });
+  const sized = cropLayer(layer, framing.frame);
+  const inFrame = (b) => toFrame(b, framing.frame, framing.work);
+  const frameFaces = faces.map(inFrame).filter(visible);
+  const frameWords = words.designed.map(inFrame).filter(visible);
+  const plan = words.read ? planWordsShift(frameWords, params.format, {
+    ...params.placements ? { placements: params.placements } : {},
+    ...params.band_min_scale !== void 0 ? { minScale: params.band_min_scale } : {},
+    // A move never takes words into the slot kept for the logo, nor is made for it: moving a block
+    // out of it cut its band through the letters (Cubicup 4:5, round 6); the logo goes elsewhere.
+    faces: frameFaces,
+    keepOut
+  }) : { moves: [] };
+  const { layer: placed2, covered } = protectFaces(
+    plan.moves.length > 0 ? moveLayer(sized, plan.moves) : sized,
+    frameFaces
+  );
+  const hidden = coveredSubjects(placed2, subjects.map(inFrame).filter(visible));
+  const reason = (words.read ? void 0 : "words_not_read") ?? plan.reason ?? (misaligned ? "words_misaligned" : void 0) ?? (covered > 0 ? "words_over_face" : void 0) ?? (hidden.length > 0 ? "subject_covered" : void 0);
+  return {
+    out: compose(framing.cutFrame, placed2),
+    alpha: placed2.alpha,
+    moves: plan.moves,
+    residual: fit.residual,
+    reverted,
+    covered: hidden,
+    ...reason ? { reason } : {}
+  };
+}
+async function alphaPng(alpha, width, height) {
+  return await sharp2(Buffer.from(alpha.map((a) => Math.round(a * 255))), { raw: { width, height, channels: 1 } }).png().toBuffer();
+}
+var round3 = (v) => Math.round(v * 1e3) / 1e3;
+var round1 = (v) => Math.round(v * 10) / 10;
+function liftedFacts(base, lifted, run) {
+  const reason = lifted.reason ?? (run.subjectsRead ? void 0 : "not_read");
+  return {
+    ...base,
+    ...reason ? { reason } : {},
+    ...lifted.covered.length > 0 ? { covered: lifted.covered } : {},
+    moves: lifted.moves.map(({ fit }) => ({ scale: round3(fit.scale), dx: round3(fit.dx), dy: round3(fit.dy) })),
+    residual: round1(lifted.residual),
+    reverted: round3(lifted.reverted),
+    identity: run.identity,
+    steps: run.steps
+  };
+}
+async function wordsTry(inputs, params, run, shown, again) {
+  const ref = await setWords(inputs, params, run, shown, again);
+  const { bytes } = await imageOf(ref, "static_format");
+  const reading = await timedStep(
+    run,
+    "boxes",
+    { render: ref.sha256 },
+    () => readTextBoxes(bytes, { onSpend: (u) => run.usage.push(u) }),
+    { keep: isRead }
+  );
+  return { ref, render: await rawOf(bytes, run.framing.work), reading };
+}
+function takeOf(t, run, subjects, params) {
+  const { framing } = run;
+  return takeWhole({
+    render: t.render,
+    cut: framing.renderCut,
+    frame: framing.frame,
+    words: t.reading.status === "read" ? splitWordBoxes(t.reading.boxes, params.copy ?? [], params.in_scene ?? []) : null,
+    subjects,
+    format: params.format,
+    ...params.placements ? { placements: params.placements } : {},
+    ...params.band_min_scale !== void 0 ? { minScale: params.band_min_scale } : {},
+    ...run.keepOut.length > 0 ? { keepOut: run.keepOut } : {}
+  });
+}
+var quoted = (what) => what.map((w) => `"${w}"`).join(", ");
+function setAgain(problem, what) {
+  const said = {
+    picture_moved: "Your last version moved or resized the picture to make room for the words. Keep Image 1 exactly where it is, at its size and framing; lay any band or card over its edge instead.",
+    subject_redrawn: `Your last version drew ${what.join(" and ") || "a person"} again, elsewhere or in another pose. Keep them exactly as Image 1 shows them, where they are, and set the words around them.`,
+    words_lost: `Your last version set ${quoted(what) || "words"} where this size is cut, the app's buttons cover them or the logo goes. Keep every word and the button inside the zones and out of the place kept plain for the logo.`,
+    words_over_face: "Your last version set words over a face. Keep every word, the logo and the button off every face."
+  };
+  return said[problem];
+}
+var MISPLACED = {
+  words_lost: "band_too_far",
+  words_over_face: "words_over_face"
+};
+async function wholeSize(take2, t, run, base, why = {}) {
+  const { retried } = why;
+  const image = await run.ctx.assets.ingestBytes({
+    bytes: await pngOf(take2.out),
+    kind: "image",
+    mime: "image/png"
+  });
+  const reason = (t.reading.status === "read" ? void 0 : "words_not_read") ?? (why.misplaced ? MISPLACED[why.misplaced] : void 0) ?? (take2.covered.length > 0 ? "subject_covered" : void 0) ?? (run.subjectsRead ? void 0 : "not_read");
+  const facts = {
+    ...base,
+    ...reason ? { reason } : {},
+    ...take2.covered.length > 0 ? { covered: take2.covered } : {},
+    words_mode: "whole",
+    kept: round3(take2.kept),
+    ...take2.restored.length > 0 ? { restored: take2.restored } : {},
+    ...retried ? { retried } : {},
+    moves: take2.moves.map(({ fit }) => ({ scale: round3(fit.scale), dx: round3(fit.dx), dy: round3(fit.dy) })),
+    residual: round1(take2.residual),
+    reverted: 0,
+    steps: run.steps
+  };
+  run.ctx.log(
+    `${base.format}: cut ${base.crop.width}x${base.crop.height} (x${base.upscale}), words whole${take2.moves.length > 0 ? ", moved" : ""}${take2.restored.length > 0 ? `, ${take2.restored.join(", ")} put back` : ""}${retried ? ` (set again: ${retried})` : ""}${reason ? `, ${reason}` : ""}`
+  );
+  return { image, cut: run.cut, words_raw: t.ref, facts };
+}
+async function maskedSize(t, run, base, subjects, params, why) {
+  const { framing } = run;
+  const lifted = liftWords(
+    t.render,
+    framing,
+    { ...wordsRead(t.reading, params), read: t.reading.status === "read" },
+    subjects,
+    params,
+    run.keepOut
+  );
+  const identity = identityOutside(lifted.out, framing.cutFrame, lifted.alpha);
+  if (identity !== 0) throw new Error(`static_format: the picture outside the words changed (${identity})`);
+  const [image, alpha] = await Promise.all([
+    run.ctx.assets.ingestBytes({ bytes: await pngOf(lifted.out), kind: "image", mime: "image/png" }),
+    run.ctx.assets.ingestBytes({
+      bytes: await alphaPng(lifted.alpha, framing.frame.width, framing.frame.height),
+      kind: "image",
+      mime: "image/png"
+    })
+  ]);
+  const facts = {
+    ...liftedFacts(base, lifted, { identity, steps: run.steps, subjectsRead: run.subjectsRead }),
+    words_mode: "masked",
+    retried: why.retried,
+    refused: why.refused
+  };
+  run.ctx.log(
+    `${base.format}: cut ${base.crop.width}x${base.crop.height} (x${base.upscale}), words set twice (${why.retried}, then ${why.refused}), only the words kept${lifted.moves.length > 0 ? ", moved" : ""}${facts.reason ? `, ${facts.reason}` : ""}`
+  );
+  return { image, cut: run.cut, words_raw: t.ref, words_alpha: alpha, facts };
+}
+async function formatSize(inputs, params, ctx) {
+  const { bytes: plateBytes, size: plate } = await imageOf(inputs.plate, "static_format");
+  const steps = [];
+  const usage = [];
+  const spend = () => usage.length > 0 ? { usage } : {};
+  const subjects = inputs.subjects ?? await subjectsStep({ ctx, steps, usage }, inputs.plate, plateBytes);
+  const ratios = supportedAspectRatios("image_generate", params.words.model);
+  const panels = platePanels(await rawOf(plateBytes, plate));
+  const crop = subjectCrop(plate, params.format, subjects, {
+    ...params.core ? { core: params.core } : {},
+    ...ratios ? { renderRatios: ratios } : {},
+    ...panels.length > 0 ? { panels } : {}
+  });
+  const framing = await frameSize(plateBytes, crop, params.format);
+  const cutRef = await ctx.assets.ingestBytes({
+    bytes: await pngOf(framing.cutFrame),
+    kind: "image",
+    mime: "image/png"
+  });
+  const base = {
+    format: params.format,
+    lead: params.lead ?? false,
+    plate,
+    crop: crop.rect,
+    render_ratio: crop.render.ratio,
+    upscale: round3(framing.upscale)
+  };
+  const shownSubjects = (subjects ?? []).map((s) => subjectIn(s, crop.render, plate)).filter(visible);
+  const logo = sizeLogoSlot(params, framing.frame, framing.work, shownSubjects, greyTable(framing.cutFrame));
+  const slotOut = logo ? { logo_slot: logo.rect } : {};
+  const elsewhere = (params.check_formats ?? []).filter((f) => f !== params.format).map((f) => ({ format: f, crop: subjectCrop(plate, f, subjects, params.core ? { core: params.core } : {}) })).find((c) => !c.crop.fits);
+  if (!crop.fits || elsewhere) {
+    const lost = crop.fits && elsewhere ? `${elsewhere.format}: ${elsewhere.crop.cut.join(", ")}` : crop.cut.join(", ");
+    ctx.log(`${params.format}: no cut keeps ${lost} whole; the words were not set`);
+    const facts = { ...base, reason: "subject_cut", moves: [], reverted: 0, identity: 0, steps };
+    return { image: cutRef, cut: cutRef, facts, ...slotOut, ...spend() };
+  }
+  const shownCut = await ctx.assets.ingestBytes({
+    bytes: await pngOf(framing.renderCut),
+    kind: "image",
+    mime: "image/png"
+  });
+  const keepOut = logo ? [
+    {
+      x0: logo.clear.x / framing.frame.width,
+      y0: logo.clear.y / framing.frame.height,
+      x1: (logo.clear.x + logo.clear.width) / framing.frame.width,
+      y1: (logo.clear.y + logo.clear.height) / framing.frame.height
+    }
+  ] : [];
+  const run = { ctx, steps, usage, subjectsRead: subjects !== null, cut: cutRef, framing, keepOut };
+  const shown = {
+    cut: shownCut,
+    ratio: crop.render.ratio,
+    faces: shownSubjects.filter((s) => s.kind === "face"),
+    frame: framing.frame,
+    work: framing.work,
+    ...logo ? { logo } : {}
+  };
+  return { ...await letter({ inputs, params, run, shown, base, subjects: shownSubjects }), ...slotOut, ...spend() };
+}
+async function letter(l) {
+  const { inputs, params, run, shown, base, subjects } = l;
+  const first = await wordsTry(inputs, params, run, shown);
+  const firstTake = takeOf(first, run, subjects, params);
+  if (firstTake.ok) return await wholeSize(firstTake, first, run, base);
+  const second = await wordsTry(inputs, params, run, shown, setAgain(firstTake.problem, firstTake.what));
+  const secondTake = takeOf(second, run, subjects, params);
+  const retried = firstTake.problem;
+  if (secondTake.ok) return await wholeSize(secondTake, second, run, base, { retried });
+  const placed2 = [
+    { take: secondTake, t: second },
+    { take: firstTake, t: first }
+  ].find((p) => p.take.whole);
+  const whole = placed2?.take.whole;
+  if (placed2 && whole) {
+    const taken = { ...whole, moves: [], kept: placed2.take.kept, residual: placed2.take.residual };
+    return await wholeSize(taken, placed2.t, run, base, { retried, misplaced: placed2.take.problem });
+  }
+  const kept = secondTake.kept >= firstTake.kept ? second : first;
+  return await maskedSize(kept, run, base, subjects, params, { retried, refused: secondTake.problem });
+}
+
+// src/engine/nodes/local/lib/size-consistency.ts
+import sharp3 from "sharp";
+import { z as z4 } from "zod";
+var SHOWN_AREA = 0.01;
+var SEEN_AREA = SHOWN_AREA / 3;
+var SAME_BOX = 0.3;
+var COUNTED = [
+  { kind: "person", name: "people" },
+  { kind: "face", name: "faces" },
+  { kind: "animal", name: "animals" }
+];
+var area = (b) => Math.max(0, b.x1 - b.x0) * Math.max(0, b.y1 - b.y0);
+function overlap2(a, b) {
+  const ix = Math.max(0, Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0));
+  const iy = Math.max(0, Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0));
+  const union = area(a) + area(b) - ix * iy;
+  return union > 0 ? ix * iy / union : 0;
+}
+function surely(image, kind) {
+  const [first = [], ...rest] = image.reads.map((r) => r.filter((b) => b.kind === kind));
+  return first.filter((b) => area(b) >= SHOWN_AREA && rest.every((r) => r.some((o) => overlap2(b, o) >= SAME_BOX)));
+}
+function atMost(image, kind) {
+  return Math.max(0, ...image.reads.map((r) => r.filter((b) => b.kind === kind && area(b) >= SEEN_AREA).length));
+}
+function boxDifferences(master, size) {
+  return COUNTED.flatMap(({ kind, name }) => {
+    const shown = surely(size, kind).length;
+    const shownBefore = atMost(master, kind);
+    if (shown > shownBefore) {
+      return [{ kind: "added", what: `shows ${shown} ${name} where the main size shows ${shownBefore}` }];
+    }
+    const before = surely(master, kind).length;
+    const now = atMost(size, kind);
+    if (before > now) return [{ kind: "missing", what: `shows ${now} ${name} where the main size shows ${before}` }];
+    return [];
+  });
+}
+var PAINTED = 0.6;
+function paintedSubjects(plate, paintedShare) {
+  const words = (label) => label.toLowerCase().match(new RegExp("\\p{L}{3,}", "gu")) ?? [];
+  const keptProducts = new Set(
+    surely(plate, "product").filter((b) => paintedShare(b) < PAINTED).flatMap((b) => words(b.label))
+  );
+  return ["person", "face", "animal", "product"].flatMap(
+    (kind) => surely(plate, kind).filter((b) => paintedShare(b) >= PAINTED).filter((b) => kind !== "product" || words(b.label).some((w) => keptProducts.has(w))).map((b) => b.label)
+  );
+}
+var SIZE_MATCH_PROMPT = [
+  "Image 1 is the main size of one static ad. Image 2 is the same ad made in another size. Image 2 may show more or less of the scene and lay the words out differently: that is expected and never a finding. Compare only the people, animals and products the two pictures show:",
+  "- people: Image 2 shows a different number of the ad's people than Image 1, or a different person where Image 1 has one (another face, age, gender or clothing).",
+  "- product: the product the ad is about (the thing sold or shown in use) is a different object in Image 2 (another model, shape, colour or label), or is missing from it.",
+  "- duplicated: Image 2 shows the same person, animal or product twice where Image 1 shows it once.",
+  "- stretched: a person, face or product in Image 2 is visibly stretched or squashed compared with Image 1 (wider or taller than it is).",
+  "- framed: Image 2 holds Image 1's picture as a smaller rectangle inside a bigger frame, with a visible edge, border or seam around it.",
+  "Someone in the far background, a crowd, and a prop a bigger frame shows more of are never findings. Say only what you see clearly at phone size; when unsure, it is the same.",
+  'Reply with only this JSON: {"people":"same|different","product":"same|different|missing|none","duplicated":"<what is shown twice>|null","stretched":"<who or what>|null","framed":true|false,"what":"<one short sentence naming what differs, or empty>"}'
+].join("\n");
+var SizeMatchAnswer = z4.object({
+  people: z4.enum(["same", "different"]),
+  product: z4.enum(["same", "different", "missing", "none"]),
+  duplicated: z4.string().nullable().optional(),
+  stretched: z4.string().nullable().optional(),
+  framed: z4.boolean()
+});
+var named = (text) => {
+  const t = text?.trim();
+  return t && t.toLowerCase() !== "null" ? t : null;
+};
+function sizeMatchFromAnswer(answer) {
+  const parsed = SizeMatchAnswer.safeParse(answer);
+  if (!parsed.success) return null;
+  const a = parsed.data;
+  const twice = named(a.duplicated);
+  const stretched = named(a.stretched);
+  return [
+    ...a.people === "different" ? [{ kind: "other_people", what: "shows other people than the main size" }] : [],
+    ...a.product === "different" ? [{ kind: "other_product", what: "shows another product than the main size" }] : a.product === "missing" ? [{ kind: "no_product", what: "no longer shows the product the main size shows" }] : [],
+    ...twice ? [{ kind: "duplicated", what: `shows ${twice} twice` }] : [],
+    ...stretched ? [{ kind: "stretched", what: `shows ${stretched} stretched or squashed` }] : [],
+    ...a.framed ? [{ kind: "framed", what: "shows the main size's picture boxed inside a bigger frame" }] : []
+  ];
+}
+var READS = 2;
+var MATCH_EDGE = 1024;
+async function readTwice(bytes, onSpend) {
+  const meta = await sharp3(bytes).metadata();
+  const reads = await Promise.all(Array.from({ length: READS }, () => readSubjectBoxes(bytes, { onSpend })));
+  const boxes = reads.flatMap((r) => r.status === "read" ? [r.boxes] : []);
+  return boxes.length === READS ? { size: { width: meta.width ?? 0, height: meta.height ?? 0 }, reads: boxes } : null;
+}
+var matchJpeg = async (bytes) => (await sharp3(bytes).resize(MATCH_EDGE, MATCH_EDGE, { fit: "inside", withoutEnlargement: true }).jpeg({ quality: 88 }).toBuffer()).toString("base64");
+var unique2 = (diffs) => diffs.filter((d, i) => diffs.findIndex((o) => o.what === d.what) === i);
+async function compareSizes(master, sizes, opts = {}) {
+  const masterBytes = await bytesOf(master.path);
+  const [masterReads, masterJpeg] = await Promise.all([readTwice(masterBytes, opts.onSpend), matchJpeg(masterBytes)]);
+  return await Promise.all(
+    sizes.map(async (size) => {
+      const bytes = await bytesOf(size.path);
+      const [reads, answer] = await Promise.all([
+        readTwice(bytes, opts.onSpend),
+        matchJpeg(bytes).then(
+          (jpeg) => askAboutImages(SIZE_MATCH_MODEL, [masterJpeg, jpeg], SIZE_MATCH_PROMPT, opts.onSpend, 6e4, {
+            effort: "low"
+          })
+        )
+      ]);
+      const boxed = masterReads && reads ? boxDifferences(masterReads, reads) : null;
+      const seen = sizeMatchFromAnswer(answer);
+      return {
+        format: size.format,
+        compared: boxed !== null || seen !== null,
+        differences: unique2([...boxed ?? [], ...seen ?? []])
+      };
+    })
+  );
+}
+function sizeDifferenceFinding(format, differences) {
+  const missing = differences.some((d) => d.kind === "missing" || d.kind === "no_product");
+  return {
+    severity: "blocking",
+    what: `${format}: ${differences.map((d) => d.what).join("; ")}. It must show the main size's people and product, once each, at their own proportions.`,
+    kind: { item: "sizes", element: "picture", defect: missing ? "missing" : "other", edges: [] }
+  };
+}
+
+export {
+  paintedSubjects,
+  readTwice,
+  compareSizes,
+  sizeDifferenceFinding,
+  registryParamShape,
+  imageGenerateNode,
+  subjectCrop,
+  boxesToPlace,
+  planSafeFit,
+  plainEdge,
+  minFitScale,
+  fitPicture,
+  registerToSource,
+  warpToCut,
+  MISALIGNED,
+  staticFormatNode,
+  splitWordBoxes
+};
+//# sourceMappingURL=chunk-JGSEHX2Q.js.map