@koda-sl/baker-cli 0.396.0-dev.88120240 → 0.397.0-dev.afb6a264b

package/dist/cli.js

@@ -62543,10 +62543,10 @@ function parseColor(raw) {
 function parseOklch(c) {
   const m = c.match(/oklch\(\s*([\d.]+%?)\s+([\d.]+%?)\s+([\d.]+)(?:deg)?(?:\s*\/\s*([\d.]+%?))?\s*\)/i);
   if (!m) return null;
-  const pct = (s, scale) => s.endsWith("%") ? Number.parseFloat(s) / 100 * scale : Number.parseFloat(s);
+  const pct2 = (s, scale) => s.endsWith("%") ? Number.parseFloat(s) / 100 * scale : Number.parseFloat(s);
   const alpha = m[4];
-  const a = alpha === void 0 ? 1 : pct(alpha, 1);
-  return { ...oklchToRgb(pct(m[1] ?? "0", 1), pct(m[2] ?? "0", 0.4), Number.parseFloat(m[3] ?? "0")), a };
+  const a = alpha === void 0 ? 1 : pct2(alpha, 1);
+  return { ...oklchToRgb(pct2(m[1] ?? "0", 1), pct2(m[2] ?? "0", 0.4), Number.parseFloat(m[3] ?? "0")), a };
 }
 function oklchToRgb(L, C, H) {
   const hRad = H * Math.PI / 180;
@@ -63920,6 +63920,36 @@ async function markInkIsLight(markPath) {
 
 // src/engine/scaffold/static-compose.ts
 import { z as z48 } from "zod";
+
+// src/engine/scaffold/static-formats.ts
+var CROP_TOLERANCE = 0.1;
+function ratioValue(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;
+}
+function ratioDelta(a, b) {
+  return Math.abs(ratioValue(a) / ratioValue(b) - 1);
+}
+function round3(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function planStaticFormats(genModel, formats) {
+  const first = formats[0];
+  if (!first) throw new Error("a static ad needs at least one format");
+  const plateRatio = nearestSupportedAspectRatio("image_generate", genModel, first);
+  return {
+    plateRatio,
+    formats: formats.map((format) => {
+      const delta = ratioDelta(format, plateRatio);
+      if (delta <= CROP_TOLERANCE) return { format, source: "crop", delta: round3(delta) };
+      const extendRatio = nearestSupportedAspectRatio("image_generate", genModel, format);
+      return { format, source: "extend", delta: round3(ratioDelta(format, extendRatio)), extendRatio };
+    })
+  };
+}
+
+// src/engine/scaffold/static-compose.ts
 var WinningMechanismSchema = z48.object({ kind: z48.string(), device: z48.string(), why_it_works: z48.string().optional() }).loose();
 function winningMechanisms(blueprint) {
   const raw = blueprint?.winning_mechanisms;
@@ -63954,7 +63984,31 @@ function copyEntries(blueprint) {
   return entries.flatMap((e) => {
     const text2 = typeof e?.text === "string" ? e.text.trim() : "";
     const role = normalize(e?.role);
-    return text2 && role !== "logo" ? [{ text: text2, role }] : [];
+    return text2 && role !== "logo" ? [
+      {
+        text: text2,
+        role,
+        treatment: normalize(e?.treatment),
+        surface: normalize(e?.surface),
+        placement: normalize(e?.placement)
+      }
+    ] : [];
+  });
+}
+var IN_SCENE_ROLES = /* @__PURE__ */ new Set(["in_scene", "scene", "ui", "screen", "screenshot", "packaging", "signage", "sign"]);
+var IN_SCENE_PLACEMENT = /\b(phone|screen|screenshot|app|packaging|package|bottle|jar|signage|signboard|handwritten|receipt|whiteboard|sticky note|notepad)\b/;
+function isInScene(entry) {
+  if (entry.surface === "in_scene") return true;
+  if (entry.surface === "overlay") return false;
+  return IN_SCENE_ROLES.has(entry.role) || IN_SCENE_PLACEMENT.test(entry.placement);
+}
+function inSceneText(blueprint) {
+  const raw = blueprint?.text_content;
+  const entries = Array.isArray(raw) ? raw : [];
+  return copyEntries(blueprint).filter(isInScene).map((entry) => {
+    const source = entries.find((e) => typeof e?.text === "string" && e.text.trim() === entry.text);
+    const placement = typeof source?.placement === "string" ? source.placement.trim() : "";
+    return { text: entry.text, placement };
   });
 }
 function pairCopy(blueprint) {
@@ -64022,6 +64076,9 @@ function hexOrNull(value2) {
 function ctaTextOf(blueprint) {
   return normalize(blueprint?.ad_signals?.cta?.text);
 }
+function conceptHasLogo(blueprint) {
+  return logoPlacement(blueprint) !== null;
+}
 function logoPlacement(blueprint) {
   const region = regionsOf(blueprint).find(isLogoRegion);
   if (region) return { band: bandOf(region, "top"), align: alignOf(void 0, region) };
@@ -64033,29 +64090,151 @@ function inkOn(background) {
   const luma = hexLuma(background);
   return luma !== null && luma > 150 ? "#111111" : "#ffffff";
 }
-function composeSpec(blueprint, brand) {
+function treatmentNamed(description) {
+  if (!description) return null;
+  if (/underline/.test(description)) return "underline";
+  if (/\b(button|pill|capsule)\b/.test(description)) return "button";
+  if (/arrow|→|->|chevron|›|»/.test(description)) return "arrow";
+  if (/sticker|starburst|stamp|seal|badge/.test(description)) return "sticker";
+  if (/highlight|marker|label|\btag\b|banner|ribbon|\bbox\b/.test(description)) return "highlight";
+  if (/rounded|rectangle/.test(description)) return "button";
+  if (/plain|\btext\b|\blink\b|\bnone\b/.test(description)) return "plain";
+  return null;
+}
+function shapeNamed(description) {
+  if (/pill|capsule/.test(description)) return "pill";
+  if (/round/.test(description)) return "rounded";
+  if (/square|sharp|rectangle/.test(description)) return "square";
+  return "rounded";
+}
+function ctaStyleOf(blueprint) {
+  return normalize(blueprint?.ad_signals?.cta?.style);
+}
+function treatmentOf(args8) {
+  const { entry, slot, role, brand } = args8;
+  const region = slot?.region;
+  const regionShape = [normalize(region?.shape), normalize(region?.notes)].join(" ").trim();
+  const descriptions = [
+    entry.treatment,
+    normalize(slot?.text.treatment),
+    ...role === "cta" ? [args8.ctaStyle, regionShape] : []
+  ];
+  let kind = "plain";
+  let described = "";
+  for (const description of descriptions) {
+    const named = treatmentNamed(description);
+    if (named) {
+      kind = named;
+      described = `${description} ${regionShape}`;
+      break;
+    }
+  }
+  if (kind === "plain" || kind === "underline" || kind === "arrow") return { kind };
+  const regionFill = hexOrNull(region?.background_color);
+  const background = kind === "button" ? hexOrNull(brand.ctaColor) ?? hexOrNull(brand.palette[0]) ?? regionFill ?? "#111111" : hexOrNull(brand.palette[1]) ?? hexOrNull(brand.palette[0]) ?? regionFill ?? "#111111";
+  return { kind, shape: shapeNamed(described), background, color: inkOn(background) };
+}
+function cover(from, to) {
+  return from > to ? { sx: from / to, sy: 1 } : { sx: 1, sy: to / from };
+}
+function contain(from, to) {
+  return from > to ? { sx: 1, sy: to / from } : { sx: from / to, sy: 1 };
+}
+var scaleSpan = ([a, b], k) => [(a - 0.5) * k + 0.5, (b - 0.5) * k + 0.5];
+function clampSpan([a, b], lo, hi) {
+  if (b - a >= hi - lo) return [lo, hi];
+  if (a < lo) return [lo, lo + (b - a)];
+  if (b > hi) return [hi - (b - a), hi];
+  return [a, b];
+}
+var pct = (n) => Math.round(n * 1e3) / 10;
+function placeRegion(x, y, geometry) {
+  let xs = [x[0] / 100, x[1] / 100];
+  let ys = [y[0] / 100, y[1] / 100];
+  const plate = geometry.plate;
+  if (plate) {
+    const format = ratioValue(geometry.format);
+    let from = ratioValue(plate.ratio);
+    if (plate.extendRatio) {
+      const extended = ratioValue(plate.extendRatio);
+      const fit = contain(from, extended);
+      xs = scaleSpan(xs, fit.sx);
+      ys = scaleSpan(ys, fit.sy);
+      from = extended;
+    }
+    const crop = cover(from, format);
+    xs = scaleSpan(xs, crop.sx);
+    ys = scaleSpan(ys, crop.sy);
+  }
+  const { safe } = geometry;
+  const [x0, x1] = clampSpan(xs, safe.left, 1 - safe.right);
+  const [y0, y1] = clampSpan(ys, safe.top, 1 - safe.bottom);
+  return { x: [pct(x0), pct(x1)], y: [pct(y0), pct(y1)] };
+}
+function regionId(region, index) {
+  const id = typeof region.id === "string" ? region.id.trim().replace(/[^A-Za-z0-9_-]+/g, "-") : "";
+  return `region-${id || index}`;
+}
+function distinctFrom(ground, candidates) {
+  return candidates.find((c) => c !== null && c !== ground) ?? inkOn(ground);
+}
+function composeSpec(blueprint, brand, options = {}) {
   const ctaText = ctaTextOf(blueprint);
-  const copy = pairCopy(blueprint).map(({ entry, slot }) => {
+  const ctaStyle = ctaStyleOf(blueprint);
+  const formats = options.formats ?? [];
+  const regions = regionsOf(blueprint);
+  const groups = /* @__PURE__ */ new Map();
+  const groupFor = (region, band, align) => {
+    const x = span(region?.x_pct);
+    const y = span(region?.y_pct);
+    const id = region && x && y ? regionId(region, regions.indexOf(region)) : `band-${band}`;
+    if (!groups.has(id)) {
+      const at = x && y ? Object.fromEntries(formats.map((g) => [g.format, placeRegion(x, y, g)])) : {};
+      groups.set(id, { id, band, align, at });
+    }
+    return id;
+  };
+  const ground = hexOrNull(brand.palette[0]) ?? "#111111";
+  const overlay = pairCopy(blueprint).filter(({ entry }) => !isInScene(entry));
+  const copy = overlay.map(({ entry, slot }) => {
     const role = roleOf(entry, ctaText);
     const region = slot?.region;
+    const band = bandOf(region, DEFAULT_BAND[role]);
+    const align = alignOf(slot?.text.align, region);
+    let treatment = treatmentOf({ entry, slot, role, ctaStyle, brand });
+    if (options.textOnly && "background" in treatment && treatment.background === ground) {
+      const background = distinctFrom(ground, [hexOrNull(brand.ctaColor), ...brand.palette.map(hexOrNull)]);
+      treatment = { ...treatment, background, color: inkOn(background) };
+    }
     return {
       role,
       // The source's line breaks fall elsewhere in our font: the composition wraps instead.
       text: entry.text.replace(/\s*\n\s*/g, " "),
-      band: bandOf(region, DEFAULT_BAND[role]),
-      align: alignOf(slot?.text.align, region),
+      band,
+      align,
       size: pick2(slot?.text.size, ["x_large", "large", "medium", "small"]) ?? DEFAULT_SIZE[role],
       weight: pick2(slot?.text.weight, ["bold", "semibold", "regular"]) ?? (role === "headline" ? "bold" : "regular"),
       case: pick2(slot?.text.case, ["upper", "title", "sentence"]),
-      color: hexOrNull(slot?.text.color)
+      // The source's ink was chosen for the source's picture; on our brand ground it is ours.
+      color: options.textOnly ? null : hexOrNull(slot?.text.color),
+      treatment,
+      group: groupFor(region, band, align)
     };
   });
+  const placement = options.logo ? logoPlacement(blueprint) : null;
+  const logoRegion = regions.find(isLogoRegion);
+  const logo = placement ? {
+    ...placement,
+    group: logoRegion && span(logoRegion.x_pct) && span(logoRegion.y_pct) ? groupFor(logoRegion, placement.band, placement.align) : null
+  } : null;
   const ctaBackground = hexOrNull(brand.ctaColor) ?? hexOrNull(brand.palette[0]) ?? "#111111";
   return {
     copy,
-    logo: logoPlacement(blueprint) ?? { band: "bottom", align: "center" },
+    logo,
+    groups: [...groups.values()],
     palette: brand.palette.flatMap((h) => hexOrNull(h) ?? []),
-    cta: { background: ctaBackground, color: inkOn(ctaBackground) }
+    cta: { background: ctaBackground, color: inkOn(ctaBackground) },
+    background: { color: ground, ink: inkOn(ground) }
   };
 }
 var SCENE_KEYS = [
@@ -64090,15 +64269,16 @@ function scrub(value2, names) {
   return value2;
 }
 var BAND_SPAN = { top: [4, 32], middle: [40, 60], bottom: [72, 96] };
-function reservedAreas(blueprint) {
+function reservedAreas(blueprint, logoDrawn2) {
   const areas = [];
   const seen = /* @__PURE__ */ new Set();
-  const logo = regionsOf(blueprint).find(isLogoRegion);
+  const logo = logoDrawn2 ? regionsOf(blueprint).find(isLogoRegion) : void 0;
   const logoX = span(logo?.x_pct);
   const logoY = span(logo?.y_pct);
   if (logo && logoX && logoY) areas.push({ for: "logo", x_pct: logoX, y_pct: logoY });
   const ctaText = ctaTextOf(blueprint);
   for (const { entry, slot } of pairCopy(blueprint)) {
+    if (isInScene(entry)) continue;
     const role = roleOf(entry, ctaText);
     const region = slot?.region;
     if (region && seen.has(region)) continue;
@@ -64113,19 +64293,25 @@ function reservedAreas(blueprint) {
   }
   return areas;
 }
-function platePlan(blueprint) {
+function platePlan(blueprint, options = {}) {
   const names = brandNames(blueprint);
   const source = blueprint ?? {};
   const scene = Object.fromEntries(SCENE_KEYS.flatMap((k) => k in source ? [[k, scrub(source[k], names)]] : []));
   const mechanisms = winningMechanisms(blueprint).filter((m) => normalize(m.kind) !== "verbal").map((m) => scrub(m, names));
-  return { scene, reserved_for_overlay: reservedAreas(blueprint), mechanisms_to_keep: mechanisms };
+  const inScene = inSceneText(blueprint);
+  return {
+    scene,
+    reserved_for_overlay: reservedAreas(blueprint, options.logo === true),
+    mechanisms_to_keep: mechanisms,
+    ...inScene.length > 0 ? { in_scene_text: inScene } : {}
+  };
 }
-function renderPlateSpec(blueprint) {
-  return `${JSON.stringify(platePlan(blueprint), null, 2)}
+function renderPlateSpec(blueprint, options = {}) {
+  return `${JSON.stringify(platePlan(blueprint, options), null, 2)}
 `;
 }
-function renderComposeSpec(blueprint, brand) {
-  return `${JSON.stringify(composeSpec(blueprint, brand), null, 2).replace(/</g, "\\u003c")}
+function renderComposeSpec(blueprint, brand, options = {}) {
+  return `${JSON.stringify(composeSpec(blueprint, brand, options), null, 2).replace(/</g, "\\u003c")}
 `;
 }
 
@@ -64282,6 +64468,66 @@ async function findWorkspaceRoot(start) {
     dir = parent;
   }
 }
+var snapshotsOf = (nodes) => nodes.filter((n) => n.type === "hyperframe_snapshot");
+var refId = (ref) => typeof ref === "string" ? ref.match(/^\$ref:([a-z][a-z0-9_]*)\./)?.[1] ?? null : null;
+async function isRealFile(file) {
+  if (typeof file !== "string" || file.includes("[TODO")) return false;
+  return stat(file).then(
+    (s) => s.isFile(),
+    () => false
+  );
+}
+async function releaseUnsuppliedLogo(canvas) {
+  const holder = canvas;
+  if (!Array.isArray(holder.nodes)) return false;
+  const nodes = holder.nodes;
+  const logoIds = new Set(snapshotsOf(nodes).flatMap((n) => refId(n.inputs?.logo) ?? []));
+  const empty = /* @__PURE__ */ new Set();
+  for (const id of logoIds) {
+    const node = nodes.find((n) => n.id === id && n.type === "ingest");
+    const p = node?.params;
+    if (p?.source === "path" && !await isRealFile(p.path)) empty.add(id);
+  }
+  if (empty.size === 0) return false;
+  for (const node of snapshotsOf(nodes)) {
+    const id = refId(node.inputs?.logo);
+    if (id && empty.has(id) && node.inputs) delete node.inputs.logo;
+  }
+  holder.nodes = nodes.filter((n) => !(typeof n.id === "string" && empty.has(n.id)));
+  return true;
+}
+function staticShape(nodes) {
+  const snapshots = snapshotsOf(nodes);
+  const formats = snapshots.flatMap((n) => {
+    const frame = n.params?.frame ?? {};
+    if (typeof frame.format !== "string") return [];
+    const safe = frame.safe;
+    if (!safe || typeof safe.top !== "number") return [];
+    const plate = frame.plate;
+    if (plate === void 0) return [];
+    return [
+      {
+        format: frame.format,
+        safe,
+        ...plate && typeof plate.ratio === "string" ? {
+          plate: {
+            ratio: plate.ratio,
+            ...typeof plate.extend_ratio === "string" ? { extendRatio: plate.extend_ratio } : {}
+          }
+        } : {}
+      }
+    ];
+  });
+  return {
+    logoWired: snapshots.some((n) => refId(n.inputs?.logo) !== null),
+    textOnly: snapshots.length > 0 && snapshots.every((n) => n.params?.frame?.plate === null),
+    formats
+  };
+}
+function composeOptionsFor(canvas, blueprint) {
+  const shape = staticShape(nodesOf(canvas));
+  return { logo: shape.logoWired && conceptHasLogo(blueprint), formats: shape.formats, textOnly: shape.textOnly };
+}
 async function syncStaticAdSpecs(canvas, log) {
   const nodes = nodesOf(canvas);
   const platePath = ingestPath(nodes, "plate_spec");
@@ -64291,6 +64537,10 @@ async function syncStaticAdSpecs(canvas, log) {
   const blueprint = JSON.parse(await readFile5(source, "utf8"));
   const root = await findWorkspaceRoot(path6.dirname(source));
   const brand = root ? await readStaticBrandKit(root) : { palette: [] };
+  if (await releaseUnsuppliedLogo(canvas)) {
+    log("[logo] the logo slot holds no real file, so the ad is drawn without a logo (Meta shows the page name and picture)");
+  }
+  const { logo, formats, textOnly } = composeOptionsFor(canvas, blueprint);
   let changed = 0;
   const write = async (file, content) => {
     if (!file) return;
@@ -64299,8 +64549,8 @@ async function syncStaticAdSpecs(canvas, log) {
     await writeFile2(file, content, "utf8");
     changed++;
   };
-  await write(platePath, renderPlateSpec(blueprint));
-  await write(composePath, renderComposeSpec(blueprint, brand));
+  await write(platePath, renderPlateSpec(blueprint, { logo }));
+  await write(composePath, renderComposeSpec(blueprint, brand, { logo, formats, textOnly }));
   if (changed === 0) return "up_to_date";
   log("[copy] prompt.plate.json and prompt.compose.json were re-derived from prompt.json");
   return "regenerated";
@@ -65075,12 +65325,12 @@ function spineClockFor(blueprint) {
     spineStarts.push(acc);
     acc += d;
   }
-  const totalS = round3(acc);
-  const startOf = (scene) => round3(spineStarts[scene] ?? totalS);
+  const totalS = round32(acc);
+  const startOf = (scene) => round32(spineStarts[scene] ?? totalS);
   const map = (scene, absS) => {
     const i = Math.min(Math.max(scene, 0), durs.length - 1);
     const delta = Math.min(Math.max(absS - refStarts[i], 0), durs[i]);
-    return round3(spineStarts[i] + delta);
+    return round32(spineStarts[i] + delta);
   };
   const mapAbs = (absS) => {
     let i = 0;
@@ -65089,7 +65339,7 @@ function spineClockFor(blueprint) {
   };
   return { startOf, map, mapAbs, totalS };
 }
-function round3(n) {
+function round32(n) {
   return Math.round(n * 1e3) / 1e3;
 }
 function canvasDims(ar) {
@@ -65796,9 +66046,9 @@ function ingestFrameRef(url, edge, ctx, nodes) {
   const cached = ctx.ingestCache?.get(url);
   if (cached) return cached;
   const tag = ctx.tag ?? "";
-  const refId = `s${ctx.sceneIndex}${tag}_${edge}_ref`;
-  nodes.push({ id: refId, type: "ingest", params: { source: "url", url, expect: "image" } });
-  const ref = `$ref:${refId}.asset`;
+  const refId2 = `s${ctx.sceneIndex}${tag}_${edge}_ref`;
+  nodes.push({ id: refId2, type: "ingest", params: { source: "url", url, expect: "image" } });
+  const ref = `$ref:${refId2}.asset`;
   ctx.ingestCache?.set(url, ref);
   return ref;
 }
@@ -66414,12 +66664,12 @@ function emitFlashHold(i, scene, slots, ctx, lengths, out, nodes, clips) {
 function emitScreenScene(i, scene, lengths, out, surfaceIngests, nodes, clips) {
   const regions = (scene.composition?.regions ?? []).filter((r) => Boolean(r) && typeof r === "object");
   const surfaceId = regions.find((r) => r.surface_id)?.surface_id;
-  let refId = surfaceId ? surfaceIngests.get(surfaceId) : void 0;
-  if (!refId) {
+  let refId2 = surfaceId ? surfaceIngests.get(surfaceId) : void 0;
+  if (!refId2) {
     const label = commentSafe((scene.summary || scene.start_frame_prompt || "the app screen").slice(0, 120));
-    refId = `s${i}_screen_ref`;
+    refId2 = `s${i}_screen_ref`;
     nodes.push({
-      id: refId,
+      id: refId2,
       type: "ingest",
       params: {
         source: "path",
@@ -66427,9 +66677,9 @@ function emitScreenScene(i, scene, lengths, out, surfaceIngests, nodes, clips) {
         expect: "image"
       }
     });
-    if (surfaceId) surfaceIngests.set(surfaceId, refId);
+    if (surfaceId) surfaceIngests.set(surfaceId, refId2);
   }
-  clips.push({ ref: `$ref:${refId}.asset`, scene_s: lengths.dur, out, still: { fit: "pad" } });
+  clips.push({ ref: `$ref:${refId2}.asset`, scene_s: lengths.dur, out, still: { fit: "pad" } });
 }
 function sceneIsAllGraphic(scene) {
   const regions = (scene.composition?.regions ?? []).filter((r) => Boolean(r) && typeof r === "object");
@@ -66466,12 +66716,12 @@ function fullFrameGraphicScenes(blueprint) {
 function emitGraphicScene(i, scene, lengths, out, surfaceIngests, nodes, clips) {
   const regions = (scene.composition?.regions ?? []).filter((r) => Boolean(r) && typeof r === "object");
   const surfaceId = regions.find((r) => r.surface_id)?.surface_id;
-  let refId = surfaceId ? surfaceIngests.get(surfaceId) : void 0;
-  if (!refId) {
+  let refId2 = surfaceId ? surfaceIngests.get(surfaceId) : void 0;
+  if (!refId2) {
     const label = commentSafe((scene.summary || scene.start_frame_prompt || "the designed panel").slice(0, 120));
-    refId = `s${i}_graphic_ref`;
+    refId2 = `s${i}_graphic_ref`;
     nodes.push({
-      id: refId,
+      id: refId2,
       type: "ingest",
       params: {
         source: "path",
@@ -66479,9 +66729,9 @@ function emitGraphicScene(i, scene, lengths, out, surfaceIngests, nodes, clips)
         expect: "image"
       }
     });
-    if (surfaceId) surfaceIngests.set(surfaceId, refId);
+    if (surfaceId) surfaceIngests.set(surfaceId, refId2);
   }
-  clips.push({ ref: `$ref:${refId}.asset`, scene_s: lengths.dur, out, still: { fit: "pad" } });
+  clips.push({ ref: `$ref:${refId2}.asset`, scene_s: lengths.dur, out, still: { fit: "pad" } });
 }
 var BRAND_CARD_RE = /\b(?:solid|plain|flat|brand|logo|wordmark|end[- ]?card|cta card|title card|colou?r background|background colou?r)\b/i;
 function sceneIsBrandCard(scene, present2, isCta) {
@@ -69624,23 +69874,36 @@ function staticVerdict(findings) {
   return findings.length > 0 ? "ready_with_notes" : "ready";
 }
 function buildStaticReviewPrompt(opts) {
-  const copy = opts.copy.length > 0 ? opts.copy.map((c) => `- "${c}"`).join("\n") : "(no copy was specified)";
   const brand = opts.brand ? ` for ${opts.brand}` : "";
+  const order = opts.formats.join(", ");
+  const shown = opts.thumbnails ? `These are the finished versions of ONE static advertisement${brand}, in this order: ${order}. After them come the same versions again, in the same order, shrunk to phone-feed thumbnail size (about 240px wide).` : `These are the finished versions of ONE static advertisement${brand}, in this order: ${order}.`;
+  const text2 = opts.copy.length > 0 ? [
+    "Read every word in every full-size image. The words must be exactly these strings, each shown once, spelled exactly:",
+    opts.copy.map((c) => `- "${c}"`).join("\n"),
+    "1. TEXT: a listed string misspelled, duplicated, garbled or absent, or extra words that are not in the list (a brand name inside a drawn logo is fine)."
+  ] : [
+    "This ad has no words on purpose: the picture is the ad. Do not report missing copy, a missing headline or a missing call to action.",
+    "1. TEXT: any letters or words that appear anyway (invented or garbled text is blocking)."
+  ];
+  const logo = opts.logo ? "2. LOGO: the brand logo distorted, cut off, or drawn more than once." : "2. LOGO: this ad carries no logo on purpose (the platform shows the brand's name and picture); never report a missing logo. A made-up logo or wordmark in the picture is blocking.";
+  const mechanisms = opts.mechanisms && opts.mechanisms.length > 0 ? [`8. CONCEPT: the ad no longer carries these devices it is built on (warning): ${opts.mechanisms.join("; ")}.`] : [];
   return [
-    `These are the finished versions of ONE static advertisement${brand}, in this order: ${opts.formats.join(", ")}.`,
-    "Read every word in every image. The copy must be exactly these strings, each shown once, spelled exactly:",
-    copy,
+    shown,
+    ...text2,
     "",
-    "Report, per image, only what is actually wrong:",
-    "1. TEXT: a copy string missing, misspelled, duplicated, garbled, or any extra words that are not in the list (a brand name inside the logo is fine).",
-    "2. LOGO: the brand logo missing, distorted, cut off, or drawn more than once.",
-    "3. LAYOUT: text or logo clipped by the frame edge, overlapping each other, or unreadable against the picture.",
+    "Report, per format, only what is actually wrong:",
+    logo,
+    "3. LAYOUT: anything the ad shows clipped by the frame edge, overlapping, or unreadable against what is behind it.",
     ...opts.drawnInSafeArea ? [] : [
-      "4. STORIES: on a 9:16 image, copy, logo or the call to action clearly inside the top 14% or the bottom 20% of the frame (measure it; an element that starts below the 14% line is fine)."
+      "4. STORIES: on a 9:16 image, text, a logo or a button that exists clearly inside the top 14% or the bottom 20% of the frame (measure it; an element that starts below the 14% line is fine)."
     ],
     "5. PICTURE: AI artifacts on people, animals or products (hands, faces, mouths, warped objects), visible seams or smears.",
-    "Blocking = it cannot ship as is (wrong or missing words, a broken logo, clipped copy, a malformed face or product). Warning = it can ship but should improve.",
-    "An empty list is the right answer for a clean ad. Keep each item under twenty words.",
+    "6. ONE IDEA: two or more elements compete equally for the eye, so no single promise leads (warning).",
+    opts.thumbnails ? "7. THUMBNAIL: at thumbnail size the dominant message (the lead line, or the hero when there are no words) cannot be read or understood in under two seconds. That is blocking: most people only ever see the ad that small." : "7. THUMBNAIL: the lead line would be unreadable on a phone feed. That is blocking.",
+    "BRAND: with the logo covered, nothing (colours, type, subject, format) says whose ad this is (warning).",
+    ...mechanisms,
+    "Blocking = it cannot ship as is (wrong or garbled words, a broken logo, clipped content, a malformed face or product, unreadable at thumbnail size). Warning = it can ship but should improve.",
+    "Never report an element as missing because ads usually have one: judge only what this concept holds. An empty list is the right answer for a clean ad. Keep each item under twenty words.",
     'Reply with only this JSON: {"findings":[{"severity":"blocking|warning","format":"4:5","what":"..."}]}'
   ].join("\n");
 }
@@ -69650,33 +69913,42 @@ async function bytesOf(source) {
   if (!res.ok) throw new Error(`fetch ${res.status}`);
   return Buffer.from(await res.arrayBuffer());
 }
-async function jpegFor(bytes) {
-  const jpeg = await sharp2(bytes).resize(1024, 1024, { fit: "inside", withoutEnlargement: true }).jpeg({ quality: 85 }).toBuffer();
+var THUMBNAIL_WIDTH = 240;
+async function jpegFor(bytes, width) {
+  const resized = width ? sharp2(bytes).resize({ width, withoutEnlargement: true }) : sharp2(bytes).resize(1024, 1024, { fit: "inside", withoutEnlargement: true });
+  const jpeg = await resized.jpeg({ quality: 85 }).toBuffer();
   return jpeg.toString("base64");
 }
 async function reviewRenderedStatic(opts) {
   const measured = [];
   const stills = [];
+  const thumbs = [];
   for (const image of opts.images) {
     try {
       const bytes = await bytesOf(image.path);
       const meta = await sharp2(bytes).metadata();
+      const still = await jpegFor(bytes);
+      const thumb = await jpegFor(bytes, THUMBNAIL_WIDTH);
       measured.push({ format: image.format, width: meta.width ?? 0, height: meta.height ?? 0 });
-      stills.push(await jpegFor(bytes));
+      stills.push(still);
+      thumbs.push(thumb);
     } catch {
     }
   }
   if (measured.length === 0) return null;
   const shape = ratioFindings(measured);
   const answer = await askAboutStills(
-    stills,
+    [...stills, ...thumbs],
     buildStaticReviewPrompt({
       copy: opts.copy,
       // `measured` grows in lockstep with `stills`, so an unreadable image drops out of
       // both and the model is never told a format it was not shown.
       formats: measured.map((m) => m.format),
       brand: opts.brand,
-      drawnInSafeArea: opts.drawnInSafeArea
+      drawnInSafeArea: opts.drawnInSafeArea,
+      logo: opts.logo,
+      thumbnails: true,
+      mechanisms: opts.mechanisms
     }),
     opts.onSpend
   );
@@ -69711,13 +69983,42 @@ function staticReviewTargets(parsed, output) {
     })
   };
 }
-function drawsCopy(parsed) {
+function nodesOf2(parsed) {
   const nodes = parsed?.nodes;
-  if (!Array.isArray(nodes)) return false;
-  return nodes.some((n) => {
-    const node = n;
-    return node.type === "hyperframe_snapshot" && node.params?.frame?.draw_copy === true;
-  });
+  return Array.isArray(nodes) ? nodes : [];
+}
+function staticRunShape(parsed) {
+  const nodes = nodesOf2(parsed);
+  const snapshots = nodes.filter((n) => n.type === "hyperframe_snapshot");
+  const pictures = nodes.filter(
+    (n) => n.type === "image_generate" && typeof n.id === "string" && /^plate(_[a-z])?$/.test(n.id)
+  ).length;
+  return {
+    pictures,
+    judged: nodes.some((n) => n.type === "image_select" && n.id === "pick"),
+    text: snapshots.some((n) => n.params?.frame?.draw_copy === true) ? "drawn" : "baked",
+    logo: snapshots.some((n) => typeof n.inputs?.logo === "string")
+  };
+}
+function drawsCopy(parsed) {
+  return nodesOf2(parsed).some((n) => n.type === "hyperframe_snapshot" && n.params?.frame?.draw_copy === true);
+}
+function shapeHint(shape, copy) {
+  const pictures = shape.pictures === 0 ? "no picture (a text-only ad)" : `${shape.pictures} picture${shape.pictures === 1 ? "" : "s"}${shape.judged ? ", judged" : ", no judge"}`;
+  const text2 = copy === 0 ? "no copy (the picture is the ad)" : `copy ${shape.text === "drawn" ? "drawn in real fonts" : "baked into the picture"}`;
+  return `This run: ${pictures}; ${text2}; ${shape.logo ? "the brand logo drawn" : "no logo"}.`;
+}
+async function drawsLogo(parsed) {
+  const compose = nodesOf2(parsed).find((n) => n.id === "compose_spec" && n.type === "ingest");
+  const file = compose?.params?.path;
+  if (typeof file === "string") {
+    try {
+      const spec = JSON.parse(await readFile17(file, "utf8"));
+      return spec.logo !== null && spec.logo !== void 0;
+    } catch {
+    }
+  }
+  return staticRunShape(parsed).logo;
 }
 async function textOf(ref) {
   const r = ref;
@@ -69738,15 +70039,21 @@ async function reviewStaticRun(opts) {
   const reasoning = await textOf(opts.outputsByNode.pick?.reasoning);
   const judge = reasoning ? parseJudgeScores(reasoning) : null;
   let copy = [];
+  let mechanisms = [];
   try {
-    copy = copyStrings(JSON.parse(await readFile17(targets.promptPath, "utf8")));
+    const blueprint = JSON.parse(await readFile17(targets.promptPath, "utf8"));
+    copy = copyStrings(blueprint);
+    mechanisms = winningMechanisms(blueprint).map((m) => m.device);
   } catch {
     copy = [];
   }
+  const shape = staticRunShape(opts.parsed);
   const review = await reviewRenderedStatic({
     images: targets.images,
     copy,
     drawnInSafeArea: drawsCopy(opts.parsed),
+    logo: await drawsLogo(opts.parsed),
+    mechanisms,
     onSpend: opts.onSpend
   });
   const verdict = staticVerdict(review);
@@ -69761,9 +70068,15 @@ async function reviewStaticRun(opts) {
     hints2.push("Reviewed every format of the finished ad: nothing to fix.");
   }
   for (const f of review ?? []) hints2.push(`${f.severity === "blocking" ? "Must fix" : "Should fix"}: ${f.what}`);
+  hints2.push(shapeHint(shape, copy.length));
   if (judge && judge.length > 0) {
     const best = [...judge].sort((a, b) => b.total - a.total)[0];
-    if (best) hints2.push(`The judge picked picture ${best.image} of ${judge.length} (${best.total}/30); the others stay in this run as alternates.`);
+    if (best) {
+      const max = Object.keys(best.scores).length * 5;
+      hints2.push(
+        `The judge picked picture ${best.image} of ${judge.length} (${best.total}/${max}); the others stay in this run as alternates.`
+      );
+    }
   }
   return { review, verdict, judge, hints: hints2 };
 }
@@ -70366,38 +70679,126 @@ import { access, mkdir as mkdir6, readFile as readFile20, writeFile as writeFile
 import path26 from "path";
 import { defineCommand as defineCommand134 } from "citty";
 
-// src/engine/scaffold/staticAd.ts
-import { z as z52 } from "zod";
-
-// src/engine/scaffold/static-formats.ts
-var CROP_TOLERANCE = 0.1;
-function ratioValue(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;
-}
-function ratioDelta(a, b) {
-  return Math.abs(ratioValue(a) / ratioValue(b) - 1);
+// src/engine/scaffold/static-fonts.ts
+import { marked } from "marked";
+var DEFAULT_FONTS = { headline: { family: "Inter", weight: 800 }, body: { family: "Inter", weight: 400 } };
+var HEADLINE_WORDS = /\b(headings?|headlines?|display|titles?|h[1-3])\b/i;
+var BODY_WORDS = /\b(body|paragraphs?|text|copy)\b/i;
+var PROHIBITION = /\b(never|don'?t|do not|avoid|instead of|ban(?:ned)?|no)\b/i;
+var NOT_FAMILIES = /* @__PURE__ */ new Set([
+  "system",
+  "system stack",
+  "sans",
+  "font",
+  "fonts",
+  "typography",
+  "typeface",
+  "weight",
+  "fallback"
+]);
+function isFamily(candidate) {
+  const name = candidate.trim();
+  const lower = name.toLowerCase();
+  if (name.length < 2 || !/^[A-Z0-9]/.test(name)) return false;
+  if (GENERIC_FAMILIES.has(lower) || NOT_FAMILIES.has(lower) || isNotAFamily(lower)) return false;
+  if (HEADLINE_WORDS.test(name) || BODY_WORDS.test(name)) return false;
+  return !/^#?[0-9a-f]{6}$/i.test(name) && !name.includes(":");
+}
+function familiesOn(line) {
+  const found = [];
+  for (const m of line.matchAll(/(\*\*|__|`|"|“|')([^*_`"”']{2,40}?)\1|“([^”]{2,40})”/g)) {
+    found.push((m[2] ?? m[3] ?? "").trim());
+  }
+  const labelled = line.match(
+    /\b(?:headings?|headlines?|display|titles?|body|text|font|typeface|family)\s*(?:font|face|typeface)?\s*[:=–-]\s*\**`?([A-Z][A-Za-z0-9]*(?: [A-Z][A-Za-z0-9]*){0,2})/
+  );
+  if (labelled?.[1]) found.push(labelled[1]);
+  return found.map((f) => f.replace(/\s+\d{3}$/, "").trim()).filter(isFamily);
 }
-function round32(n) {
-  return Math.round(n * 1e3) / 1e3;
+function typographySection(brandMd) {
+  const tokens = marked.lexer(brandMd);
+  const out = [];
+  let depth = null;
+  for (const token of tokens) {
+    if (token.type === "heading") {
+      if (depth !== null && token.depth <= depth) break;
+      if (depth === null && /typograph|fonts?\b|typefaces?/i.test(token.text)) {
+        depth = token.depth;
+        continue;
+      }
+    }
+    if (depth !== null) out.push(token.raw);
+  }
+  return out.join("\n");
 }
-function planStaticFormats(genModel, formats) {
-  const first = formats[0];
-  if (!first) throw new Error("a static ad needs at least one format");
-  const plateRatio = nearestSupportedAspectRatio("image_generate", genModel, first);
+function claimsIn(brandMd) {
+  return typographySection(brandMd).split("\n").filter((line) => !PROHIBITION.test(line)).map((line) => ({ families: familiesOn(line), headline: HEADLINE_WORDS.test(line), body: BODY_WORDS.test(line) })).filter((claim) => claim.families.length > 0);
+}
+function fromBrandMd(brandMd) {
+  const claims = claimsIn(brandMd);
+  const named = (family) => family ? { family, origin: "brand_md" } : void 0;
+  const loose = claims.filter((c) => !c.headline && !c.body).map((c) => c.families[0]);
+  const headlineClaim = claims.find((c) => c.headline);
+  const bodyClaim = claims.find((c) => c.body);
+  const bodyFamily = bodyClaim?.headline ? bodyClaim.families[1] ?? bodyClaim.families[0] : bodyClaim?.families[0];
+  const headline = named(headlineClaim?.families[0] ?? loose[0]);
+  const body = named(bodyFamily ?? loose[1] ?? loose[0]);
+  return { ...headline ? { headline } : {}, ...body ? { body } : {} };
+}
+function fromTokens2(tokensJson) {
+  let json;
+  try {
+    json = JSON.parse(tokensJson);
+  } catch {
+    return {};
+  }
+  const parsed = brandTokensSchema.safeParse(json);
+  if (!parsed.success) return {};
+  const heading = parsed.data.fonts.find((f) => f.role === "heading")?.family;
+  const body = parsed.data.fonts.find((f) => f.role === "body")?.family;
   return {
-    plateRatio,
-    formats: formats.map((format) => {
-      const delta = ratioDelta(format, plateRatio);
-      if (delta <= CROP_TOLERANCE) return { format, source: "crop", delta: round32(delta) };
-      const extendRatio = nearestSupportedAspectRatio("image_generate", genModel, format);
-      return { format, source: "extend", delta: round32(ratioDelta(format, extendRatio)), extendRatio };
-    })
+    ...heading ? { headline: { family: heading, origin: "tokens" } } : {},
+    ...body ? { body: { family: body, origin: "tokens" } } : {}
   };
 }
+function namedTypefaces(sources) {
+  const tokens = sources.tokensJson ? fromTokens2(sources.tokensJson) : {};
+  const doc = sources.brandMd ? fromBrandMd(sources.brandMd) : {};
+  const headline = tokens.headline ?? doc.headline;
+  const body = tokens.body ?? doc.body;
+  return { ...headline ? { headline } : {}, ...body ? { body } : {} };
+}
+function nearest(faces, weight) {
+  return [...faces].filter((f) => f.style === "normal").sort((a, b) => Math.abs(a.weight - weight) - Math.abs(b.weight - weight))[0];
+}
+async function webFontUrl(family, weight, deps) {
+  const first = await resolveBrandFaces(family, [weight], ["latin"], deps);
+  if (first.ok) return nearest(first.faces, weight)?.url ?? null;
+  if (first.reason !== "weight" || first.available.length === 0) return null;
+  const closest = [...first.available].sort((a, b) => Math.abs(a - weight) - Math.abs(b - weight))[0];
+  if (closest === void 0) return null;
+  const retry = await resolveBrandFaces(family, [closest], ["latin"], deps);
+  return retry.ok ? nearest(retry.faces, closest)?.url ?? null : null;
+}
+async function webFace(named, fallback, weight, resolveUrl) {
+  if (named) {
+    const url2 = await resolveUrl(named.family, weight);
+    if (url2) return { slot: { url: url2 }, family: named.family, origin: named.origin };
+  }
+  const url = await resolveUrl(fallback.family, fallback.weight);
+  return url ? { slot: { url }, family: fallback.family, origin: "default" } : null;
+}
+async function resolveStaticFonts(args8) {
+  const { files, named, resolveUrl } = args8;
+  const file = (p) => ({ slot: { path: p }, family: null, origin: "brand_file" });
+  const headline = files.headline ? file(files.headline) : await webFace(named.headline ?? named.body, DEFAULT_FONTS.headline, DEFAULT_FONTS.headline.weight, resolveUrl);
+  if (!headline) return null;
+  const body = files.body ? file(files.body) : files.headline ? headline : await webFace(named.body ?? named.headline, DEFAULT_FONTS.body, DEFAULT_FONTS.body.weight, resolveUrl) ?? headline;
+  return { headline, body };
+}
 
 // src/engine/scaffold/staticAd.ts
+import { z as z52 } from "zod";
 var GEN_ASPECT_RATIOS = /* @__PURE__ */ new Set(["1:1", "4:5", "9:16", "16:9", "4:3", "3:4", "2:3", "3:2", "21:9"]);
 var DEFAULT_ASPECT_RATIO = "9:16";
 var SHEET_SUBJECT_TYPE2 = {
@@ -70407,7 +70808,7 @@ var ACTOR_SHEET_MODEL2 = "google/gemini-3-pro-image";
 var ACTOR_SHEET_IMAGE_SIZE = "4K";
 var ADAPT_MODEL = "google/gemini-3-pro-image";
 var ADAPT_IMAGE_SIZE = "2K";
-var ADAPT_GUIDANCE = "Keep the headline, the call to action and the hero subject fully visible. Reproduce every text string verbatim, with no dropped, added, or altered characters, and preserve the exact brand-colour treatment. Draw no logo: it is placed afterwards.";
+var ADAPT_GUIDANCE = "Keep every line of text and the hero subject fully visible. Reproduce every text string verbatim, with no dropped, added, or altered characters, and preserve the exact colour treatment of each line. Draw no logo or wordmark.";
 var Blueprint = z52.object({
   meta: z52.object({ estimated_aspect_ratio: z52.string().optional() }).loose().optional(),
   text_content: z52.array(z52.object({ text: z52.string().optional() }).loose()).optional(),
@@ -70453,8 +70854,22 @@ function suppliedImage(el) {
   const url = typeof el.source_image === "string" ? el.source_image.trim() : "";
   return /^https?:\/\//i.test(url) ? url : void 0;
 }
-function staticTextMode(opts) {
-  return opts.brand?.headlineFontPath && !opts.bakeText ? "composed" : "baked";
+function overlayCopy(blueprint) {
+  return composeSpec(blueprint, { palette: [] }).copy.map((b) => b.text);
+}
+function staticMode(blueprint, opts) {
+  if (opts.textOnly) return "text_only";
+  if (overlayCopy(blueprint).length === 0) return "picture_only";
+  return opts.brand?.fonts && !opts.bakeText ? "composed" : "baked";
+}
+var plateTextOf = (mode) => mode === "baked" ? "baked" : "clean";
+function isTextForward(input) {
+  const blueprint = input;
+  const none = (v) => !Array.isArray(v) || v.length === 0;
+  return none(blueprint?.subjects) && none(blueprint?.people) && overlayCopy(input).length > 0;
+}
+function logoDrawn(blueprint, opts) {
+  return Boolean(opts.brand?.logoPath) && conceptHasLogo(blueprint);
 }
 function layoutDirFor(format) {
   return `./layout-${format.replace(":", "x")}`;
@@ -70480,27 +70895,29 @@ var TAKE_DIRECTIONS = [
   "Take C: a fresh camera angle and lighting that still fit the brief, same subject and palette."
 ];
 var PLATE_RULES = [
-  "This is a CLEAN PLATE for an advertisement: the picture only. The headline, the copy, the call to action and the logo are added afterwards by a designer, so:",
-  "- Render NO text of any kind: no letters, words, numbers, captions, labels, signage, packaging copy you invent, watermarks, UI, buttons or logos.",
+  "This is a CLEAN PLATE for an advertisement: the picture only. Whatever copy the ad carries is added afterwards by a designer, so:",
+  "- Render NO text of any kind: no letters, words, numbers, captions, labels, signage, packaging copy you invent, watermarks, UI, buttons or logos. The one exception is `in_scene_text`: each of those strings is written ON the object its placement names (a phone screen, a note, a sign, packaging), exactly once, spelled exactly.",
   "- Keep every area in `reserved_for_overlay` calm: an even, low-detail continuation of the background, with no subject, face, product or strong edge inside it.",
   "- Keep the hero subject and product whole and inside the frame, clear of those areas.",
   "- Rebuild each device in `mechanisms_to_keep`: it is why the reference ad works."
 ].join("\n");
 var JUDGE_RUBRIC = [
-  "You are judging candidate PLATES for a static ad: the picture before the copy and the logo are drawn on it.",
+  "You are judging candidate PLATES for a static ad: the picture before any copy is drawn on it. A winning static is ONE specific promise understood at a glance.",
   "Score every image 0-5 on each criterion:",
-  "- mechanism: rebuilds the devices in `mechanisms_to_keep` below (the reason the reference ad works).",
-  "- offer_space: the areas in `reserved_for_overlay` are calm enough for the offer to read in one second once the copy is drawn there.",
-  "- brand: the palette and the product or subject identity read as the brand's.",
+  "- idea: ONE dominant element carries the idea; nothing competes with it for the eye.",
+  "- thumbnail: shrunk to a phone feed thumbnail (about 240px wide), the dominant element still reads in under two seconds.",
+  "- mechanism: rebuilds the devices in `mechanisms_to_keep` below (the reason the reference ad works); 5 when the list is empty and the picture is on brief.",
+  "- offer_space: the areas in `reserved_for_overlay` are calm enough for what is drawn there to read in one second; 5 when the list is empty.",
+  "- brand: with any logo covered, the palette, the subject and the treatment still read as the brand's.",
   "- artifacts: no AI artifacts (hands, faces, mouths, warped products, seams, duplicated limbs); 5 means none.",
   "- safe_zones: the hero stays out of the outer top 14% and bottom 20% of the frame (Stories and Reels chrome).",
   "- text: {{text_rule}}",
-  'Begin `reasoning` with one line per image, exactly: "Image N: mechanism=x offer_space=x brand=x artifacts=x safe_zones=x text=x total=x" (total out of 30), then one sentence on why the winner won. Pick the highest total; break a tie on artifacts.',
+  'Begin `reasoning` with one line per image, exactly: "Image N: idea=x thumbnail=x mechanism=x offer_space=x brand=x artifacts=x safe_zones=x text=x total=x" (total out of 40), then one sentence on why the winner won. Pick the highest total; break a tie on artifacts.',
   "",
   "BRIEF:",
   "{{plate_spec}}"
 ].join("\n");
-var TEXT_RULE_COMPOSED = "the plate has no letters, words, logos or UI at all; any text is a 0.";
+var TEXT_RULE_COMPOSED = "no letters, words, logos or UI anywhere, except the strings in `in_scene_text`, each once and spelled exactly on the object it belongs to; any other text is a 0.";
 var TEXT_RULE_BAKED = "read every word in the image: the copy is exactly the strings the brief quotes, each once, spelled right; a missing, extra or misspelled word lowers the score.";
 function referenceLegend(slots, originalAsReference) {
   return [
@@ -70512,14 +70929,14 @@ function referenceLegend(slots, originalAsReference) {
 }
 function platePrompt(args8) {
   const exclusions = "Exclusions: no invented badges, icons, or seals; render exactly the subjects the blueprint names and no others; no competitor branding; no watermark.";
-  const head = args8.mode === "composed" ? [
+  const head = args8.mode === "clean" ? [
     "Render the picture for the advertisement described by the PLATE SPEC below. The `scene` is authoritative (subjects, expressions, palette, lighting, camera, style); follow its composition and leave the `reserved_for_overlay` areas free.",
     "",
     PLATE_RULES
   ] : [
     "Render the advertisement described by the TARGET BLUEPRINT below faithfully. The blueprint is authoritative \u2014 render exactly what it says (palette, expressions, intent, layout). Follow the blueprint's `layout` object for the global composition: reproduce the column/row grid, each region's position and size from its x_pct/y_pct bounds, the panel splits, and every text block at the relative size, weight, case, and alignment it specifies. Do not add brand logic, do not recolor on your own, do not invent any logo, badge, face, or product.",
     "",
-    "Leave the logo OUT: the brand's real logo file is placed on the finished ad afterwards, so draw no logo, wordmark or brand name anywhere."
+    "Leave any logo OUT: draw no logo, wordmark or brand name anywhere. When the ad carries a logo, the brand's real file is placed afterwards."
   ];
   const copyBlock = args8.mode === "baked" ? ["", COPY_DIRECTIVE_HEADER, textFidelityDirective(args8.copy, false), ""] : [""];
   return [
@@ -70536,15 +70953,15 @@ function platePrompt(args8) {
     "Match the palette hex precisely. Render each subject's expression and the ad's intent.",
     ...args8.exclusionsLast ? [] : ["", exclusions],
     "",
-    args8.mode === "composed" ? "PLATE SPEC:" : "TARGET BLUEPRINT:",
-    args8.mode === "composed" ? "{{plate_spec}}" : "{{target_blueprint}}",
+    args8.mode === "clean" ? "PLATE SPEC:" : "TARGET BLUEPRINT:",
+    args8.mode === "clean" ? "{{plate_spec}}" : "{{target_blueprint}}",
     ...args8.exclusionsLast ? ["", exclusions] : []
   ].join("\n");
 }
 function extensionPrompt(format, legend, hasElementRefs) {
   return [
     `Extend the picture in the FIRST reference image to a ${format} frame. It is the same photograph with more of the scene revealed: keep the subject, the product, their scale, the lighting, the colors and the camera exactly as they are, and continue the background naturally into the new area.`,
-    "Keep the new area calm and even: the ad copy is placed there afterwards. Render NO text, letters, logos, UI or watermarks anywhere.",
+    "Keep the new area calm and even: any ad copy is placed there afterwards. Keep text already written on objects in the picture exactly as it is, and add NO other text, letters, logos, UI or watermarks anywhere.",
     "Keep the hero whole and away from the outer top 14% and bottom 20% of the frame.",
     ...hasElementRefs ? ["", "The other references keep identities exact:", legend] : [],
     "",
@@ -70632,19 +71049,25 @@ function outputFormats(blueprint, opts) {
 function showsPerson(blueprint, elements) {
   return (blueprint.people?.length ?? 0) > 0 || elements.some(isPerson);
 }
-function elementNodes(elements, opts) {
+function elementNodes(elements, opts, drawLogo) {
   const includeActorSheets = opts.includeActorSheets !== false;
   const usedIds = /* @__PURE__ */ new Set(["prompt", "plate_spec", "compose_spec", "original", "pick", "final"]);
   const nodes = [];
   const slots = [];
+  const logoPath = drawLogo ? opts.brand?.logoPath : void 0;
   let logoRef;
-  assignElementLabels2(elements).forEach(({ el, label }, i) => {
-    const isLogo = el.type.toLowerCase() === "logo";
-    if (isLogo && logoRef) return;
+  const wanted = (isLogo) => isLogo ? !logoRef && Boolean(logoPath) : !opts.textOnly;
+  const freshId = (label, i) => {
     let id = sanitizeId2(`el_${label}`, `el_${i}`);
     while (usedIds.has(id)) id = `${id}_${i}`;
     usedIds.add(id);
-    nodes.push(elementIngest(id, el, label, isLogo ? opts.brand?.logoPath : void 0));
+    return id;
+  };
+  assignElementLabels2(elements).forEach(({ el, label }, i) => {
+    const isLogo = el.type.toLowerCase() === "logo";
+    if (!wanted(isLogo)) return;
+    const id = freshId(label, i);
+    nodes.push(elementIngest(id, el, label, isLogo ? logoPath : void 0));
     if (isLogo) {
       logoRef = `$ref:${id}.asset`;
       return;
@@ -70653,8 +71076,8 @@ function elementNodes(elements, opts) {
     if (sheet) nodes.push(sheet);
     slots.push({ ref: sheet ? `$ref:${sheet.id}.sheet` : `$ref:${id}.asset`, label, type: el.type });
   });
-  if (!logoRef && opts.brand?.logoPath) {
-    nodes.push(ingestNode("brand_logo", opts.brand.logoPath, "image"));
+  if (!logoRef && logoPath) {
+    nodes.push(ingestNode("brand_logo", logoPath, "image"));
     logoRef = "$ref:brand_logo.asset";
   }
   return { nodes, slots, logoRef };
@@ -70682,15 +71105,18 @@ function actorSheetNode(el, ingestId) {
     }
   };
 }
+function fontIngest(id, font) {
+  return "path" in font.slot ? ingestNode(id, font.slot.path, "font") : { id, type: "ingest", params: { source: "url", url: font.slot.url, expect: "font" } };
+}
+var slotKey = (font) => "path" in font.slot ? font.slot.path : font.slot.url;
 function fontNodes(brand) {
-  const headline = brand?.headlineFontPath;
-  if (!headline) return { nodes: [], refs: {} };
-  const nodes = [ingestNode("font_headline", headline, "font")];
-  const body = brand?.bodyFontPath;
-  if (!body || body === headline) {
+  const fonts = brand?.fonts;
+  if (!fonts) return { nodes: [], refs: {} };
+  const nodes = [fontIngest("font_headline", fonts.headline)];
+  if (slotKey(fonts.body) === slotKey(fonts.headline)) {
     return { nodes, refs: { font_headline: "$ref:font_headline.asset", font_body: "$ref:font_headline.asset" } };
   }
-  nodes.push(ingestNode("font_body", body, "font"));
+  nodes.push(fontIngest("font_body", fonts.body));
   return { nodes, refs: { font_headline: "$ref:font_headline.asset", font_body: "$ref:font_body.asset" } };
 }
 function renderParamsFor(genModel) {
@@ -70702,12 +71128,12 @@ function renderParamsFor(genModel) {
   };
 }
 function plateNodes(args8) {
-  const { blueprint, slots, opts, mode } = args8;
+  const { blueprint, slots, opts, text: text2 } = args8;
   const takes = takesFor(opts);
   const originalAsReference = !showsPerson(blueprint, args8.elements);
   const reference = [...slots.map((s) => s.ref), ...originalAsReference ? ["$ref:original.asset"] : []];
   const legend = referenceLegend(slots, originalAsReference);
-  const specInput = mode === "composed" ? { plate_spec: "$ref:plate_spec.asset" } : { target_blueprint: "$ref:prompt.asset" };
+  const specInput = text2 === "clean" ? { plate_spec: "$ref:plate_spec.asset" } : { target_blueprint: "$ref:prompt.asset" };
   const nodes = [];
   const ids = Array.from({ length: takes }, (_, t) => takes === 1 ? "plate" : `plate_${String.fromCharCode(97 + t)}`);
   ids.forEach((id, t) => {
@@ -70720,7 +71146,7 @@ function plateNodes(args8) {
         aspect_ratio: args8.plateRatio,
         ...renderParamsFor(opts.genModel),
         prompt: platePrompt({
-          mode,
+          mode: text2,
           copy: copyStrings(blueprint),
           take: TAKE_DIRECTIONS[t] ?? "",
           legend,
@@ -70737,18 +71163,19 @@ function plateNodes(args8) {
     type: "image_select",
     inputs: {
       images: ids.map((id) => `$ref:${id}.images#0`),
-      plate_spec: mode === "composed" ? "$ref:plate_spec.asset" : "$ref:prompt.asset"
+      plate_spec: text2 === "clean" ? "$ref:plate_spec.asset" : "$ref:prompt.asset"
     },
     params: {
       model: JUDGE_MODEL,
       count: 1,
       temperature: 0,
-      prompt: JUDGE_RUBRIC.replace("{{text_rule}}", mode === "composed" ? TEXT_RULE_COMPOSED : TEXT_RULE_BAKED)
+      prompt: JUDGE_RUBRIC.replace("{{text_rule}}", text2 === "clean" ? TEXT_RULE_COMPOSED : TEXT_RULE_BAKED)
     }
   });
   return { nodes, chosen: "$ref:pick.images#0" };
 }
 function takesFor(opts) {
+  if (opts.textOnly) return 0;
   return Math.max(1, Math.min(TAKE_DIRECTIONS.length, opts.takes ?? TAKE_DIRECTIONS.length));
 }
 function bakedAdaptNode(plan, chosen) {
@@ -70764,72 +71191,151 @@ function bakedAdaptNode(plan, chosen) {
     }
   };
 }
+function snapshotNode(args8) {
+  const slug = args8.format.replace(":", "x");
+  return {
+    id: `ad_${slug}`,
+    type: "hyperframe_snapshot",
+    inputs: {
+      ...args8.plateRef ? { plate: args8.plateRef } : {},
+      compose: "$ref:compose_spec.asset",
+      ...args8.logoRef ? { logo: args8.logoRef } : {},
+      ...args8.fontRefs
+    },
+    params: {
+      composition: layoutDirFor(args8.format),
+      wait_for: { kind: "selector", value: "#root[data-ready='1']" },
+      ad: "{{compose}}",
+      // `plate` tells the composition (and the run-time layout pass) which picture this
+      // format is cut from, so each line lands where the source layout put it; null means
+      // there is no picture at all.
+      // `fonts` says whether any face is staged: one declared but never staged is a 404.
+      frame: {
+        format: args8.format,
+        safe: safeAreaFor(args8.format),
+        draw_copy: args8.drawCopy,
+        plate: args8.plate,
+        fonts: Object.keys(args8.fontRefs).length > 0
+      }
+    }
+  };
+}
+function extendNode(entry, chosen, slots, genModel) {
+  if (entry.source !== "extend" || !entry.extendRatio) return null;
+  return {
+    id: `extend_${entry.format.replace(":", "x")}`,
+    type: "image_generate",
+    inputs: { reference: [chosen, ...slots.map((s) => s.ref)], plate_spec: "$ref:plate_spec.asset" },
+    params: {
+      model: genModel,
+      aspect_ratio: entry.extendRatio,
+      ...renderParamsFor(genModel),
+      prompt: extensionPrompt(entry.format, referenceLegend(slots, false), slots.length > 0)
+    }
+  };
+}
+function formatSource(args8) {
+  const { entry, plan, adapt, chosen } = args8;
+  if (!chosen) return { plateRef: null, plate: null, extend: null };
+  const adapted = adapt ? adapt.formats.indexOf(entry.format) : -1;
+  if (adapted >= 0) return { plateRef: `$ref:adapt.images#${adapted}`, plate: { ratio: entry.format }, extend: null };
+  const extend = args8.mode !== "baked" ? extendNode(entry, chosen, args8.slots, args8.genModel) : null;
+  if (!extend) return { plateRef: chosen, plate: { ratio: plan.plateRatio }, extend: null };
+  return {
+    plateRef: `$ref:${extend.id}.images#0`,
+    plate: { ratio: plan.plateRatio, extend_ratio: String(extend.params?.aspect_ratio) },
+    extend
+  };
+}
 function formatNodes(args8) {
   const { plan, mode, chosen, slots } = args8;
   const nodes = [];
   const layoutIds = [];
-  const adapt = mode === "baked" ? bakedAdaptNode(plan, chosen) : null;
+  const adapt = mode === "baked" && chosen ? bakedAdaptNode(plan, chosen) : null;
   if (adapt) nodes.push(adapt.node);
   for (const entry of plan.formats) {
     const slug = entry.format.replace(":", "x");
-    const adapted = adapt ? adapt.formats.indexOf(entry.format) : -1;
-    let plateRef = adapted >= 0 ? `$ref:adapt.images#${adapted}` : chosen;
-    if (entry.source === "extend" && mode === "composed" && entry.extendRatio) {
-      nodes.push({
-        id: `extend_${slug}`,
-        type: "image_generate",
-        inputs: { reference: [chosen, ...slots.map((s) => s.ref)], plate_spec: "$ref:plate_spec.asset" },
-        params: {
-          model: args8.genModel,
-          aspect_ratio: entry.extendRatio,
-          ...renderParamsFor(args8.genModel),
-          prompt: extensionPrompt(entry.format, referenceLegend(slots, false), slots.length > 0)
-        }
-      });
-      plateRef = `$ref:extend_${slug}.images#0`;
-    }
-    layoutIds.push(`ad_${slug}`);
-    nodes.push({
-      id: `ad_${slug}`,
-      type: "hyperframe_snapshot",
-      inputs: {
-        plate: plateRef,
-        compose: "$ref:compose_spec.asset",
-        ...args8.logoRef ? { logo: args8.logoRef } : {},
-        ...args8.fontRefs
-      },
-      params: {
-        composition: layoutDirFor(entry.format),
-        wait_for: { kind: "selector", value: "#root[data-ready='1']" },
-        ad: "{{compose}}",
-        frame: {
-          format: entry.format,
-          safe: safeAreaFor(entry.format),
-          draw_copy: mode === "composed"
-        }
-      }
+    const { plateRef, plate, extend } = formatSource({
+      entry,
+      plan,
+      adapt,
+      chosen,
+      mode,
+      slots,
+      genModel: args8.genModel
     });
+    if (extend) nodes.push(extend);
+    layoutIds.push(`ad_${slug}`);
+    nodes.push(
+      snapshotNode({
+        format: entry.format,
+        plateRef,
+        plate,
+        drawCopy: mode !== "baked",
+        logoRef: args8.logoRef,
+        fontRefs: args8.fontRefs
+      })
+    );
   }
   return { nodes, layoutIds };
 }
+function fontLabel(font) {
+  const origin = {
+    brand_file: "the brand's font file",
+    tokens: "named in tokens.json, loaded as a web font",
+    brand_md: "named in BRAND.md, loaded as a web font",
+    default: "the default, since the brand names no typeface"
+  };
+  const name = font.family ?? ("path" in font.slot ? font.slot.path.split("/").pop() ?? font.slot.path : "a web font");
+  return `${name} (${origin[font.origin]})`;
+}
+function describeText(mode, fonts) {
+  if (mode === "picture_only") return "The ad has no copy: the picture is the ad, with nothing drawn on it.";
+  if (mode === "baked") {
+    return "The copy is baked into the picture by the image model (no font could be loaded, or --skip-font).";
+  }
+  if (!fonts) return "The copy is drawn from prompt.json in a fallback system face.";
+  const oneFace = slotKey(fonts.body) === slotKey(fonts.headline) || fonts.body.family !== null && fonts.body.family === fonts.headline.family;
+  const body = oneFace ? "" : ` and ${fontLabel(fonts.body)}`;
+  return `The copy is drawn from prompt.json in ${fontLabel(fonts.headline)}${body}.`;
+}
+function describeRun(args8) {
+  const { mode, takes, logo } = args8;
+  const numbers = ["No", "One", "Two", "Three"];
+  const pictures = mode === "text_only" ? "No picture is generated: every format is the copy drawn on the brand's colours." : takes > 1 ? `${numbers[takes] ?? takes} pictures are rendered and a judge picks one; every format is cut from it.` : "One picture is rendered (no judge); every format is cut from it.";
+  const text2 = describeText(mode, args8.brand?.fonts);
+  const scene = args8.inScene > 0 ? ` ${args8.inScene} line(s) written on something in the scene are painted into the picture.` : "";
+  const mark = logo ? " The brand's logo file is drawn where the concept places it." : " No logo is drawn: the concept has none, or the brand has no logo file (Meta shows the page name and picture on every ad).";
+  return `${pictures} ${text2}${scene}${mark}`;
+}
 function scaffoldStaticAd(input, elementsInput, opts) {
   const blueprint = Blueprint.parse(input);
   const elements = MainElements.parse(elementsInput);
-  const mode = staticTextMode(opts);
+  const mode = staticMode(blueprint, opts);
   const plan = planStaticFormats(opts.genModel, outputFormats(blueprint, opts));
+  const drawLogo = logoDrawn(blueprint, opts);
   const spine = [
     ingestNode("prompt", opts.blueprintPath ?? "./prompt.json", "json"),
-    ...mode === "composed" ? [ingestNode("plate_spec", PLATE_SPEC_PATH, "json")] : [],
+    ...mode === "composed" || mode === "picture_only" ? [ingestNode("plate_spec", PLATE_SPEC_PATH, "json")] : [],
     ingestNode("compose_spec", COMPOSE_SPEC_PATH, "json"),
-    {
-      id: "original",
-      type: "ingest",
-      params: opts.imageIsUrl ? { source: "url", url: opts.imagePath, expect: "image" } : { source: "path", path: opts.imagePath, expect: "image" }
-    }
+    ...mode === "text_only" ? [] : [
+      {
+        id: "original",
+        type: "ingest",
+        params: opts.imageIsUrl ? { source: "url", url: opts.imagePath, expect: "image" } : { source: "path", path: opts.imagePath, expect: "image" }
+      }
+    ]
   ];
-  const els = elementNodes(elements, opts);
-  const fonts = mode === "composed" ? fontNodes(opts.brand) : { nodes: [], refs: {} };
-  const plates = plateNodes({ blueprint, elements, slots: els.slots, opts, mode, plateRatio: plan.plateRatio });
+  const els = elementNodes(elements, opts, drawLogo);
+  const fonts = mode === "baked" ? { nodes: [], refs: {} } : fontNodes(opts.brand);
+  const plates = mode === "text_only" ? { nodes: [], chosen: null } : plateNodes({
+    blueprint,
+    elements,
+    slots: els.slots,
+    opts,
+    text: plateTextOf(mode),
+    plateRatio: plan.plateRatio
+  });
   const formats = formatNodes({
     plan,
     mode,
@@ -70843,7 +71349,9 @@ function scaffoldStaticAd(input, elementsInput, opts) {
     schema: "baker-canvas/1",
     metadata: {
       name: "static ad reproduction",
-      description: "Scaffolded by `baker canvas scaffold-static-ad`. Edit `prompt.json` (the blueprint generated from the source image) into the ad you want; the copy, the CTA and the layout are read from it on every run. Drop a real asset at each [TODO] ingest path, then `baker canvas run`. Three plates are rendered and judged, and every format is drawn from the winner with the brand's own fonts and logo."
+      description: `Scaffolded by \`baker canvas scaffold-static-ad\`. Edit \`prompt.json\` (the blueprint generated from the source image) into the ad you want; the copy and the layout are read from it on every run, and only what it holds is drawn. Drop a real asset at each [TODO] ingest path, then \`baker canvas run\`. ${describeRun(
+        { mode, takes: takesFor(opts), logo: drawLogo, brand: opts.brand, inScene: inSceneText(blueprint).length }
+      )}`
     },
     nodes: [
       ...spine,
@@ -70861,26 +71369,45 @@ function scaffoldStaticAd(input, elementsInput, opts) {
     output: { node: "final", output: "images" }
   };
 }
+function logoWhy(blueprint, opts) {
+  if (!conceptHasLogo(blueprint)) {
+    return "The concept shows no logo, so none is drawn: Meta shows the page name and picture on every ad.";
+  }
+  if (!opts.brand?.logoPath) {
+    return "The concept shows a logo but src/brand/logos/ has no real logo file, so none is drawn (never a stand-in). Add the file and re-scaffold to have it drawn.";
+  }
+  return `The brand logo ${opts.brand.logoPath} is drawn where the concept places it, never generated.`;
+}
 function staticAdReport(input, elementsInput, opts) {
   const blueprint = Blueprint.parse(input);
   const elements = MainElements.parse(elementsInput);
   const includeActorSheets = opts.includeActorSheets !== false;
   const plan = planStaticFormats(opts.genModel, outputFormats(blueprint, opts));
+  const mode = staticMode(blueprint, opts);
+  const drawLogo = logoDrawn(blueprint, opts);
+  const takes = takesFor(opts);
+  const fonts = mode !== "baked" ? opts.brand?.fonts : void 0;
+  const inScene = inSceneText(blueprint).map((t) => t.text);
   return {
     element_count: elements.length,
     elements: assignElementLabels2(elements).map(({ el, label }) => ({
       label,
       type: el.type,
       description: el.description ?? null,
-      asset_todo: suppliedImage(el) ? "none \u2014 cast from a company Avatar's identity sheet" : el.type.toLowerCase() === "logo" && opts.brand?.logoPath ? `none \u2014 the brand logo ${opts.brand.logoPath} is drawn by the composition` : todoPath2(el, label)
+      asset_todo: suppliedImage(el) ? "none: cast from a company Avatar's identity sheet" : el.type.toLowerCase() === "logo" ? drawLogo ? `none: the brand logo ${opts.brand?.logoPath} is drawn by the composition` : "none: no logo is drawn (the logo is optional)" : opts.textOnly ? "none: a text-only ad generates no picture" : todoPath2(el, label)
     })),
-    text_mode: staticTextMode(opts),
-    actor_sheets: includeActorSheets ? assignElementLabels2(elements).filter(({ el }) => SHEET_SUBJECT_TYPE2[el.type.toLowerCase()]).map(({ label }) => label) : [],
+    mode,
+    summary: describeRun({ mode, takes, logo: drawLogo, brand: opts.brand, inScene: inScene.length }),
+    fonts: fonts ? { headline: fontLabel(fonts.headline), body: fontLabel(fonts.body) } : null,
+    logo: { drawn: drawLogo, why: logoWhy(blueprint, opts) },
+    in_scene_text: mode === "text_only" ? [] : inScene,
+    actor_sheets: includeActorSheets && !opts.textOnly ? assignElementLabels2(elements).filter(({ el }) => SHEET_SUBJECT_TYPE2[el.type.toLowerCase()]).map(({ label }) => label) : [],
     aspect_ratio: plan.plateRatio,
     placements: opts.placements ?? null,
     output_formats: plan.formats.map((f) => f.format),
     format_plan: plan.formats,
-    takes: takesFor(opts),
+    takes,
+    judged: takes > 1,
     winning_mechanisms: winningMechanisms(blueprint),
     describe_gaps: describeGaps(blueprint)
   };
@@ -71192,6 +71719,46 @@ async function uploadSourceAsReference(source, isUrl, client) {
   if (!putRes.ok) throw new Error(`source upload failed (${putRes.status})`);
   return publicUrl;
 }
+async function brandFaces(root, kit, toCanvas) {
+  const read = (file) => readFile20(path26.join(root, BRAND_DIR, file), "utf8").catch(() => null);
+  const named = namedTypefaces({ tokensJson: await read("tokens.json"), brandMd: await read("BRAND.md") });
+  const fonts = await resolveStaticFonts({
+    files: { headline: kit.headlineFont, body: kit.bodyFont },
+    named,
+    resolveUrl: (family, weight) => webFontUrl(family, weight, { lookupGoogleCss, fetchJson })
+  });
+  if (!fonts) return null;
+  const local = (font) => "path" in font.slot ? { ...font, slot: { path: toCanvas(font.slot.path) } } : font;
+  return { headline: local(fonts.headline), body: local(fonts.body) };
+}
+function staticTextNote(report, bakeText) {
+  const faces = !report.fonts ? "a fallback system face" : report.fonts.headline === report.fonts.body ? report.fonts.headline : `${report.fonts.headline} / ${report.fonts.body}`;
+  switch (report.mode) {
+    case "composed":
+      return `The copy is DRAWN, not generated: each line of text_content in prompt.json (minus the logo and any text written in the scene) is set in ${faces} where the source layout put it, styled the way the reference styled it. A call to action stays plain, underlined, an arrow or a button as the reference had it (role "cta", and a "treatment" to change it); nothing is added that prompt.json does not hold. Edit the copy in prompt.json; every run reads it again.`;
+    case "picture_only":
+      return "The concept has no copy: the picture is the ad, with nothing drawn on it. Add lines to text_content in prompt.json to draw copy.";
+    case "text_only":
+      return `Text-only: no picture is generated. Every line of prompt.json is drawn on the brand's colours in ${faces}. Pass --no-text-only to render a picture instead.`;
+    default:
+      return bakeText ? "The copy is baked into the picture (--skip-font). Re-read every word on every format before publishing." : "The copy is baked into the picture because no font could be loaded: no file in src/brand/fonts/, and neither the typeface the brand names nor the default web font could be fetched. Re-read every word before publishing.";
+  }
+}
+function staticFormatsNote(report, genModel) {
+  const set = report.placements === null ? " Pass --placements meta_feed_stories|meta_all|linkedin|\u2026 for a platform's set." : "";
+  if (report.mode === "text_only") {
+    return `Delivers ${report.output_formats.join(", ")}, each drawn directly at its exact size (no picture).${set}`;
+  }
+  const how = report.format_plan.map((f) => {
+    if (f.format === report.aspect_ratio) return `${f.format} is the picture itself`;
+    if (report.mode === "baked") {
+      return `${f.format} is re-framed from the chosen picture by Nano Banana Pro (one billed render; the copy is in the pixels, so it is never cropped)`;
+    }
+    return f.source === "crop" ? `${f.format} is a free crop of it` : `${f.format} extends the chosen picture to ${f.extendRatio} (one billed render) and crops the rest`;
+  }).join("; ");
+  const drawn = report.mode === "composed" ? " Nothing re-paints the copy or the logo." : "";
+  return `Delivers ${report.output_formats.join(", ")}, each at its exact size. The pictures render at ${report.aspect_ratio} (the nearest shape ${genModel} renders); ${how}.${drawn}${set}`;
+}
 function resolveModel(kind, preferred) {
   const ids = Object.keys(MODEL_REGISTRY[kind]);
   return ids.includes(preferred) ? preferred : ids[0] ?? preferred;
@@ -71212,7 +71779,7 @@ Return a JSON object describing the GLOBAL LAYOUT of the frame precisely enough
     "content": what is here (name the subject/badge; reuse its description),
     "background_color": hex or null,
     "shape": e.g. "rounded-rectangle" | "pill" | null,
-    "text": [ { "string": verbatim, "size": "x_large"|"large"|"medium"|"small", "weight": "bold"|"semibold"|"regular", "case": "upper"|"title"|"sentence", "color": hex, "align": "left"|"center"|"right" } ],
+    "text": [ { "string": verbatim, "size": "x_large"|"large"|"medium"|"small", "weight": "bold"|"semibold"|"regular", "case": "upper"|"title"|"sentence", "color": hex, "align": "left"|"center"|"right", "treatment": "plain"|"underline"|"arrow"|"button"|"sticker"|"highlight" } ],
     "notes": splits / overlaps / margins worth rebuilding
   } ] }
 
@@ -71374,7 +71941,7 @@ async function runVisionPasses(canvas) {
 var scaffoldStaticAdCommand = defineCommand134({
   meta: {
     name: "scaffold-static-ad",
-    description: "Turn a source/inspiration image into a runnable static-ad canvas. Runs billed passes \u2014 image_describe (the blueprint, baked to prompt.json as the editable 'prompt'), an AI selection of the image's MAIN identity elements, and a structured global-layout pass (the column/row grid with per-region bounds and text sizes) \u2014 then scaffolds a canvas that renders three candidate pictures (no text, no logo), judges them, and draws every placement format from the winner: the copy from prompt.json in the brand's fonts from src/brand/fonts/, the CTA, and the logo from src/brand/logos/. A format close to the picture's shape is a free crop; a far one extends the picture. With no brand font the copy is baked into the picture instead. Pass --placements none for a single base ad, or a preset to pick the set. Edit prompt.json and drop the real assets, then `baker canvas run` it. Start here: `baker avatars list`, then pass `--avatar <handle>` when the image shows a person \u2014 the ad's people are played by the company's avatars, never by a photo of anyone real."
+    description: "Turn a source/inspiration image into a runnable static-ad canvas. Runs billed passes \u2014 image_describe (the blueprint, baked to prompt.json as the editable 'prompt'), an AI selection of the image's MAIN identity elements, and a structured global-layout pass (the column/row grid with per-region bounds and text sizes) \u2014 then scaffolds a canvas that renders up to three candidate pictures (no overlay text, no logo), judges them, and draws every placement format from the winner with only what prompt.json holds: each line where the source layout put it, styled as the reference styled it, in the brand's fonts (a font file, else the typeface the brand names as a web font, else Inter), and the logo from src/brand/logos/ only when the concept shows one. No copy means the picture is the ad; a reference that pictures nothing but copy becomes a text-only ad with no picture at all (--text-only). A format close to the picture's shape is a free crop; a far one extends the picture. The copy is baked into the picture only with --skip-font or when no font loads. Pass --placements none for a single base ad, or a preset to pick the set. Edit prompt.json and drop the real assets, then `baker canvas run` it. Start here: `baker avatars list`, then pass `--avatar <handle>` when the image shows a person \u2014 the ad's people are played by the company's avatars, never by a photo of anyone real."
   },
   args: {
     file: { type: "positional", required: true, description: "Path or http(s) URL to the source/inspiration image" },
@@ -71404,7 +71971,11 @@ var scaffoldStaticAdCommand = defineCommand134({
     },
     "skip-font": {
       type: "boolean",
-      description: "Bake the copy into the picture instead of drawing it in the brand's font. Only for a brand with no font file; by default a font in src/brand/fonts/ draws the copy."
+      description: "Bake the copy into the picture instead of drawing it in a real font. By default the copy is drawn in a font file from src/brand/fonts/, else the typeface tokens.json or BRAND.md names (loaded as a web font), else Inter."
+    },
+    "text-only": {
+      type: "boolean",
+      description: "A typographic ad: no picture is generated, the copy from prompt.json is drawn on the brand's colours in its fonts (near-zero credits). On by default when the reference pictures nothing but copy; --no-text-only renders a picture anyway."
     },
     takes: {
       type: "string",
@@ -71490,6 +72061,9 @@ var scaffoldStaticAdCommand = defineCommand134({
     const relative = (file) => file ? toCanvasRelative2(canvasDir, file) : void 0;
     const takes = args8.takes !== void 0 ? Number.parseInt(String(args8.takes), 10) : void 0;
     if (takes !== void 0 && !(takes >= 1 && takes <= 3)) return fail4("invalid_takes", "--takes must be 1, 2 or 3");
+    const bakeText = args8["skip-font"] === true;
+    const textOnly = args8["text-only"] === void 0 ? isTextForward(blueprint) : args8["text-only"] === true;
+    const fonts = bakeText ? null : await brandFaces(workspaceRoot, kit, (file) => toCanvasRelative2(canvasDir, file));
     const opts = {
       genModel,
       imagePath: canvasImagePath,
@@ -71498,13 +72072,10 @@ var scaffoldStaticAdCommand = defineCommand134({
       aspectRatio: args8.aspect ? String(args8.aspect) : void 0,
       includeActorSheets: !args8["skip-actor-sheets"],
       placements,
-      brand: {
-        logoPath: relative(kit.logo),
-        headlineFontPath: relative(kit.headlineFont),
-        bodyFontPath: relative(kit.bodyFont)
-      },
-      bakeText: args8["skip-font"] === true,
-      takes
+      brand: { logoPath: relative(kit.logo), ...fonts ? { fonts } : {} },
+      bakeText,
+      takes,
+      textOnly
     };
     let canvas;
     let report;
@@ -71517,8 +72088,9 @@ var scaffoldStaticAdCommand = defineCommand134({
     for (const layout2 of staticAdCompositions(blueprint, opts)) {
       await writeStaticComposition(path26.resolve(canvasDir, layout2.dir), layout2.width, layout2.height);
     }
-    await writeFile9(path26.resolve(canvasDir, PLATE_SPEC_PATH), renderPlateSpec(annotated), "utf8");
-    await writeFile9(path26.resolve(canvasDir, COMPOSE_SPEC_PATH), renderComposeSpec(annotated, kit), "utf8");
+    const specOptions = composeOptionsFor(canvas, annotated);
+    await writeFile9(path26.resolve(canvasDir, PLATE_SPEC_PATH), renderPlateSpec(annotated, specOptions), "utf8");
+    await writeFile9(path26.resolve(canvasDir, COMPOSE_SPEC_PATH), renderComposeSpec(annotated, kit, specOptions), "utf8");
     const validation = await validateScaffoldedStaticAd(canvas, path26.dirname(outPath));
     if (validation.blocking.length > 0) {
       process.stderr.write(
@@ -71590,18 +72162,16 @@ var scaffoldStaticAdCommand = defineCommand134({
             winning_mechanisms: report.winning_mechanisms,
             rebuild_the_mechanism: "`winning_mechanisms` is WHY the source ad works. Rewrite each one for our brand in prompt.json (a rhyme stays a rhyme in our words, a before/after stays a before/after of our product); never copy the source's literal copy.",
             assets_to_supply: report.elements,
-            text: report.text_mode === "composed" ? `The copy is DRAWN, not generated: every line of text_content in prompt.json (minus the logo) is set in the brand's fonts (${[kit.headlineFont, kit.bodyFont].filter(Boolean).map((f) => path26.basename(String(f))).join(" / ")}) where the layout puts it, with the CTA as a button in the brand's CTA colour. Give the call to action role "cta". Edit the copy in prompt.json; every run reads it again.` : args8["skip-font"] ? "The copy is baked into the picture (--skip-font). Re-read every word on every format before publishing." : 'The copy is baked into the picture because the brand has no font file in src/brand/fonts/. Add one (`baker brand fonts fetch "<family>"`) and re-scaffold to have it drawn exactly instead. Re-read every word before publishing.',
-            logo: kit.logo ? `The logo is drawn from ${path26.basename(kit.logo)}, never generated.` : "No brand logo in src/brand/logos/: fill the logo slot with the brand's real file, or the ad goes out unsigned. It is drawn by the composition, never generated.",
-            takes: `${report.takes} picture${report.takes === 1 ? "" : "s"} are rendered and ${report.takes > 1 ? "judged on a fixed rubric (mechanism, space for the offer, brand, artifacts, safe zones, text); the winner becomes the ad and the others stay in the run as alternates." : "used as they are."}`,
+            mode: report.mode,
+            summary: report.summary,
+            text: staticTextNote(report, bakeText),
+            fonts: report.fonts,
+            in_scene_text: report.in_scene_text,
+            logo: report.logo.why,
+            takes: report.takes === 0 ? "No picture is rendered: a text-only ad costs no image credits." : report.takes === 1 ? "1 picture is rendered and used as it is (no judge)." : `${report.takes} pictures are rendered and judged (one idea, thumbnail legibility, mechanism, space for what is drawn, brand, artifacts, safe zones, text); the winner becomes the ad and the others stay in the run as alternates.`,
             actor_sheets: report.actor_sheets.length > 0 ? `Each animal hero (${report.actor_sheets.join(", ")}) is fused into a generated multi-view reference sheet (image_reference_sheet) that the render grounds on \u2014 so drop ONE clean photo at that hero's ingest and the sheet builds the consistent turnaround. Pass --skip-actor-sheets to ground on the lone photo instead. A person hero is cast from a company Avatar (--avatar <handle>), never a found photo.` : "none (no animal heroes detected, or --skip-actor-sheets). A person hero is cast from a company Avatar (--avatar <handle>), never a found photo.",
-            formats: `Delivers ${report.output_formats.join(", ")}, each at its exact size. The pictures render at ${report.aspect_ratio} (the nearest shape ${opts.genModel} renders); ${report.format_plan.map((f) => {
-              if (f.format === report.aspect_ratio) return `${f.format} is the picture itself`;
-              if (report.text_mode === "baked") {
-                return `${f.format} is re-framed from the chosen picture by Nano Banana Pro (one billed render; the copy is in the pixels, so it is never cropped)`;
-              }
-              return f.source === "crop" ? `${f.format} is a free crop of it` : `${f.format} extends the chosen picture to ${f.extendRatio} (one billed render) and crops the rest`;
-            }).join("; ")}.${report.text_mode === "composed" ? " Nothing re-paints the copy or the logo." : ""}${report.placements === null ? " Pass --placements meta_feed_stories|meta_all|linkedin|\u2026 for a platform's set." : ""}`,
-            note: "Populate as you go: for each [TODO] ingest slot, source its real asset and wire it into the slot right away \u2014 one at a time, not all sourced first then reconciled at the end. For any LOGO slot, use the company's committed brand logo from `src/brand/logos/` (per BRAND.md's Logos map) \u2014 do NOT re-fetch it with `baker images logo <domain>` when a brand logo exists, because the Brandfetch CDN often serves an OUTDATED mark and that is how an old logo ships on a live ad. When every slot is filled, `baker canvas validate` then `baker canvas run`. Running generates a billed image \u2014 it is not free."
+            formats: staticFormatsNote(report, opts.genModel),
+            note: `Populate as you go: for each [TODO] ingest slot, source its real asset and wire it into the slot right away, one at a time. The logo is optional and never a slot to fill: it is drawn only when prompt.json keeps a logo (a layout region of kind "logo" or an advertiser entry in brands_logos) and src/brand/logos/ has the real file; never fetch or draw a stand-in. When every slot is filled, \`baker canvas validate\` then \`baker canvas run\`.${report.takes > 0 ? " Running generates a billed image: it is not free." : " A text-only ad renders no picture and costs next to nothing."}`
           }
         },
         null,
@@ -74334,7 +74904,7 @@ import { readFileSync as readFileSync17 } from "fs";
 import path32 from "path";
 import { defineCommand as defineCommand144 } from "citty";
 import { parse as parseYaml } from "yaml";
-var DESCRIPTION4 = `How each Baker creative is doing in the live Meta ads that show it: spend, impressions, CTR, CPC, results, cost per result, frequency and a fatigue verdict, next to the angle and hook its definition set out to test. Use it before briefing new creatives, to learn which angle to make next and which creatives to replace.
+var DESCRIPTION4 = `How each Baker creative is doing in the live Meta ads that show it: spend, impressions, CTR, CPC, results, cost per result, frequency and a fatigue verdict, next to the angle, hook, mechanism and dominant slot its definition set out to test. Use it before briefing new creatives, to learn which angle and mechanism to make next and which creatives to replace.
 
 Start here:
   baker creatives performance                      # every creative in an ad, last 30 days
@@ -74357,7 +74927,7 @@ var ARGS6 = {
   }
 };
 registerSchema({ command: "creatives.performance", description: DESCRIPTION4, args: ARGS6 });
-var INSIGHT_KEYS = ["angle", "hook", "persona", "awareness", "hypothesis"];
+var INSIGHT_KEYS = ["angle", "hook", "mechanism", "dominantSlot", "persona", "awareness", "hypothesis"];
 var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
 function insightValue(value2) {
   if (typeof value2 === "string") return value2.trim() || null;
@@ -74389,20 +74959,25 @@ function readLocalDefinition(slug) {
     return null;
   }
 }
-function angleHint(creatives) {
-  const byAngle = /* @__PURE__ */ new Map();
+var COMPARED_FIELDS = [
+  { key: "angle", label: "angle", advice: "Brief the next creative on the cheapest angle with a new hook." },
+  { key: "mechanism", label: "mechanism", advice: "Brief the next creative on the cheapest mechanism." },
+  { key: "dominantSlot", label: "dominant slot", advice: "Lead the next creative with the cheapest dominant slot." }
+];
+function cheapestHint(creatives, { key, label, advice }) {
+  const byValue = /* @__PURE__ */ new Map();
   for (const creative of creatives) {
-    const angle = creative.definition?.angle;
-    if (!angle || creative.costPerResult === null) continue;
-    const best = byAngle.get(angle);
+    const value2 = creative.definition?.[key];
+    if (!value2 || creative.costPerResult === null) continue;
+    const best = byValue.get(value2);
     if (!best || (best.costPerResult ?? Number.POSITIVE_INFINITY) > creative.costPerResult)
-      byAngle.set(angle, creative);
+      byValue.set(value2, creative);
   }
-  if (byAngle.size < 2) return null;
-  const ranked = [...byAngle.entries()].sort(([, a], [, b]) => (a.costPerResult ?? 0) - (b.costPerResult ?? 0)).map(
-    ([angle, creative]) => `"${angle}" ${creative.costPerResult}${creative.currency ? ` ${creative.currency}` : ""} (${creative.slug ?? creative.title})`
+  if (byValue.size < 2) return null;
+  const ranked = [...byValue.entries()].sort(([, a], [, b]) => (a.costPerResult ?? 0) - (b.costPerResult ?? 0)).map(
+    ([value2, creative]) => `"${value2}" ${creative.costPerResult}${creative.currency ? ` ${creative.currency}` : ""} (${creative.slug ?? creative.title})`
   );
-  return `Cost per result by angle: ${ranked.join(", ")}. Brief the next creative on the cheapest angle with a new hook.`;
+  return `Cost per result by ${label}: ${ranked.join(", ")}. ${advice}`;
 }
 function withDefinitions(response, readDefinition) {
   const creatives = response.data.creatives.map((creative) => {
@@ -74411,8 +74986,10 @@ function withDefinitions(response, readDefinition) {
     return definition ? { ...creative, definition } : creative;
   });
   const hints2 = [...response.hints ?? []];
-  const byAngle = angleHint(creatives);
-  if (byAngle) hints2.push(byAngle);
+  for (const field of COMPARED_FIELDS) {
+    const hint = cheapestHint(creatives, field);
+    if (hint) hints2.push(hint);
+  }
   const unnamed = creatives.filter((creative) => !creative.definition?.angle).map((c) => c.slug ?? c.title);
   if (unnamed.length > 0) {
     hints2.push(
@@ -86235,14 +86812,14 @@ var ANALYZERS = [
       const counts = {};
       for (const v of rounded) counts[v] = (counts[v] || 0) + 1;
       const maxCount = Math.max(...Object.values(counts));
-      const pct = maxCount / rounded.length;
+      const pct2 = maxCount / rounded.length;
       const unique = [...new Set(rounded)].filter((v) => v > 0);
-      if (pct <= 0.6 || unique.length > 3) return [];
+      if (pct2 <= 0.6 || unique.length > 3) return [];
       const dominant = Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "?";
       return [
         {
           id: "monotonous-spacing",
-          snippet: `~${dominant}px used ${maxCount}/${rounded.length} times (${Math.round(pct * 100)}%)`,
+          snippet: `~${dominant}px used ${maxCount}/${rounded.length} times (${Math.round(pct2 * 100)}%)`,
           file
         }
       ];