@ggui-ai/ui-gen 0.27.0 → 0.29.0

package/dist/chunk-732IBFEJ.js

@@ -0,0 +1,2400 @@
+import { createVisionAgent } from './chunk-O2YC6XDC.js';
+import { buildStylingProfileJudgeBlock } from './chunk-NF6JUZWF.js';
+import { displayModeForCanvas, CANVAS_VIEWPORTS } from './chunk-3T2HMTON.js';
+import { createHash } from 'crypto';
+import * as z from 'zod';
+import { build } from 'esbuild';
+import { EXPANDED_FRAME, getCssTokens, FRAMED_CARD_GROUND, expandedFrameScrimDecls, mountFitCss, expandedFramePanelRule, expandedFramePanelDecls, GGUI_MOUNT_CANVAS_EXPORT, resolveMountFit, inlineCardRadius } from '@ggui-ai/design/rendering';
+import { inflateSync } from 'zlib';
+import { readFileSync, existsSync, mkdtempSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { resolve, relative, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { tmpdir } from 'os';
+
+var CRITERION_ID = /^[a-z][a-z0-9-]*(?:\.[a-zA-Z][a-zA-Z0-9-]*)+$/;
+var criteriaScopeSchema = z.object({
+  kind: z.string().min(1).optional(),
+  canvas: z.string().min(1).optional(),
+  preset: z.string().min(1).optional()
+});
+var bankRowSchema = z.object({
+  id: z.string().regex(CRITERION_ID, "a criterion id is family.property[.facet], lower-case family"),
+  group: z.string().optional(),
+  scope: criteriaScopeSchema.default({}),
+  /** Importance, independent of whether anything automated checks it yet. */
+  severity: z.enum(["must", "should"]),
+  /** The method that produces the verdict. */
+  evaluation: z.enum(["instrument", "judge", "human"]),
+  /** The method's readiness — the only source of an `n/a`. */
+  status: z.enum(["live", "reference", "planned", "manual"]),
+  /** The question, answerable yes/no from the frame. */
+  text: z.string().min(1),
+  /** The evidence rule: what the one-sentence evidence must name (a region or element). */
+  evidence: z.string().min(1),
+  /** The templated fix line a feedback channel may consume later; never read in v1. */
+  fix: z.string().optional()
+});
+var criteriaBankSchema = z.object({
+  version: z.string().min(1),
+  applies: z.object({
+    /** `["*"]` = every kind. */
+    kind: z.array(z.string().min(1)).optional(),
+    canvases: z.array(z.string().min(1)).optional()
+  }).optional(),
+  criteria: z.array(bankRowSchema).min(1),
+  recipes: z.array(bankRowSchema).optional()
+}).superRefine((bank, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  const check = (rows, key) => {
+    rows.forEach((c, i) => {
+      if (seen.has(c.id)) ctx.addIssue({ code: "custom", path: [key, i, "id"], message: `duplicate criterion id ${c.id}` });
+      seen.add(c.id);
+    });
+  };
+  check(bank.criteria, "criteria");
+  check(bank.recipes ?? [], "recipes");
+});
+function bankRows(bank) {
+  return [...bank.criteria, ...bank.recipes ?? []];
+}
+function parseCriteriaBank(raw) {
+  const parsed = criteriaBankSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.map(String).join(".") || "<root>"}: ${i.message}`).join("; ");
+    throw new Error(`criteria bank invalid \u2014 ${issues}`);
+  }
+  return parsed.data;
+}
+
+// src/evaluation/criteria/select.ts
+var CRITERIA_SELECTOR_VERSION = "selector@2";
+function canonicalCriteriaContext(ctx) {
+  const sortKeys = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? Object.fromEntries(
+    Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => [k, sortKeys(v)])
+  ) : value;
+  return JSON.stringify(sortKeys(ctx));
+}
+function criteriaSetIdFor(bankVersion, ctx) {
+  return createHash("sha256").update(`${bankVersion}|${CRITERIA_SELECTOR_VERSION}|${canonicalCriteriaContext(ctx)}`, "utf8").digest("hex").slice(0, 16);
+}
+function matchedScope(row, ctx) {
+  const s = row.scope;
+  const matched = [];
+  if (s.kind !== void 0) {
+    if (ctx.kind !== s.kind) return null;
+    matched.push(`kind=${s.kind}`);
+  }
+  if (s.canvas !== void 0) {
+    if (ctx.canvas !== s.canvas) return null;
+    matched.push(`canvas=${s.canvas}`);
+  }
+  if (s.preset !== void 0) {
+    if (ctx.preset !== s.preset) return null;
+    matched.push(`preset=${s.preset}`);
+  }
+  return matched;
+}
+function selectCriteria(bank, ctx) {
+  const criteriaSetId = criteriaSetIdFor(bank.version, ctx);
+  const applies = bank.applies;
+  if (applies?.canvases !== void 0 && !applies.canvases.includes(ctx.canvas)) return { criteriaSetId, selection: [] };
+  if (applies?.kind !== void 0 && ctx.kind !== void 0 && !applies.kind.includes("*") && !applies.kind.includes(ctx.kind)) {
+    return { criteriaSetId, selection: [] };
+  }
+  const selection = [];
+  for (const row of bankRows(bank)) {
+    const matched = matchedScope(row, ctx);
+    if (matched === null) continue;
+    selection.push(matched.length === 0 ? { id: row.id, source: "static", reason: "static" } : { id: row.id, source: "context", reason: `context: ${matched.join(", ")}` });
+  }
+  return { criteriaSetId, selection };
+}
+
+// src/evaluation/criteria/edge-probe.ts
+var EDGE_BLOCKS_EXPRESSION = String.raw`(() => {
+  const root = document.getElementById('root');
+  if (!root) return null;
+  const rootBox = root.getBoundingClientRect();
+  const x0 = rootBox.left;
+  const px = (v) => Math.round((v - x0) * 2) / 2;
+  const CONTROL = 'button,input,select,textarea,[role="button"],[role="tab"],[role="switch"],[role="checkbox"],[role="radio"],[role="option"],[role="link"],a[href]';
+  const ALNUM = /[\p{L}\p{N}]/u;
+  const css = (el) => getComputedStyle(el);
+  const clear = (c) => !c || c === 'transparent' || /rgba\([^)]*,\s*0(\.0+)?\)$/.test(c);
+  // Visible through every ancestor (an ancestor at opacity 0 or visibility hidden hides it), and not degenerate.
+  const shown = (el) => {
+    const s = css(el);
+    if (s.display === 'none' || s.visibility === 'hidden' || Number(s.opacity) === 0) return false;
+    if (typeof el.checkVisibility === 'function' && !el.checkVisibility({ opacityProperty: true, visibilityProperty: true })) return false;
+    const r = el.getBoundingClientRect();
+    return r.width > 1 && r.height > 1;
+  };
+  const inline = (s) => /^inline/.test(s.display) && s.display !== 'inline-block' && s.display !== 'inline-flex' && s.display !== 'inline-grid';
+  const groundOf = (el) => {
+    for (let p = el.parentElement; p; p = p.parentElement) { const b = css(p).backgroundColor; if (!clear(b)) return b; }
+    return 'rgb(255, 255, 255)';
+  };
+  const sides = (s) => ['Top', 'Right', 'Bottom', 'Left'].filter((k) => parseFloat(s['border' + k + 'Width']) > 0 && s['border' + k + 'Style'] !== 'none' && !clear(s['border' + k + 'Color'])).length;
+  const bounded = (el) => { const s = css(el); return sides(s) >= 1 || (!clear(s.backgroundColor) && s.backgroundColor !== groundOf(el)); };
+  // A control: a native or ARIA one, or a bounded box the visitor clicks (a pointer cursor or a tab stop) that holds no
+  // control of its own and is not the whole card. Its contents are not blocks of the column (decided 2026-10-02).
+  const isControl = (el) => {
+    const s = css(el);
+    if (inline(s)) return false;
+    if (el.matches(CONTROL)) return true;
+    if (el === root) return false;
+    const clickable = s.cursor === 'pointer' || (el.hasAttribute('tabindex') && el.tabIndex >= 0);
+    if (!clickable || !bounded(el) || el.querySelector(CONTROL)) return false;
+    const r = el.getBoundingClientRect();
+    return r.width * r.height < 0.6 * rootBox.width * rootBox.height;
+  };
+  const isTable = (el) => el.matches('table,[role="table"],[role="grid"]');
+  const isSurface = (el) => {
+    if (el === root || isControl(el)) return false;
+    const s = css(el);
+    if (/^inline/.test(s.display) || s.display === 'contents') return false;
+    if (isTable(el)) return true;
+    return sides(s) >= 3 || (!clear(s.backgroundColor) && s.backgroundColor !== groundOf(el)) || (s.boxShadow && s.boxShadow !== 'none');
+  };
+  const path = (el) => {
+    const parts = [];
+    for (let e = el; e && e !== root && parts.length < 4; e = e.parentElement) {
+      const i = e.parentElement ? Array.prototype.indexOf.call(e.parentElement.children, e) + 1 : 1;
+      parts.unshift(e.tagName.toLowerCase() + ':' + i);
+    }
+    return parts.join('>');
+  };
+  const label = (el) => { const t = (el.innerText || '').replace(/\s+/g, ' ').trim(); return path(el) + (t ? ' "' + t.slice(0, 24) + '"' : ''); };
+  const surfaces = [];
+  const surfaceOf = (el, self) => { for (let p = self ? el : el.parentElement; p && p !== root; p = p.parentElement) if (surfaces.indexOf(p) >= 0) return p; return null; };
+  const inTable = (el) => { for (let p = el.parentElement; p && p !== root; p = p.parentElement) if (isTable(p)) return true; return false; };
+  const inControl = (el) => { for (let p = el; p && p !== root; p = p.parentElement) if (isControl(p)) return p; return null; };
+  const all = Array.prototype.slice.call(root.querySelectorAll('*')).filter(shown);
+  for (const el of all) if (isSurface(el) && !inTable(el) && !inControl(el)) surfaces.push(el);
+  const ids = new Map();
+  const idOf = (el) => { if (!ids.has(el)) ids.set(el, label(el)); return ids.get(el); };
+  const blocks = [];
+  // Per block: the element it stands for and its first line's box, for rows.
+  const owners = [];
+  const lines = [];
+  // Per block: its raw line boxes and left, so a row reads the line two items share, not a wrapped item's widest line.
+  const rects = [];
+  const rawLeft = [];
+  const words = [];
+  const within = (el, self) => { const s = surfaceOf(el, self); return s ? { within: idOf(s) } : {}; };
+  for (const s of surfaces) {
+    const r = s.getBoundingClientRect();
+    owners.push(s); lines.push({ top: r.top, bottom: r.bottom }); rects.push([r]); rawLeft.push(r.left); words.push('');
+    // A placeholder: a box with no text, no control and no image or icon inside it (a loading bar). Not a block.
+    const holds = Array.prototype.some.call(s.querySelectorAll('*'), (el) => shown(el) && (el.matches(CONTROL) || el.tagName === 'IMG' || el.tagName.toLowerCase() === 'svg')) || ALNUM.test(s.innerText || '');
+    blocks.push(Object.assign({ id: idOf(s), kind: 'surface', edge: px(r.left), left: px(r.left), right: px(r.right), top: Math.round(r.top) }, within(s, false), isTable(s) ? { role: 'table' } : holds ? {} : { role: 'placeholder' }));
+  }
+  const blockOf = (node) => { for (let p = node.parentElement; p && p !== root; p = p.parentElement) if (!inline(css(p))) return p; return root; };
+  const groups = new Map();
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+    if (!/\S/.test(n.data) || !n.parentElement || n.parentElement.closest('style,script,noscript,template') || !shown(n.parentElement) || inControl(n.parentElement) || inTable(n.parentElement)) continue;
+    const b = blockOf(n);
+    if (!groups.has(b)) groups.set(b, []);
+    groups.get(b).push(n);
+  }
+  // Ink: text whose own colour is not transparent. The edge is the first visible character in ink (decided 2026-10-02):
+  // leading invisible text, private-use icon-font glyphs and formatting characters are not characters of the block,
+  // while a currency sign or a quotation mark is.
+  const inked = (n) => !clear(css(n.parentElement).color) && ALNUM.test(n.data);
+  const textRects = (nodes) => {
+    const rs = [];
+    for (const n of nodes) { if (!inked(n)) continue; const range = document.createRange(); range.selectNodeContents(n); for (const r of range.getClientRects()) if (r.width > 0 && r.height > 0) rs.push(r); }
+    return rs;
+  };
+  const glyphAt = (n, i) => { const range = document.createRange(); range.setStart(n, i); range.setEnd(n, i + 1); const r = range.getClientRects()[0]; return r || null; };
+  const firstGlyph = (nodes) => {
+    for (const n of nodes) { if (!inked(n)) continue; const i = n.data.search(/[^\s\p{Co}\p{Cf}]/u); if (i < 0) continue; const r = glyphAt(n, i); if (r) return r; }
+    return null;
+  };
+  // A marker paints: a loaded image, an SVG with a filled or stroked shape, or an element with its own fill, border
+  // or visible text. An element that paints nothing is not a marker.
+  const painted = (m) => {
+    if (!shown(m)) return false;
+    if (m.tagName === 'IMG') return m.complete && m.naturalWidth > 0;
+    if (m.tagName.toLowerCase() === 'svg' || m.closest('svg')) {
+      const shapes = m.querySelectorAll('path,circle,rect,line,polyline,polygon,ellipse,use,text');
+      return Array.prototype.some.call(shapes, (sh) => { const st = css(sh); return (st.fill !== 'none' && !clear(st.fill)) || (st.stroke !== 'none' && !clear(st.stroke)); });
+    }
+    const s = css(m);
+    if (!clear(s.backgroundColor) || sides(s) >= 1 || ((m.textContent || '').trim().length > 0 && !clear(s.color))) return true;
+    // A wrapper that paints nothing itself is a marker when an image or icon inside it paints.
+    return Array.prototype.some.call(m.querySelectorAll('svg,img'), (k) => painted(k));
+  };
+  const markerBefore = (b, textLeft, lineTop, lineBottom) => {
+    const cands = [];
+    const consider = (m) => { if (!painted(m)) return; const r = m.getBoundingClientRect(); if (r.left < textLeft - 2 && r.bottom > lineTop && r.top < lineBottom) cands.push(r.left); };
+    for (const m of b.querySelectorAll('svg,img,[aria-hidden="true"],i')) if ((m.textContent || '').trim().length <= 2) consider(m);
+    const p = b.parentElement;
+    if (p && p !== root && /flex/.test(css(p).display) && !/column/.test(css(p).flexDirection)) for (const sib of p.children) { if (sib === b) break; if (sib.matches('svg,img,i,[aria-hidden="true"]') || !(sib.textContent || '').trim()) consider(sib); }
+    return cands.length ? Math.min.apply(null, cands) : null;
+  };
+  let texts = 0;
+  let ornaments = 0;
+  for (const [b, nodes] of groups) {
+    if (!nodes.some((n) => ALNUM.test(n.data))) { ornaments += 1; continue; }
+    const rs = textRects(nodes);
+    const g = firstGlyph(nodes);
+    if (!rs.length || g === null) continue;
+    texts += 1;
+    const first = g.left;
+    const left = Math.min.apply(null, rs.map((r) => r.left));
+    const right = Math.max.apply(null, rs.map((r) => r.right));
+    const top = Math.min.apply(null, rs.map((r) => r.top));
+    const marker = markerBefore(b, first, g.top, g.bottom);
+    const s = css(b);
+    const box = b.getBoundingClientRect();
+    const parent = b.parentElement ? css(b.parentElement) : null;
+    const centredText = s.textAlign === 'center' && right - left < box.width * 0.9;
+    const centredBox = parent && /flex/.test(parent.display) && /column/.test(parent.flexDirection) && parent.alignItems === 'center';
+    const list = b.matches('li') || s.display === 'list-item' ? b.closest('ul,ol') : null;
+    const inProse = list && list.previousElementSibling && list.previousElementSibling.matches('p');
+    const block = { id: idOf(b), kind: 'text', edge: px(marker !== null ? marker : first), left: px(Math.min(left, marker !== null ? marker : left)), right: px(right), top: Math.round(top) };
+    if (marker !== null) block.textEdge = px(first);
+    if (centredText || centredBox) block.role = 'centred';
+    else if (inProse) block.role = 'list-item';
+    owners.push(b); lines.push({ top: g.top, bottom: g.bottom }); rects.push(rs); rawLeft.push(Math.min(left, marker !== null ? marker : left)); words.push(nodes.map((n) => n.data).join('').trim());
+    blocks.push(Object.assign(block, within(b, true)));
+  }
+  const ctlGroups = new Map();
+  for (const el of all) { if (!isControl(el) || inTable(el) || (el.parentElement && inControl(el.parentElement))) continue; const p = el.parentElement || root; if (!ctlGroups.has(p)) ctlGroups.set(p, []); ctlGroups.get(p).push(el); }
+  let controls = 0;
+  for (const [p, els] of ctlGroups) {
+    const rs = els.map((e) => e.getBoundingClientRect());
+    const topRow = Math.min.apply(null, rs.map((r) => r.top));
+    let firstEl = null; let firstR = null;
+    els.forEach((e, i) => { const r = rs[i]; if (r.top - topRow < r.height / 2 && (!firstR || r.left < firstR.left)) { firstEl = e; firstR = r; } });
+    let edge = firstR.left;
+    if (!bounded(firstEl)) { const tw = document.createTreeWalker(firstEl, NodeFilter.SHOW_TEXT); const ns = []; for (let n = tw.nextNode(); n; n = tw.nextNode()) ns.push(n); const g = firstGlyph(ns); if (g) edge = g.left; }
+    controls += 1;
+    const ps = css(p);
+    const centred = ps.justifyContent === 'center' || (ps.textAlign === 'center' && !/flex|grid/.test(ps.display));
+    const block = { id: idOf(p) + ' [controls]', kind: 'controls', edge: px(edge), left: px(Math.min.apply(null, rs.map((r) => r.left))), right: px(Math.max.apply(null, rs.map((r) => r.right))), top: Math.round(topRow) };
+    if (centred) block.role = 'centred';
+    owners.push(firstEl); lines.push({ top: firstR.top, bottom: firstR.bottom }); rects.push(rs); rawLeft.push(Math.min.apply(null, rs.map((r) => r.left))); words.push('');
+    blocks.push(Object.assign(block, within(firstEl, true)));
+  }
+  // Rows (decided 2026-10-01, read by geometry 2026-10-02): items set on one line, however the CSS sets them. An item
+  // after another measured item on its line that holds one block (a text, a control, or a box holding at most one
+  // text) belongs to the row and is not measured; an item with a stack inside it is a column.
+  const dropped = new Set();
+  const sameLine = (a, b) => Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top) > Math.min(a.bottom - a.top, b.bottom - b.top) / 2;
+  const contains = (o, el) => o === el || o.contains(el);
+  const innerTexts = (i) => owners.map((el, k) => k).filter((k) => k !== i && blocks[k].kind !== 'surface' && contains(owners[i], owners[k]));
+  const isPill = (i) => blocks[i].kind === 'surface' && innerTexts(i).length <= 1 && !owners.some((el, k) => k !== i && blocks[k].kind === 'surface' && contains(owners[i], el));
+  const itemOf = (el, other) => { let e = el; while (e.parentElement && e.parentElement !== root && !e.parentElement.contains(other)) e = e.parentElement; return e; };
+  for (let i = 0; i < blocks.length; i += 1) {
+    if (blocks[i].kind === 'surface' && !isPill(i)) continue;
+    const before = blocks.findIndex((bj, j) => j !== i && bj.within === blocks[i].within && !(bj.kind === 'surface' && !isPill(j)) && !contains(owners[j], owners[i]) && !contains(owners[i], owners[j]) && rects[j].some((r) => sameLine(r, lines[i]) && r.right <= rawLeft[i] + 1));
+    if (before < 0) continue;
+    // A number or bullet in front of a text on its line is a hanging marker, not a row: the pair is one block with two
+    // edges, the marker's and the text's.
+    if (blocks[i].kind === 'text' && blocks[before].kind === 'text' && /^[\p{N}\p{P}\p{S}]{1,3}$/u.test(words[before])) {
+      blocks[i] = Object.assign({}, blocks[i], { edge: blocks[before].edge, left: Math.min(blocks[i].left, blocks[before].left), textEdge: blocks[i].edge });
+      delete blocks[i].role;
+      dropped.add(before);
+      continue;
+    }
+    const item = itemOf(owners[i], owners[before]);
+    const inside = owners.map((el, k) => k).filter((k) => contains(item, owners[k]) && blocks[k].kind !== 'surface');
+    const boxes = owners.map((el, k) => k).filter((k) => contains(item, owners[k]) && blocks[k].kind === 'surface' && k !== i);
+    if (blocks[i].kind === 'surface') { if (boxes.length === 0) { dropped.add(i); for (const k of innerTexts(i)) dropped.add(k); } continue; }
+    if (inside.length === 1 && boxes.length === 0) dropped.add(i);
+  }
+  const kept = blocks.filter((_, i) => !dropped.has(i));
+  // Placeholders: a frame with no text in ink shows nothing to evaluate, whatever controls or boxes it draws.
+  return { blocks: kept, placeholdersOnly: texts === 0, skipped: { rowItems: dropped.size, ornaments } };
+})()`;
+var KINDS = ["text", "controls", "surface"];
+var ROLES = ["list-item", "table", "centred", "placeholder"];
+var isKind = (v) => KINDS.some((k) => k === v);
+var isRole = (v) => ROLES.some((r) => r === v);
+var num = (v) => typeof v === "number" && Number.isFinite(v);
+var field = (o, key) => Reflect.get(o, key);
+function parseEdgeProbe(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const raw = field(value, "blocks");
+  const placeholdersOnly = field(value, "placeholdersOnly");
+  if (!Array.isArray(raw) || typeof placeholdersOnly !== "boolean") return null;
+  const skippedRaw = field(value, "skipped");
+  if (typeof skippedRaw !== "object" || skippedRaw === null) return null;
+  const rowItems = field(skippedRaw, "rowItems");
+  const ornaments = field(skippedRaw, "ornaments");
+  if (!num(rowItems) || !num(ornaments)) return null;
+  const blocks = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) return null;
+    const [id, kind, edge, left, right, top] = ["id", "kind", "edge", "left", "right", "top"].map((k) => field(entry, k));
+    const [within, textEdge, role] = ["within", "textEdge", "role"].map((k) => field(entry, k));
+    if (typeof id !== "string" || !isKind(kind) || !num(edge) || !num(left) || !num(right) || !num(top)) return null;
+    if (within !== void 0 && typeof within !== "string") return null;
+    if (textEdge !== void 0 && !num(textEdge)) return null;
+    if (role !== void 0 && !isRole(role)) return null;
+    blocks.push({
+      id,
+      kind,
+      edge,
+      left,
+      right,
+      top,
+      ...within !== void 0 ? { within } : {},
+      ...textEdge !== void 0 ? { textEdge } : {},
+      ...role !== void 0 ? { role } : {}
+    });
+  }
+  return { blocks, placeholdersOnly, skipped: { rowItems, ornaments } };
+}
+
+// src/evaluation/criteria/edge-probe-v2.ts
+var EDGE_BLOCKS_V2_EXPRESSION = String.raw`(() => {
+  const root = document.getElementById('root');
+  if (!root) return null;
+  const rootBox = root.getBoundingClientRect();
+  const x0 = rootBox.left;
+  const px = (v) => Math.round((v - x0) * 2) / 2;
+  const CONTROL = 'button,input,select,textarea,[role="button"],[role="tab"],[role="switch"],[role="checkbox"],[role="radio"],[role="option"],[role="link"],a[href]';
+  const ALNUM = /[\p{L}\p{N}]/u;
+  const css = (el) => getComputedStyle(el);
+  const clear = (c) => !c || c === 'transparent' || /rgba\([^)]*,\s*0(\.0+)?\)$/.test(c);
+  // Visible through every ancestor (an ancestor at opacity 0 or visibility hidden hides it), and not degenerate.
+  const shown = (el) => {
+    const s = css(el);
+    if (s.display === 'none' || s.visibility === 'hidden' || Number(s.opacity) === 0) return false;
+    if (typeof el.checkVisibility === 'function' && !el.checkVisibility({ opacityProperty: true, visibilityProperty: true })) return false;
+    const r = el.getBoundingClientRect();
+    return r.width > 1 && r.height > 1;
+  };
+  const inline = (s) => /^inline/.test(s.display) && s.display !== 'inline-block' && s.display !== 'inline-flex' && s.display !== 'inline-grid';
+  const groundOf = (el) => {
+    for (let p = el.parentElement; p; p = p.parentElement) { const b = css(p).backgroundColor; if (!clear(b)) return b; }
+    return 'rgb(255, 255, 255)';
+  };
+  const sides = (s) => ['Top', 'Right', 'Bottom', 'Left'].filter((k) => parseFloat(s['border' + k + 'Width']) > 0 && s['border' + k + 'Style'] !== 'none' && !clear(s['border' + k + 'Color'])).length;
+  const bounded = (el) => { const s = css(el); return sides(s) >= 1 || (!clear(s.backgroundColor) && s.backgroundColor !== groundOf(el)); };
+  // A control: a native or ARIA one, or a bounded box the visitor clicks (a pointer cursor or a tab stop) that holds no
+  // control of its own and is not the whole card. Its contents are not blocks of the column (decided 2026-10-02).
+  const isControl = (el) => {
+    const s = css(el);
+    if (inline(s)) return false;
+    if (el.matches(CONTROL)) return true;
+    if (el === root) return false;
+    const clickable = s.cursor === 'pointer' || (el.hasAttribute('tabindex') && el.tabIndex >= 0);
+    if (!clickable || !bounded(el) || el.querySelector(CONTROL)) return false;
+    const r = el.getBoundingClientRect();
+    return r.width * r.height < 0.6 * rootBox.width * rootBox.height;
+  };
+  const isTable = (el) => el.matches('table,[role="table"],[role="grid"]');
+  const isSurface = (el) => {
+    if (el === root || isControl(el)) return false;
+    const s = css(el);
+    if (/^inline/.test(s.display) || s.display === 'contents') return false;
+    if (isTable(el)) return true;
+    // v2 (the design lead, #1765): what paints owns its edge — any border side (a single rule counts), a fill, a shadow.
+    return sides(s) >= 1 || (!clear(s.backgroundColor) && s.backgroundColor !== groundOf(el)) || (s.boxShadow && s.boxShadow !== 'none');
+  };
+  const path = (el) => {
+    const parts = [];
+    // v2: the whole path from the root, so nested boxes with the same tail and text never share an id (v1 kept four
+    // steps, and three nested surfaces of one card read as one container).
+    for (let e = el; e && e !== root; e = e.parentElement) {
+      const i = e.parentElement ? Array.prototype.indexOf.call(e.parentElement.children, e) + 1 : 1;
+      parts.unshift(e.tagName.toLowerCase() + ':' + i);
+    }
+    return parts.join('>');
+  };
+  const label = (el) => { const t = (el.innerText || '').replace(/\s+/g, ' ').trim(); return path(el) + (t ? ' "' + t.slice(0, 24) + '"' : ''); };
+  const surfaces = [];
+  const surfaceOf = (el, self) => { for (let p = self ? el : el.parentElement; p && p !== root; p = p.parentElement) if (surfaces.indexOf(p) >= 0) return p; return null; };
+  const inTable = (el) => { for (let p = el.parentElement; p && p !== root; p = p.parentElement) if (isTable(p)) return true; return false; };
+  const inControl = (el) => { for (let p = el; p && p !== root; p = p.parentElement) if (isControl(p)) return p; return null; };
+  const all = Array.prototype.slice.call(root.querySelectorAll('*')).filter(shown);
+  for (const el of all) if (isSurface(el) && !inTable(el) && !inControl(el)) surfaces.push(el);
+  const ids = new Map();
+  const idOf = (el) => { if (!ids.has(el)) ids.set(el, label(el)); return ids.get(el); };
+  const blocks = [];
+  // Per block: the element it stands for and its first line's box, for rows.
+  const owners = [];
+  const lines = [];
+  // Per block: its raw line boxes and left, so a row reads the line two items share, not a wrapped item's widest line.
+  const rects = [];
+  const rawLeft = [];
+  const words = [];
+  const within = (el, self) => { const s = surfaceOf(el, self); return s ? { within: idOf(s) } : {}; };
+  for (const s of surfaces) {
+    const r = s.getBoundingClientRect();
+    owners.push(s); lines.push({ top: r.top, bottom: r.bottom }); rects.push([r]); rawLeft.push(r.left); words.push('');
+    // A placeholder: a box with no text, no control and no image or icon inside it (a loading bar). Not a block.
+    const holds = Array.prototype.some.call(s.querySelectorAll('*'), (el) => shown(el) && (el.matches(CONTROL) || el.tagName === 'IMG' || el.tagName.toLowerCase() === 'svg')) || ALNUM.test(s.innerText || '');
+    const ss = css(s);
+    const cl = r.left + parseFloat(ss.borderLeftWidth) + parseFloat(ss.paddingLeft);
+    const cr = r.right - parseFloat(ss.borderRightWidth) - parseFloat(ss.paddingRight);
+    blocks.push(Object.assign({ id: idOf(s), kind: 'surface', edge: px(r.left), left: px(r.left), right: px(r.right), top: Math.round(r.top), bottom: Math.round(r.bottom), contentLeft: px(cl), contentRight: px(cr) }, within(s, false), isTable(s) ? { role: 'table' } : holds ? {} : { role: 'placeholder' }));
+  }
+  const blockOf = (node) => { for (let p = node.parentElement; p && p !== root; p = p.parentElement) if (!inline(css(p))) return p; return root; };
+  const groups = new Map();
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+    if (!/\S/.test(n.data) || !n.parentElement || n.parentElement.closest('style,script,noscript,template') || !shown(n.parentElement) || inControl(n.parentElement) || inTable(n.parentElement)) continue;
+    const b = blockOf(n);
+    if (!groups.has(b)) groups.set(b, []);
+    groups.get(b).push(n);
+  }
+  // Ink: text whose own colour is not transparent. The edge is the first visible character in ink (decided 2026-10-02):
+  // leading invisible text, private-use icon-font glyphs and formatting characters are not characters of the block,
+  // while a currency sign or a quotation mark is.
+  const inked = (n) => !clear(css(n.parentElement).color) && ALNUM.test(n.data);
+  const textRects = (nodes) => {
+    const rs = [];
+    for (const n of nodes) { if (!inked(n)) continue; const range = document.createRange(); range.selectNodeContents(n); for (const r of range.getClientRects()) if (r.width > 0 && r.height > 0) rs.push(r); }
+    return rs;
+  };
+  const glyphAt = (n, i) => { const range = document.createRange(); range.setStart(n, i); range.setEnd(n, i + 1); const r = range.getClientRects()[0]; return r || null; };
+  const firstGlyph = (nodes) => {
+    for (const n of nodes) { if (!inked(n)) continue; const i = n.data.search(/[^\s\p{Co}\p{Cf}]/u); if (i < 0) continue; const r = glyphAt(n, i); if (r) return r; }
+    return null;
+  };
+  // A marker paints: a loaded image, an SVG with a filled or stroked shape, or an element with its own fill, border
+  // or visible text. An element that paints nothing is not a marker.
+  const painted = (m) => {
+    if (!shown(m)) return false;
+    if (m.tagName === 'IMG') return m.complete && m.naturalWidth > 0;
+    if (m.tagName.toLowerCase() === 'svg' || m.closest('svg')) {
+      const shapes = m.querySelectorAll('path,circle,rect,line,polyline,polygon,ellipse,use,text');
+      return Array.prototype.some.call(shapes, (sh) => { const st = css(sh); return (st.fill !== 'none' && !clear(st.fill)) || (st.stroke !== 'none' && !clear(st.stroke)); });
+    }
+    const s = css(m);
+    if (!clear(s.backgroundColor) || sides(s) >= 1 || ((m.textContent || '').trim().length > 0 && !clear(s.color))) return true;
+    // A wrapper that paints nothing itself is a marker when an image or icon inside it paints.
+    return Array.prototype.some.call(m.querySelectorAll('svg,img'), (k) => painted(k));
+  };
+  const markerEls = [];
+  const markerBefore = (b, textLeft, lineTop, lineBottom) => {
+    const cands = [];
+    const consider = (m) => { if (!painted(m)) return; const r = m.getBoundingClientRect(); if (r.left < textLeft - 2 && r.bottom > lineTop && r.top < lineBottom) { cands.push(r.left); markerEls.push(m); } };
+    for (const m of b.querySelectorAll('svg,img,[aria-hidden="true"],i')) if ((m.textContent || '').trim().length <= 2) consider(m);
+    const p = b.parentElement;
+    if (p && p !== root && /flex/.test(css(p).display) && !/column/.test(css(p).flexDirection)) for (const sib of p.children) { if (sib === b) break; if (sib.matches('svg,img,i,[aria-hidden="true"]') || !(sib.textContent || '').trim()) consider(sib); }
+    return cands.length ? Math.min.apply(null, cands) : null;
+  };
+  let texts = 0;
+  let ornaments = 0;
+  for (const [b, nodes] of groups) {
+    if (!nodes.some((n) => ALNUM.test(n.data))) { ornaments += 1; continue; }
+    const rs = textRects(nodes);
+    const g = firstGlyph(nodes);
+    if (!rs.length || g === null) continue;
+    texts += 1;
+    const first = g.left;
+    const left = Math.min.apply(null, rs.map((r) => r.left));
+    const right = Math.max.apply(null, rs.map((r) => r.right));
+    const top = Math.min.apply(null, rs.map((r) => r.top));
+    const marker = markerBefore(b, first, g.top, g.bottom);
+    const s = css(b);
+    const box = b.getBoundingClientRect();
+    const parent = b.parentElement ? css(b.parentElement) : null;
+    const centredText = s.textAlign === 'center' && right - left < box.width * 0.9;
+    const centredBox = parent && /flex/.test(parent.display) && /column/.test(parent.flexDirection) && parent.alignItems === 'center';
+    const list = b.matches('li') || s.display === 'list-item' ? b.closest('ul,ol') : null;
+    const inProse = list && list.previousElementSibling && list.previousElementSibling.matches('p');
+    const bottom = Math.max.apply(null, rs.map((r) => r.bottom));
+    const block = { id: idOf(b), kind: 'text', edge: px(marker !== null ? marker : first), left: px(Math.min(left, marker !== null ? marker : left)), right: px(right), top: Math.round(top), bottom: Math.round(bottom) };
+    if (marker !== null) block.textEdge = px(first);
+    if (centredText || centredBox) block.role = 'centred';
+    else if (inProse) block.role = 'list-item';
+    owners.push(b); lines.push({ top: g.top, bottom: g.bottom }); rects.push(rs); rawLeft.push(Math.min(left, marker !== null ? marker : left)); words.push(nodes.map((n) => n.data).join('').trim());
+    blocks.push(Object.assign(block, within(b, true)));
+  }
+  const ctlGroups = new Map();
+  for (const el of all) { if (!isControl(el) || inTable(el) || (el.parentElement && inControl(el.parentElement))) continue; const p = el.parentElement || root; if (!ctlGroups.has(p)) ctlGroups.set(p, []); ctlGroups.get(p).push(el); }
+  let controls = 0;
+  for (const [p, els] of ctlGroups) {
+    const rs = els.map((e) => e.getBoundingClientRect());
+    const topRow = Math.min.apply(null, rs.map((r) => r.top));
+    let firstEl = null; let firstR = null;
+    els.forEach((e, i) => { const r = rs[i]; if (r.top - topRow < r.height / 2 && (!firstR || r.left < firstR.left)) { firstEl = e; firstR = r; } });
+    let edge = firstR.left;
+    const tw = document.createTreeWalker(firstEl, NodeFilter.SHOW_TEXT); const ns = []; for (let n = tw.nextNode(); n; n = tw.nextNode()) ns.push(n);
+    const cg = firstGlyph(ns);
+    if (!bounded(firstEl) && cg) edge = cg.left;
+    // v2: a control's edge is its first painted content — its first character or a painted icon inside its box,
+    // whichever is leftmost; an icon drawn over a native field counts. A field with neither reads its padding edge.
+    const fs = css(firstEl);
+    const fieldEdge = firstEl.matches('input,select,textarea') ? firstR.left + parseFloat(fs.borderLeftWidth) + parseFloat(fs.paddingLeft) : null;
+    const iconLefts = all.filter((k) => k.matches('svg,img,i,[aria-hidden="true"]') && !(k.parentElement && k.parentElement.closest('svg')) && painted(k)).map((k) => k.getBoundingClientRect()).filter((r) => r.left >= firstR.left - 1 && r.right <= firstR.right + 1 && r.top >= firstR.top - 1 && r.bottom <= firstR.bottom + 1).map((r) => r.left);
+    const iconLeft = iconLefts.length ? Math.min.apply(null, iconLefts) : null;
+    controls += 1;
+    const ps = css(p);
+    const centred = ps.justifyContent === 'center' || (ps.textAlign === 'center' && !/flex|grid/.test(ps.display));
+    const block = { id: idOf(p) + ' [controls]', kind: 'controls', edge: px(edge), left: px(Math.min.apply(null, rs.map((r) => r.left))), right: px(Math.max.apply(null, rs.map((r) => r.right))), top: Math.round(topRow), bottom: Math.round(Math.max.apply(null, rs.map((r) => r.bottom))) };
+    const firstPaint = [cg ? cg.left : null, iconLeft].filter((v) => v !== null);
+    if (firstPaint.length) block.textEdge = px(Math.min.apply(null, firstPaint));
+    else if (fieldEdge !== null) block.textEdge = px(fieldEdge);
+    if (centred) block.role = 'centred';
+    owners.push(firstEl); lines.push({ top: firstR.top, bottom: firstR.bottom }); rects.push(rs); rawLeft.push(Math.min.apply(null, rs.map((r) => r.left))); words.push('');
+    blocks.push(Object.assign(block, within(firstEl, true)));
+  }
+  // v2: media — a painted image, video or icon that is not a text's marker and sits in no text, control or table.
+  const textOwners = Array.from(groups.keys());
+  for (const el of all) {
+    if (!el.matches('img,video,picture,svg') || (el.parentElement && el.parentElement.closest('svg')) || !painted(el) || inControl(el) || inTable(el)) continue;
+    if (markerEls.some((m) => m === el || m.contains(el))) continue;
+    if (textOwners.some((t) => t.contains(el))) continue;
+    const r = el.getBoundingClientRect();
+    // An icon drawn inside a control's box (a search field's glass) is the control's adornment, not a block.
+    if (all.some((k) => isControl(k) && (() => { const kr = k.getBoundingClientRect(); return r.left >= kr.left - 1 && r.right <= kr.right + 1 && r.top >= kr.top - 1 && r.bottom <= kr.bottom + 1; })())) continue;
+    owners.push(el); lines.push({ top: r.top, bottom: r.bottom }); rects.push([r]); rawLeft.push(r.left); words.push('');
+    blocks.push(Object.assign({ id: idOf(el) + ' [media]', kind: 'media', edge: px(r.left), left: px(r.left), right: px(r.right), top: Math.round(r.top), bottom: Math.round(r.bottom) }, within(el, false)));
+  }
+  // v2 rule 2, trailing: the right content edge of the box a block sits in (its nearest wider, non-inline ancestor
+  // inside its container), where a right-anchored item ends.
+  for (let i = 0; i < blocks.length; i += 1) {
+    const el = owners[i];
+    const w = el.getBoundingClientRect().width;
+    for (let p = el.parentElement; p && p !== root.parentElement; p = p.parentElement) {
+      const ps = css(p);
+      if (inline(ps) || ps.display === 'contents') continue;
+      const pr = p.getBoundingClientRect();
+      if (pr.width <= w + 2) continue;
+      blocks[i].parentRight = px(pr.right - parseFloat(ps.borderRightWidth) - parseFloat(ps.paddingRight));
+      break;
+    }
+  }
+  // v2 rule 2: a block in a row item that is not the row's leading item on its line follows that leader. A row is a
+  // horizontal flex or grid box; the leading item is the leftmost of the shown children that share the item's line.
+  const isRowBox = (el) => { const s = css(el); return (/flex/.test(s.display) && !/column/.test(s.flexDirection)) || /grid/.test(s.display); };
+  const vOverlap = (a, b) => Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top) > 1;
+  for (let i = 0; i < blocks.length; i += 1) {
+    const el = owners[i];
+    const c = (blocks[i].kind === 'surface' ? surfaceOf(el, false) : surfaceOf(el, true)) || root;
+    for (let e = el; e && e !== c && e !== root; e = e.parentElement) {
+      const p = e.parentElement;
+      if (!p) break;
+      if (isRowBox(p)) {
+        const er = e.getBoundingClientRect();
+        const line = Array.prototype.filter.call(p.children, (k) => shown(k) && vOverlap(k.getBoundingClientRect(), er));
+        if (line.length >= 2) {
+          const lead = line.reduce((a, k) => (k.getBoundingClientRect().left < a.getBoundingClientRect().left ? k : a));
+          // A leader that paints nothing (an empty icon slot) leads nothing: the item after it stands alone on its line.
+          const leads = painted(lead) || ALNUM.test(lead.innerText || '');
+          if (lead !== e && leads) { blocks[i].follows = label(lead); blocks[i].item = label(e); break; }
+        }
+      }
+      if (p === c) break;
+    }
+  }
+  // Rows (decided 2026-10-01, read by geometry 2026-10-02): items set on one line, however the CSS sets them. An item
+  // after another measured item on its line that holds one block (a text, a control, or a box holding at most one
+  // text) belongs to the row and is not measured; an item with a stack inside it is a column.
+  const dropped = new Set();
+  const sameLine = (a, b) => Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top) > Math.min(a.bottom - a.top, b.bottom - b.top) / 2;
+  const contains = (o, el) => o === el || o.contains(el);
+  const innerTexts = (i) => owners.map((el, k) => k).filter((k) => k !== i && blocks[k].kind !== 'surface' && contains(owners[i], owners[k]));
+  const isPill = (i) => blocks[i].kind === 'surface' && innerTexts(i).length <= 1 && !owners.some((el, k) => k !== i && blocks[k].kind === 'surface' && contains(owners[i], el));
+  const itemOf = (el, other) => { let e = el; while (e.parentElement && e.parentElement !== root && !e.parentElement.contains(other)) e = e.parentElement; return e; };
+  for (let i = 0; i < blocks.length; i += 1) {
+    if (blocks[i].kind === 'surface' && !isPill(i)) continue;
+    const before = blocks.findIndex((bj, j) => j !== i && bj.within === blocks[i].within && !(bj.kind === 'surface' && !isPill(j)) && !contains(owners[j], owners[i]) && !contains(owners[i], owners[j]) && rects[j].some((r) => sameLine(r, lines[i]) && r.right <= rawLeft[i] + 1));
+    if (before < 0) continue;
+    // A number or bullet in front of a text on its line is a hanging marker, not a row: the pair is one block with two
+    // edges, the marker's and the text's.
+    if (blocks[i].kind === 'text' && blocks[before].kind === 'text' && /^[\p{N}\p{P}\p{S}]{1,3}$/u.test(words[before])) {
+      blocks[i] = Object.assign({}, blocks[i], { edge: blocks[before].edge, left: Math.min(blocks[i].left, blocks[before].left), textEdge: blocks[i].edge });
+      delete blocks[i].role;
+      // v2: the merged block's edge is its marker's, which leads the row, so it stands in its container's column.
+      delete blocks[i].follows;
+      delete blocks[i].item;
+      dropped.add(before);
+      continue;
+    }
+    const item = itemOf(owners[i], owners[before]);
+    const inside = owners.map((el, k) => k).filter((k) => contains(item, owners[k]) && blocks[k].kind !== 'surface');
+    const boxes = owners.map((el, k) => k).filter((k) => contains(item, owners[k]) && blocks[k].kind === 'surface' && k !== i);
+    if (blocks[i].kind === 'surface') { if (boxes.length === 0) { dropped.add(i); for (const k of innerTexts(i)) dropped.add(k); } continue; }
+    if (inside.length === 1 && boxes.length === 0) dropped.add(i);
+  }
+  const kept = blocks.filter((_, i) => !dropped.has(i));
+  // Placeholders: a frame with no text in ink shows nothing to evaluate, whatever controls or boxes it draws.
+  const rs0 = css(root);
+  const cardContent = { left: px(rootBox.left + parseFloat(rs0.borderLeftWidth) + parseFloat(rs0.paddingLeft)), right: px(rootBox.right - parseFloat(rs0.borderRightWidth) - parseFloat(rs0.paddingRight)) };
+  return { blocks: kept, cardContent, placeholdersOnly: texts === 0, skipped: { rowItems: dropped.size, ornaments } };
+})()`;
+var KINDS2 = ["text", "controls", "surface", "media"];
+var ROLES2 = ["list-item", "table", "centred", "placeholder"];
+var isKind2 = (v) => KINDS2.some((k) => k === v);
+var isRole2 = (v) => ROLES2.some((r) => r === v);
+var num2 = (v) => typeof v === "number" && Number.isFinite(v);
+var field2 = (o, key) => Reflect.get(o, key);
+var optNum = (v) => v === void 0 || num2(v);
+var optStr = (v) => v === void 0 || typeof v === "string";
+function parseEdgeProbeV2(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const raw = field2(value, "blocks");
+  const placeholdersOnly = field2(value, "placeholdersOnly");
+  const cc = field2(value, "cardContent");
+  if (!Array.isArray(raw) || typeof placeholdersOnly !== "boolean" || typeof cc !== "object" || cc === null) return null;
+  const ccLeft = field2(cc, "left");
+  const ccRight = field2(cc, "right");
+  if (!num2(ccLeft) || !num2(ccRight)) return null;
+  const skippedRaw = field2(value, "skipped");
+  if (typeof skippedRaw !== "object" || skippedRaw === null) return null;
+  const rowItems = field2(skippedRaw, "rowItems");
+  const ornaments = field2(skippedRaw, "ornaments");
+  if (!num2(rowItems) || !num2(ornaments)) return null;
+  const blocks = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) return null;
+    const [id, kind, edge, left, right, top, bottom] = ["id", "kind", "edge", "left", "right", "top", "bottom"].map((k) => field2(entry, k));
+    const [within, textEdge, role, contentLeft, contentRight, follows, item, parentRight] = ["within", "textEdge", "role", "contentLeft", "contentRight", "follows", "item", "parentRight"].map((k) => field2(entry, k));
+    if (typeof id !== "string" || !isKind2(kind) || !num2(edge) || !num2(left) || !num2(right) || !num2(top) || !num2(bottom)) return null;
+    if (!optStr(within) || !optNum(textEdge) || !optNum(contentLeft) || !optNum(contentRight) || !optStr(follows) || !optStr(item) || !optNum(parentRight)) return null;
+    if (role !== void 0 && !isRole2(role)) return null;
+    blocks.push({
+      id,
+      kind,
+      edge,
+      left,
+      right,
+      top,
+      bottom,
+      ...typeof within === "string" ? { within } : {},
+      ...num2(textEdge) ? { textEdge } : {},
+      ...role !== void 0 ? { role } : {},
+      ...num2(contentLeft) ? { contentLeft } : {},
+      ...num2(contentRight) ? { contentRight } : {},
+      ...typeof follows === "string" ? { follows } : {},
+      ...typeof item === "string" ? { item } : {},
+      ...num2(parentRight) ? { parentRight } : {}
+    });
+  }
+  return { blocks, cardContent: { left: ccLeft, right: ccRight }, placeholdersOnly, skipped: { rowItems, ornaments } };
+}
+
+// src/evaluation/criteria/edge-instruments.ts
+var digest = (expression) => createHash("sha256").update(expression).digest("hex").slice(0, 12);
+var EDGE_INSTRUMENT_IDS = {
+  v1: `space.edge@${digest(EDGE_BLOCKS_EXPRESSION)}`,
+  v2: `space.edge.v2@${digest(EDGE_BLOCKS_V2_EXPRESSION)}`
+};
+
+// src/evaluation/criteria/resolve.ts
+var INSTRUMENT_BY_ID = {
+  "comp.fit": "fit",
+  "floor.fit": "fit",
+  "finish.canvas.inhabited": "fill"
+};
+var INSTRUMENT_BESIDE_JUDGE = {
+  "space.edge": "edge"
+};
+var REQUIRES_POST_ACTION_CAPTURE = /* @__PURE__ */ new Set(["state.feedback"]);
+var NO_POST_ACTION = "not evaluated: no post-action capture";
+function besideRead(kind, m) {
+  return edgeRead(m.edge);
+}
+function edgeRead(e) {
+  if (e === void 0) return { verdict: "n/a", evidence: "not measured: this capture had no page to read" };
+  if (e === null) return { verdict: "n/a", evidence: "edge probe failed on this capture" };
+  return { verdict: e.verdict, evidence: e.evidence };
+}
+function majority(id, answers, unansweredReason) {
+  const votes = answers.flatMap((a) => a.filter((x) => x.id === id));
+  if (votes.length === 0) return { verdict: "n/a", evidence: unansweredReason ?? "not answered" };
+  const counts = /* @__PURE__ */ new Map();
+  for (const v of votes) counts.set(v.verdict, (counts.get(v.verdict) ?? 0) + 1);
+  const ranked = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+  const top = ranked[0];
+  if (ranked.length > 1 && ranked[1][1] === top[1]) return { verdict: "n/a", evidence: "no majority" };
+  const evidence = votes.find((v) => v.verdict === top[0])?.evidence ?? "";
+  return { verdict: top[0], evidence };
+}
+function instrumentRead(kind, m) {
+  if (kind === "fit") {
+    if (m.contentHeight === null) return { verdict: "n/a", evidence: "content height unmeasurable" };
+    return { verdict: m.overflow ? "fail" : "pass", evidence: `content ${m.contentHeight}px against a ${m.viewportHeight}px box` };
+  }
+  if (m.inkRatio === null) return { verdict: "n/a", evidence: "capture unreadable" };
+  return { verdict: "n/a", evidence: `fill ${m.inkRatio.toFixed(3)} reported; no floor ruled` };
+}
+function readRow(row, answers, m, unansweredReason) {
+  if (row.evaluation === "judge" && REQUIRES_POST_ACTION_CAPTURE.has(row.id) && m.postActionCapture !== true) return { verdict: "n/a", evidence: NO_POST_ACTION };
+  if (row.evaluation === "judge") return majority(row.id, answers, unansweredReason);
+  if (row.evaluation === "human") return { verdict: "n/a", evidence: `reader's column (status ${row.status})` };
+  if (row.status !== "live") return { verdict: "n/a", evidence: `not implemented (status ${row.status})` };
+  const kind = INSTRUMENT_BY_ID[row.id];
+  return kind === void 0 ? { verdict: "n/a", evidence: "instrument not wired (status live, no binding)" } : instrumentRead(kind, m);
+}
+function resolveCriteriaBlock(args) {
+  const byId = new Map(bankRows(args.bank).map((r) => [r.id, r]));
+  const verdicts = [];
+  for (const s of args.selected.selection) {
+    const row = byId.get(s.id);
+    if (row === void 0) continue;
+    const read = readRow(row, args.answers, args.measurements, args.unansweredReason);
+    const beside = INSTRUMENT_BESIDE_JUDGE[row.id];
+    verdicts.push({
+      id: row.id,
+      severity: row.severity,
+      method: row.evaluation,
+      status: row.status,
+      source: s.source,
+      verdict: read.verdict,
+      evidence: read.evidence,
+      ...beside !== void 0 && row.evaluation === "judge" ? {
+        instrument: { ...besideRead(beside, args.measurements), id: EDGE_INSTRUMENT_IDS.v1 },
+        // #1765 — v2 beside v1 on the same capture, report-only, until its own fresh sealed draw.
+        instrumentV2: { ...edgeRead(args.measurements.edgeV2), id: EDGE_INSTRUMENT_IDS.v2 }
+      } : {}
+    });
+  }
+  return {
+    criteriaSetId: args.selected.criteriaSetId,
+    bankVersion: args.bank.version,
+    selectorVersion: CRITERIA_SELECTOR_VERSION,
+    context: args.context,
+    selection: args.selected.selection,
+    verdicts,
+    ...args.call !== void 0 ? {
+      call: {
+        answer: args.call.answer,
+        // Kept answers whose id names no row of the bank: the judge answered something nobody asked.
+        unknownIds: args.answers.flat().filter((a) => !byId.has(a.id)).length,
+        ...args.call.finishReason !== void 0 ? { finishReason: args.call.finishReason } : {}
+      }
+    } : {}
+  };
+}
+var CRITERIA_PROPS_MAX_CHARS = 2e3;
+function criteriaFrameLine(frame) {
+  const box = `${frame.width}\xD7${frame.height}`;
+  if (frame.fit === "framed-card") {
+    return `This frame is ${box}${frame.hostLabel !== void 0 ? ` (${frame.hostLabel})` : ""} with the card at its natural height at the top, inside the card's own frame \u2014 its surface, a thin ring of its ink and rounded corners \u2014 on the host's ground: the card is sized to its content, so judge composition and space within the card's own extent, and read the ground round it as the host's, not the card's.`;
+  }
+  if (frame.fit === "card") {
+    const framedBy = frame.hostLabel !== void 0 ? `inside the host's own frame (${frame.hostLabel}), on the host's ground` : "inside a generic stand-in for the host's frame \u2014 the card's surface with a thin ring and rounded corners, on the page ground";
+    return `This frame is an inline chat card captured at its natural height (at most ${box}, the host's ceiling), ${framedBy}: the host sizes the card to its content and draws that frame, so judge composition and space within the card's own extent, and read the frame and the ground round it as the host's, not the card's.`;
+  }
+  return `This frame is ${box}, a fixed full-screen box the card fills${frame.hostLabel !== void 0 ? ` (${frame.hostLabel})` : ""}: judge composition and space against the whole box, edge to edge.`;
+}
+function criteriaPropsSection(propsJson) {
+  const text = propsJson.length > CRITERIA_PROPS_MAX_CHARS ? `${propsJson.slice(0, CRITERIA_PROPS_MAX_CHARS)}\u2026 (truncated)` : propsJson;
+  return `The one input besides the frame \u2014 the props this card was rendered with. Read them ONLY for rows whose evidence names props (for example, whether a rendered string came from them); every other row is read off the frame alone:
+${text}
+`;
+}
+function buildCriteriaJudgeBlock(bank, selected, inputs = {}) {
+  const byId = new Map(bankRows(bank).map((r) => [r.id, r]));
+  const asked = selected.selection.map((s) => byId.get(s.id)).filter((r) => r !== void 0 && r.evaluation === "judge").filter((r) => inputs.postActionCapture === true || !REQUIRES_POST_ACTION_CAPTURE.has(r.id));
+  if (asked.length === 0) return "";
+  const lines = asked.map((r) => `- ${r.id} (${r.severity}): ${r.text} Evidence must name: ${r.evidence}`);
+  return "## Criteria \u2014 answer each one from the FRAME only\nRead these off the screenshot. Never infer them from the request, the styling profile or any direction text above.\n" + (inputs.frame !== void 0 ? `${criteriaFrameLine(inputs.frame)}
+` : "") + (inputs.propsJson !== void 0 ? criteriaPropsSection(inputs.propsJson) : "") + `${lines.join("\n")}
+Add to your JSON a top-level "criteria" array with exactly these ids: [{ "id": "<id>", "verdict": "pass" | "fail" | "n/a", "evidence": "<one sentence naming the region or element you read it from>" }]. Every row here was selected as applicable to this card, so "n/a" never means "does not apply": use it ONLY when this frame cannot show the criterion \u2014 it is then recorded as not evaluated.`;
+}
+var INK_TOLERANCE = 8;
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function decodePng(png) {
+  const buf = Buffer.from(png.buffer, png.byteOffset, png.byteLength);
+  if (buf.length < 8 + 25) return { reason: `not a PNG: ${buf.length} bytes` };
+  for (let i = 0; i < PNG_SIGNATURE.length; i++) {
+    if (buf[i] !== PNG_SIGNATURE[i]) return { reason: "not a PNG: signature mismatch" };
+  }
+  let width = 0;
+  let height = 0;
+  let channels = null;
+  const idat = [];
+  let offset = 8;
+  while (offset + 8 <= buf.length) {
+    const length = buf.readUInt32BE(offset);
+    const type = buf.toString("latin1", offset + 4, offset + 8);
+    const start = offset + 8;
+    if (start + length + 4 > buf.length) return { reason: `truncated PNG: ${type} chunk runs past the end` };
+    const data = buf.subarray(start, start + length);
+    if (type === "IHDR") {
+      if (length !== 13) return { reason: `malformed IHDR: ${length} bytes` };
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      const bitDepth = data[8];
+      const colorType = data[9];
+      const interlace = data[12];
+      if (bitDepth !== 8) return { reason: `unsupported PNG: bit depth ${bitDepth}` };
+      if (interlace !== 0) return { reason: "unsupported PNG: interlaced" };
+      if (colorType === 2) channels = 3;
+      else if (colorType === 6) channels = 4;
+      else return { reason: `unsupported PNG: colour type ${colorType}` };
+    } else if (type === "IDAT") {
+      idat.push(data);
+    } else if (type === "IEND") {
+      break;
+    }
+    offset = start + length + 4;
+  }
+  if (channels === null) return { reason: "malformed PNG: no IHDR" };
+  if (width === 0 || height === 0) return { reason: `empty PNG: ${width}\xD7${height}` };
+  if (idat.length === 0) return { reason: "malformed PNG: no IDAT" };
+  let raw;
+  try {
+    raw = inflateSync(Buffer.concat(idat));
+  } catch (error) {
+    return { reason: `corrupt IDAT stream: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const stride = width * channels;
+  if (raw.length !== (stride + 1) * height) {
+    return { reason: `malformed PNG: ${raw.length} raw bytes for ${width}\xD7${height}\xD7${channels}` };
+  }
+  const pixels = new Uint8Array(stride * height);
+  const bpp = channels;
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)];
+    const inRow = y * (stride + 1) + 1;
+    const outRow = y * stride;
+    const prevRow = outRow - stride;
+    for (let i = 0; i < stride; i++) {
+      const x = raw[inRow + i];
+      const a = i >= bpp ? pixels[outRow + i - bpp] : 0;
+      const b = y > 0 ? pixels[prevRow + i] : 0;
+      const c = y > 0 && i >= bpp ? pixels[prevRow + i - bpp] : 0;
+      let value;
+      switch (filter) {
+        case 0:
+          value = x;
+          break;
+        case 1:
+          value = x + a;
+          break;
+        case 2:
+          value = x + b;
+          break;
+        case 3:
+          value = x + (a + b >> 1);
+          break;
+        case 4: {
+          const p = a + b - c;
+          const pa = Math.abs(p - a);
+          const pb = Math.abs(p - b);
+          const pc = Math.abs(p - c);
+          value = x + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+          break;
+        }
+        default:
+          return { reason: `malformed PNG: scanline filter ${filter} at row ${y}` };
+      }
+      pixels[outRow + i] = value & 255;
+    }
+  }
+  return { width, height, channels, pixels };
+}
+function readInkExtent(png, insetPx = 0) {
+  const image = decodePng(png);
+  if ("reason" in image) return image;
+  const region = { x: insetPx, y: insetPx, width: image.width - 2 * insetPx, height: image.height - 2 * insetPx };
+  if (insetPx < 0 || region.width <= 0 || region.height <= 0) {
+    return { reason: `an inset of ${insetPx}px leaves nothing of a ${image.width}\xD7${image.height} image` };
+  }
+  const { channels, pixels, width } = image;
+  const counts = /* @__PURE__ */ new Map();
+  let ground = 0;
+  let groundCount = 0;
+  for (let y = region.y; y < region.y + region.height; y++) {
+    for (let x = region.x; x < region.x + region.width; x++) {
+      const i = (y * width + x) * channels;
+      const key = pixels[i] << 16 | pixels[i + 1] << 8 | pixels[i + 2];
+      const n = (counts.get(key) ?? 0) + 1;
+      counts.set(key, n);
+      if (n > groundCount) {
+        groundCount = n;
+        ground = key;
+      }
+    }
+  }
+  const gr = ground >> 16 & 255;
+  const gg = ground >> 8 & 255;
+  const gb = ground & 255;
+  let lastInkRow = null;
+  for (let y = region.y; y < region.y + region.height; y++) {
+    for (let x = region.x; x < region.x + region.width; x++) {
+      const i = (y * width + x) * channels;
+      if (Math.abs(pixels[i] - gr) > INK_TOLERANCE || Math.abs(pixels[i + 1] - gg) > INK_TOLERANCE || Math.abs(pixels[i + 2] - gb) > INK_TOLERANCE) {
+        lastInkRow = y - region.y;
+        break;
+      }
+    }
+  }
+  const ratio = lastInkRow === null ? 0 : Math.round((lastInkRow + 1) / region.height * 1e3) / 1e3;
+  return { ratio, lastInkRow, region, ground: [gr, gg, gb] };
+}
+function isDesignRenderingInput(relativePath) {
+  const rel = relativePath.split("\\").join("/");
+  if (rel.startsWith("__tests__/") || rel.includes("/__tests__/")) return false;
+  if (/\.test\.[cm]?[jt]sx?$/.test(rel)) return false;
+  if (/\.stories\.[cm]?[jt]sx?$/.test(rel)) return false;
+  if (rel.endsWith(".md")) return false;
+  return true;
+}
+function designTreeSha256(root) {
+  const base = resolve(root);
+  const files = [];
+  const walk = (dir) => {
+    for (const name of readdirSync(dir).sort()) {
+      const full = resolve(dir, name);
+      if (statSync(full).isDirectory()) walk(full);
+      else if (isDesignRenderingInput(relative(base, full))) files.push(full);
+    }
+  };
+  walk(base);
+  const h = createHash("sha256");
+  for (const f of files) {
+    h.update(relative(base, f) + "\n");
+    h.update(readFileSync(f));
+    h.update("\n");
+  }
+  return h.digest("hex");
+}
+var identityCache = /* @__PURE__ */ new Map();
+function judgeDesignIdentity(src) {
+  const key = resolve(src);
+  const cached = identityCache.get(key);
+  if (cached !== void 0) return cached;
+  let identity;
+  try {
+    identity = { src: key, srcSha256: designTreeSha256(key) };
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    console.warn(`[visual-eval] design tree unreadable at ${key} \u2014 the judgement carries no design identity (${reason})`);
+    identity = null;
+  }
+  identityCache.set(key, identity);
+  return identity;
+}
+function resetJudgeDesignIdentityCache() {
+  identityCache.clear();
+}
+
+// src/evaluation/criteria/edge.ts
+var EDGE_TOLERANCE_PX = 2;
+var CARD = "card";
+var same = (a, b) => Math.abs(a - b) <= EDGE_TOLERANCE_PX;
+var overlaps = (a, b) => a.left < b.right && b.left < a.right;
+var axis = (b) => (b.left + b.right) / 2;
+function contentEdge(surface, blocks) {
+  const texts = blocks.filter((b) => b.within === surface.id && b.kind !== "surface" && b.role !== "centred");
+  if (texts.length === 0) return void 0;
+  const first = texts.reduce((a, b) => b.top < a.top ? b : a);
+  return first.textEdge ?? first.edge;
+}
+function columns(direct) {
+  const all = direct.filter((b) => b.kind !== "surface");
+  const bridges = (b) => {
+    const under = all.filter((x) => x !== b && overlaps(x, b));
+    return under.some((x, i) => under.slice(i + 1).some((y) => !overlaps(x, y)));
+  };
+  const flow = all.filter((b) => !bridges(b));
+  const parentPool = all.filter((b) => bridges(b));
+  const parent = flow.map((_, i) => i);
+  const find = (i) => parent[i] === i ? i : parent[i] = find(parent[i]);
+  for (let i = 0; i < flow.length; i += 1) for (let j = i + 1; j < flow.length; j += 1) if (overlaps(flow[i], flow[j])) parent[find(i)] = find(j);
+  const groups = /* @__PURE__ */ new Map();
+  flow.forEach((b, i) => groups.set(find(i), [...groups.get(find(i)) ?? [], b]));
+  const cols = [...groups.values()];
+  for (const s of direct.filter((b) => b.kind === "surface")) {
+    const hit = cols.filter((c) => c.some((b) => b.kind !== "surface" && overlaps(b, s)));
+    if (hit.length === 1) hit[0].push(s);
+    else parentPool.push(s);
+  }
+  const lp = parentPool.map((_, i) => i);
+  const lfind = (i) => lp[i] === i ? i : lp[i] = lfind(lp[i]);
+  for (let i = 0; i < parentPool.length; i += 1) for (let j = i + 1; j < parentPool.length; j += 1) if (overlaps(parentPool[i], parentPool[j])) lp[lfind(i)] = lfind(j);
+  const lgroups = /* @__PURE__ */ new Map();
+  parentPool.forEach((b, i) => lgroups.set(lfind(i), [...lgroups.get(lfind(i)) ?? [], b]));
+  cols.push(...lgroups.values());
+  return cols;
+}
+function checkColumn(container, col, blocks) {
+  const surfaces = col.filter((b) => b.kind === "surface");
+  const grounds = surfaces.flatMap((s) => {
+    const c = s.role === "table" ? void 0 : contentEdge(s, blocks);
+    return c === void 0 ? [] : [c];
+  });
+  const flow = col.filter((b) => b.kind !== "surface" && b.role !== "centred" && b.role !== "list-item");
+  const listItems = col.filter((b) => b.role === "list-item");
+  const candidates = [...flow.flatMap((b) => [b.edge, ...b.textEdge !== void 0 ? [b.textEdge] : []]), ...surfaces.flatMap((s) => [s.edge]), ...grounds];
+  const blockEdges = (b) => [b.edge, ...b.textEdge !== void 0 ? [b.textEdge] : []];
+  const endEdgesBesides = (b) => [...surfaces.map((s) => s.right), ...flow.filter((x) => x !== b && x.kind === "controls").map((x) => x.right)];
+  let best = candidates.length === 0 ? [] : null;
+  for (const E of candidates) {
+    const allowed = [E, ...grounds];
+    const off = [];
+    for (const b of flow) {
+      if (blockEdges(b).some((x) => allowed.some((a) => same(x, a)))) continue;
+      if (b.kind === "controls" && endEdgesBesides(b).some((r) => same(b.right, r))) continue;
+      const nearest = allowed.reduce((n, a) => Math.abs(a - b.edge) < Math.abs(n - b.edge) ? a : n);
+      off.push({ container, block: b.id, at: b.edge, nearest, offPx: Math.abs(b.edge - nearest) });
+    }
+    for (const s of surfaces) {
+      const c = s.role === "table" ? void 0 : contentEdge(s, blocks);
+      if (same(s.edge, E) || c !== void 0 && same(c, E)) continue;
+      const nearest = c !== void 0 && Math.abs(c - E) < Math.abs(s.edge - E) ? c : s.edge;
+      off.push({ container, block: s.id, at: nearest, nearest: E, offPx: Math.abs(nearest - E) });
+    }
+    if (best === null || off.length < best.length || off.length === best.length && sum(off) < sum(best)) best = off;
+    if (best.length === 0) break;
+  }
+  const offsets = best ?? [];
+  if (listItems.length > 1) {
+    const e0 = listItems[0].edge;
+    for (const li of listItems.slice(1)) if (!same(li.edge, e0)) offsets.push({ container, block: li.id, at: li.edge, nearest: e0, offPx: Math.abs(li.edge - e0) });
+  }
+  const centred = col.filter((b) => b.role === "centred");
+  const edgeAligned = col.filter((b) => b.role !== "centred");
+  const groupTop = centred.length > 0 ? Math.min(...centred.map((c) => c.top)) : 0;
+  const groupEndsColumn = centred.length > 1 && edgeAligned.every((b) => b.top < groupTop);
+  if (centred.length > 0 && edgeAligned.some((b) => b.kind !== "surface") && !groupEndsColumn) {
+    const E = flow[0]?.edge ?? edgeAligned[0].edge;
+    for (const c of centred) offsets.push({ container, block: c.id, at: c.edge, nearest: E, offPx: Math.abs(c.edge - E), reason: "a centred block in an edge-aligned column" });
+  } else if (centred.length > 1) {
+    const a0 = axis(centred[0]);
+    for (const c of centred.slice(1)) if (!same(axis(c), a0)) offsets.push({ container, block: c.id, at: axis(c), nearest: a0, offPx: Math.abs(axis(c) - a0) });
+  }
+  return offsets;
+}
+var sum = (o) => o.reduce((s, x) => s + x.offPx, 0);
+function judgeEdges(measured, opts = {}) {
+  if (opts.placeholdersOnly === true) return { verdict: "n/a", offsets: [], evidence: "only loading placeholders are shown; not evaluated" };
+  let blocks = measured;
+  const kept = blocks.filter((b) => b.role !== "placeholder");
+  const content = kept.filter((b) => b.kind !== "surface").length;
+  if (content < 2) return { verdict: "n/a", offsets: [], evidence: kept.length === 0 ? "no blocks were measured" : "fewer than two blocks once placeholders are set aside; not evaluated" };
+  blocks = kept;
+  const offsets = [];
+  const containers = [CARD, ...blocks.filter((b) => b.kind === "surface" && b.role !== "table").map((b) => b.id)];
+  for (const container of containers) {
+    const direct = blocks.filter((b) => (b.within ?? CARD) === container);
+    for (const col of columns(direct)) offsets.push(...checkColumn(container, col, blocks));
+  }
+  if (offsets.length === 0) return { verdict: "pass", offsets, evidence: "every column shares its edge, or sits on a stacked surface\u2019s content edge, within 2 px" };
+  const worst = offsets.reduce((a, b) => b.offPx > a.offPx ? b : a);
+  const lines = offsets.map((o) => `${o.block} at x${round(o.at)} is ${round(o.offPx)} px from x${round(o.nearest)} (in ${o.container}${o.reason !== void 0 ? `; ${o.reason}` : ""})`);
+  return { verdict: "fail", offsets, evidence: `${offsets.length} block(s) off the allowed edges, largest ${round(worst.offPx)} px: ${lines.join("; ")}` };
+}
+var round = (n) => (Math.round(n * 10) / 10).toString();
+
+// src/evaluation/criteria/edge-v2.ts
+var CARD2 = "card";
+var same2 = (a, b) => Math.abs(a - b) <= EDGE_TOLERANCE_PX;
+var overlaps2 = (a, b) => a.left < b.right && b.left < a.right;
+var axis2 = (b) => (b.left + b.right) / 2;
+function contentEdge2(surface, blocks) {
+  const texts = blocks.filter((b) => b.within === surface.id && b.kind !== "surface" && b.role !== "centred");
+  if (texts.length === 0) return void 0;
+  const first = texts.reduce((a, b) => b.top < a.top ? b : a);
+  return first.textEdge ?? first.edge;
+}
+function columns2(direct) {
+  const all = direct.filter((b) => b.kind !== "surface");
+  const bridges = (b) => {
+    const under = all.filter((x) => x !== b && overlaps2(x, b));
+    return under.some((x, i) => under.slice(i + 1).some((y) => !overlaps2(x, y)));
+  };
+  const flow = all.filter((b) => !bridges(b));
+  const parentPool = all.filter((b) => bridges(b));
+  const parent = flow.map((_, i) => i);
+  const find = (i) => parent[i] === i ? i : parent[i] = find(parent[i]);
+  for (let i = 0; i < flow.length; i += 1) for (let j = i + 1; j < flow.length; j += 1) if (overlaps2(flow[i], flow[j])) parent[find(i)] = find(j);
+  const groups = /* @__PURE__ */ new Map();
+  flow.forEach((b, i) => groups.set(find(i), [...groups.get(find(i)) ?? [], b]));
+  const cols = [...groups.values()];
+  for (const s of direct.filter((b) => b.kind === "surface")) {
+    const hit = cols.filter((c) => c.some((b) => b.kind !== "surface" && overlaps2(b, s)));
+    if (hit.length === 1) hit[0].push(s);
+    else parentPool.push(s);
+  }
+  const lp = parentPool.map((_, i) => i);
+  const lfind = (i) => lp[i] === i ? i : lp[i] = lfind(lp[i]);
+  for (let i = 0; i < parentPool.length; i += 1) for (let j = i + 1; j < parentPool.length; j += 1) if (overlaps2(parentPool[i], parentPool[j])) lp[lfind(i)] = lfind(j);
+  const lgroups = /* @__PURE__ */ new Map();
+  parentPool.forEach((b, i) => lgroups.set(lfind(i), [...lgroups.get(lfind(i)) ?? [], b]));
+  cols.push(...lgroups.values());
+  return cols;
+}
+function checkColumn2(container, col, blocks) {
+  const surfaces = col.filter((b) => b.kind === "surface");
+  const grounds = surfaces.flatMap((s) => {
+    const c = s.role === "table" ? void 0 : contentEdge2(s, blocks);
+    return c === void 0 ? [] : [c];
+  });
+  const flow = col.filter((b) => b.kind !== "surface" && b.role !== "centred" && b.role !== "list-item");
+  const listItems = col.filter((b) => b.role === "list-item");
+  const candidates = [...flow.flatMap((b) => [b.edge, ...b.textEdge !== void 0 ? [b.textEdge] : []]), ...surfaces.flatMap((s) => [s.edge]), ...grounds];
+  const blockEdges = (b) => [b.edge, ...b.textEdge !== void 0 ? [b.textEdge] : []];
+  const endEdgesBesides = (b) => [...surfaces.map((s) => s.right), ...flow.filter((x) => x !== b && x.kind === "controls").map((x) => x.right)];
+  let best = candidates.length === 0 ? [] : null;
+  for (const E of candidates) {
+    const allowed = [E, ...grounds];
+    const off = [];
+    for (const b of flow) {
+      if (blockEdges(b).some((x) => allowed.some((a) => same2(x, a)))) continue;
+      if (b.kind === "controls" && endEdgesBesides(b).some((r) => same2(b.right, r))) continue;
+      const nearest = allowed.reduce((n, a) => Math.abs(a - b.edge) < Math.abs(n - b.edge) ? a : n);
+      off.push({ container, block: b.id, at: b.edge, nearest, offPx: Math.abs(b.edge - nearest) });
+    }
+    for (const s of surfaces) {
+      const c = s.role === "table" ? void 0 : contentEdge2(s, blocks);
+      if (same2(s.edge, E) || c !== void 0 && same2(c, E)) continue;
+      const nearest = c !== void 0 && Math.abs(c - E) < Math.abs(s.edge - E) ? c : s.edge;
+      off.push({ container, block: s.id, at: nearest, nearest: E, offPx: Math.abs(nearest - E) });
+    }
+    if (best === null || off.length < best.length || off.length === best.length && sum2(off) < sum2(best)) best = off;
+    if (best.length === 0) break;
+  }
+  const offsets = best ?? [];
+  if (listItems.length > 1) {
+    const e0 = listItems[0].edge;
+    for (const li of listItems.slice(1)) if (!same2(li.edge, e0)) offsets.push({ container, block: li.id, at: li.edge, nearest: e0, offPx: Math.abs(li.edge - e0) });
+  }
+  const centred = col.filter((b) => b.role === "centred");
+  const edgeAligned = col.filter((b) => b.role !== "centred");
+  const groupTop = centred.length > 0 ? Math.min(...centred.map((c) => c.top)) : 0;
+  const groupEndsColumn = centred.length > 1 && edgeAligned.every((b) => b.top < groupTop);
+  if (centred.length > 0 && edgeAligned.some((b) => b.kind !== "surface") && !groupEndsColumn) {
+    const E = flow[0]?.edge ?? edgeAligned[0].edge;
+    for (const c of centred) offsets.push({ container, block: c.id, at: c.edge, nearest: E, offPx: Math.abs(c.edge - E), reason: "a centred block in an edge-aligned column" });
+  } else if (centred.length > 1) {
+    const a0 = axis2(centred[0]);
+    for (const c of centred.slice(1)) if (!same2(axis2(c), a0)) offsets.push({ container, block: c.id, at: axis2(c), nearest: a0, offPx: Math.abs(axis2(c) - a0) });
+  }
+  return offsets;
+}
+var sum2 = (o) => o.reduce((s, x) => s + x.offPx, 0);
+var follower = (b) => b.follows !== void 0;
+var vOverlap = (a, b) => Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top) > 1;
+function judgeEdgesV2(measured, opts) {
+  if (opts.placeholdersOnly === true) return { verdict: "n/a", offsets: [], evidence: "only loading placeholders are shown; not evaluated" };
+  const content = measured.filter((b) => b.role !== "placeholder" && (b.kind === "text" || b.kind === "controls")).length;
+  if (content < 2) return { verdict: "n/a", offsets: [], evidence: measured.length === 0 ? "no blocks were measured" : "fewer than two blocks once placeholders are set aside; not evaluated" };
+  const byId = new Map(measured.map((b) => [b.id, b]));
+  const containerOf = (b) => b.within ?? CARD2;
+  const contentBoxOf = (container) => {
+    if (container === CARD2) return opts.cardContent;
+    const s = byId.get(container);
+    return s?.contentLeft !== void 0 && s.contentRight !== void 0 ? { left: s.contentLeft, right: s.contentRight } : void 0;
+  };
+  const leadsARow = (p) => measured.some((b) => b !== p && containerOf(b) === containerOf(p) && follower(b) && b.left >= p.right - 1 && vOverlap(b, p));
+  const holdsControl = (s) => {
+    const inside = (b) => {
+      for (let w = b.within; w !== void 0; w = byId.get(w)?.within) if (w === s.id) return true;
+      return false;
+    };
+    return measured.some((b) => b.kind === "controls" && inside(b));
+  };
+  const aloneOnItsLine = (m) => !measured.some((b) => b !== m && containerOf(b) === containerOf(m) && b.role !== "placeholder" && vOverlap(b, m));
+  const centredInContainer = (m) => {
+    const box = contentBoxOf(containerOf(m));
+    return box !== void 0 && same2((m.left + m.right) / 2, (box.left + box.right) / 2) && !same2(m.left, box.left);
+  };
+  const mediaKind = (b) => b.kind === "media" || b.kind === "surface" && b.role !== "table" && !holdsControl(b);
+  const blocks = measured.filter((b) => {
+    if (b.role === "placeholder") return leadsARow(b);
+    if (b.kind === "media" && centredInContainer(b)) return false;
+    return true;
+  });
+  const bleeds = (b) => b.kind === "surface" && containerOf(b) === CARD2 && b.left <= EDGE_TOLERANCE_PX && b.right >= opts.cardContent.right - EDGE_TOLERANCE_PX;
+  const judged = blocks.map((b) => bleeds(b) && b.contentLeft !== void 0 ? { ...b, edge: b.contentLeft } : b);
+  const rightAnchored = (b) => {
+    const box = contentBoxOf(containerOf(b));
+    const ends = (r) => r !== void 0 && same2(b.right, r);
+    return (ends(box?.right) || ends(b.parentRight)) && box !== void 0 && b.left >= (box.left + box.right) / 2 && !bleeds(b);
+  };
+  const offsets = [];
+  const containers = [CARD2, ...judged.filter((b) => b.kind === "surface" && b.role !== "table").map((b) => b.id)];
+  for (const container of containers) {
+    const inContainer = judged.filter((b) => containerOf(b) === container);
+    const direct = inContainer.filter((b) => !follower(b) && !rightAnchored(b));
+    for (const col of columns2(direct)) {
+      const only = col.length === 1 ? col[0] : void 0;
+      if (only !== void 0 && mediaKind(only) && aloneOnItsLine(only) && centredInContainer(only)) continue;
+      offsets.push(...checkColumn2(container, col, judged));
+    }
+    const items = /* @__PURE__ */ new Map();
+    for (const b of inContainer.filter(follower)) items.set(b.item ?? b.id, [...items.get(b.item ?? b.id) ?? [], b]);
+    for (const [item, group] of items) for (const col of columns2(group)) offsets.push(...checkColumn2(`${container} \u203A ${item}`, col, judged));
+  }
+  if (offsets.length === 0) return { verdict: "pass", offsets, evidence: "every column shares its content edge, every row item after its leader shares its own, within 2 px" };
+  const worst = offsets.reduce((a, b) => b.offPx > a.offPx ? b : a);
+  const lines = offsets.map((o) => `${o.block} at x${round2(o.at)} is ${round2(o.offPx)} px from x${round2(o.nearest)} (in ${o.container}${o.reason !== void 0 ? `; ${o.reason}` : ""})`);
+  return { verdict: "fail", offsets, evidence: `${offsets.length} block(s) off the allowed edges, largest ${round2(worst.offPx)} px: ${lines.join("; ")}` };
+}
+var round2 = (n) => (Math.round(n * 10) / 10).toString();
+
+// src/evaluation/visual-evaluator.ts
+function canvasFitPolicy(canvas) {
+  switch (canvas) {
+    case "xs-chat-card":
+      return { capture: "natural", overflow: "fail" };
+    case "mobile-fullscreen-small":
+      return { capture: "full-page", overflow: "warn" };
+    default:
+      return { capture: "full-page", overflow: "none" };
+  }
+}
+var JUDGE_SCOPE_CLASS = "ggui-judge-scope";
+var JUDGE_PANEL_CLASS = "ggui-judge-panel";
+var JUDGE_INK_INSET_PX = EXPANDED_FRAME.insetPx + 24 + 1;
+function canvasFit(canvas) {
+  return displayModeForCanvas(canvas) === "fullscreen" ? "fill" : void 0;
+}
+var JUDGE_GROUND_MARGIN_PX = EXPANDED_FRAME.insetPx;
+var JUDGE_GROUND_CLASS = "ggui-judge-ground";
+var JUDGE_INLINE_FRAME_CLASS = "ggui-judge-inline-frame";
+var JUDGE_INLINE_FRAME_BORDER_PX = 1;
+var JUDGE_INLINE_FRAME_RADIUS_PX = 16;
+var JUDGE_INLINE_PAD_PX = JUDGE_GROUND_MARGIN_PX + JUDGE_INLINE_FRAME_BORDER_PX;
+var JUDGE_INLINE_INK_INSET_PX = JUDGE_INLINE_PAD_PX + JUDGE_INLINE_FRAME_RADIUS_PX;
+var HOST_COLOUR_PATTERN = /^#[0-9a-f]{6}$/;
+var HOST_FRAME_BOUNDS = {
+  ringWidthPx: { min: 0, max: 8 },
+  ringAlpha: { min: 0, max: 1 },
+  radiusPx: { min: 0, max: 64 },
+  minHeightPx: { min: 0, max: 2560 }
+};
+function resolvePresentation(canvas, p) {
+  if (p === void 0) return void 0;
+  const ignored = (reason, why) => {
+    console.warn(`[visual-eval] host presentation for ${canvas} ignored (${reason}): ${why}`);
+    return { status: "ignored", reason };
+  };
+  const inline = canvasFitPolicy(canvas).capture === "natural";
+  if (typeof p.label !== "string" || p.label.length === 0) return ignored("label_missing", "no label");
+  if (p.ground !== void 0 && !HOST_COLOUR_PATTERN.test(p.ground)) return ignored("color_not_hex", "ground is not #rrggbb");
+  if (inline && p.ground !== void 0) return ignored("ground_on_inline", "the inline card's room is its frame's ground");
+  const f = p.frame;
+  if (f !== void 0) {
+    if (!inline) return ignored("frame_off_inline", "a frame on a canvas that is not the inline card");
+    if (![f.surface, f.ground, f.ring.color].every((c) => HOST_COLOUR_PATTERN.test(c))) return ignored("color_not_hex", "a frame colour is not #rrggbb");
+    const B = HOST_FRAME_BOUNDS;
+    const inRange = (n, b) => Number.isFinite(n) && n >= b.min && n <= b.max;
+    if (!inRange(f.ring.widthPx, B.ringWidthPx) || !inRange(f.ring.alpha, B.ringAlpha) || !inRange(f.radiusPx, B.radiusPx)) return ignored("frame_malformed", "a frame number out of range");
+    if (f.minHeightPx !== void 0 && !inRange(f.minHeightPx, B.minHeightPx)) return ignored("frame_malformed", "minHeightPx out of range");
+  }
+  return { status: "applied", applied: p };
+}
+function inlineGeometry(frame) {
+  if (frame === void 0) return { padPx: JUDGE_INLINE_PAD_PX, inkInsetPx: JUDGE_INLINE_INK_INSET_PX, floorPx: void 0 };
+  const padPx = JUDGE_GROUND_MARGIN_PX + frame.ring.widthPx;
+  return { padPx, inkInsetPx: padPx + frame.radiusPx, floorPx: frame.minHeightPx };
+}
+function canvasChrome(canvas) {
+  if (canvasFitPolicy(canvas).capture === "natural") return "ground";
+  return canvasFit(canvas) === "fill" && canvas !== "mobile-fullscreen-small" ? "panel" : void 0;
+}
+function judgeWindow(viewport, chrome, inlinePadPx = JUDGE_INLINE_PAD_PX) {
+  if (chrome === void 0) return viewport;
+  const gap = 2 * (chrome === "ground" ? inlinePadPx : EXPANDED_FRAME.insetPx);
+  return { width: viewport.width + gap, height: viewport.height + gap };
+}
+function cardHeight(documentHeight, chrome) {
+  if (documentHeight === null || chrome === void 0 || chrome === "ground") return documentHeight;
+  const gap = 2 * EXPANDED_FRAME.insetPx;
+  return documentHeight < gap ? null : documentHeight - gap;
+}
+function integerBox(viewport) {
+  return { width: Math.round(viewport.width), height: Math.round(viewport.height) };
+}
+function isDeclaredViewport(canvas, viewport) {
+  const classBox = CANVAS_VIEWPORTS[canvas];
+  return viewport.width !== classBox.width || viewport.height !== classBox.height;
+}
+function canvasOverflowIssue(canvas, viewport, contentHeight, verdict) {
+  const hidden = contentHeight - viewport.height;
+  const classBox = CANVAS_VIEWPORTS[canvas];
+  const box = isDeclaredViewport(canvas, viewport) ? `declared ${viewport.width}\xD7${viewport.height}; class box ${classBox.width}\xD7${classBox.height}` : `${viewport.width}\xD7${viewport.height}`;
+  return {
+    dimension: "canvas-overflow",
+    origin: "instrument",
+    severity: verdict === "fail" ? "critical" : "major",
+    description: `Rendered content is ${contentHeight}px tall on the ${canvas} canvas (${box}) \u2014 ${hidden}px ${verdict === "fail" ? "is cut off: the inline card does not scroll" : "sits below the first screen"}.`,
+    fix: "Fit the composition to the canvas: fewer and shorter sections, one compact row of chips, no hero taller than a third of the box, no fixed min-heights or tall paddings \u2014 measure against the canvas, not the page."
+  };
+}
+function canvasOverflowXIssue(canvas, viewport, hiddenPx, verdict) {
+  return {
+    dimension: "canvas-overflow-x",
+    origin: "instrument",
+    severity: verdict === "fail" ? "critical" : "major",
+    description: `Content runs ${hiddenPx}px past the ${canvas} card's ${viewport.width}px width \u2014 the card's frame clips it, so a visitor sees a cut-off row or a sideways scroll.`,
+    fix: "Keep every row within the card: wrap long text (overflow-wrap: anywhere), let a wide table or code block scroll inside its own container, and give no child a fixed width wider than the card."
+  };
+}
+function canvasBlankIssue(canvas, viewport) {
+  const classBox = CANVAS_VIEWPORTS[canvas];
+  const box = isDeclaredViewport(canvas, viewport) ? `declared ${viewport.width}\xD7${viewport.height}; class box ${classBox.width}\xD7${classBox.height}` : `${viewport.width}\xD7${viewport.height}`;
+  return {
+    dimension: "canvas-blank",
+    origin: "instrument",
+    severity: "critical",
+    description: `Nothing painted on the ${canvas} canvas (${box}): the capture is one flat colour \u2014 the component mounted and rendered no pixels.`,
+    fix: "Return and paint the component tree: a root that renders nothing is a blank, not an empty state. Check that the default export returns its JSX, that no early return yields null on the sample props, and that the first paint shows visible content."
+  };
+}
+function resolveUiGenPackageDir() {
+  return findPackageRootAbove(dirname(fileURLToPath(import.meta.url)), "@ggui-ai/ui-gen");
+}
+function findPackageRootAbove(start, name) {
+  for (let dir = start; ; dir = dirname(dir)) {
+    const manifest = resolve(dir, "package.json");
+    if (existsSync(manifest) && readPackageName(manifest) === name) return dir;
+    if (dirname(dir) === dir) throw new Error(`${name}: no package.json named ${name} at or above ${start}`);
+  }
+}
+function readPackageName(manifest) {
+  const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+  return typeof parsed === "object" && parsed !== null && "name" in parsed && typeof parsed.name === "string" ? parsed.name : void 0;
+}
+function resolveWirePackageDir() {
+  const uiGenDir = resolveUiGenPackageDir();
+  const candidates = [
+    resolve(uiGenDir, "node_modules", "@ggui-ai", "wire"),
+    // workspace / nested install
+    resolve(uiGenDir, "..", "wire"),
+    // pnpm deploy: `.pnpm/<ui-gen>@<ver>/node_modules/@ggui-ai/{ui-gen,wire}`
+    resolve(uiGenDir, "..", "..", "@ggui-ai", "wire")
+    // hoisted flat install beside the scope dir
+  ];
+  for (const dir of candidates) {
+    if (existsSync(resolve(dir, "package.json"))) return dir;
+  }
+  try {
+    const entry = fileURLToPath(import.meta.resolve("@ggui-ai/wire"));
+    let dir = dirname(entry);
+    for (let i = 0; i < 6; i++) {
+      if (existsSync(resolve(dir, "package.json"))) return dir;
+      dir = dirname(dir);
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveDesignPackageDir() {
+  try {
+    return dirname(createRequire(import.meta.url).resolve("@ggui-ai/design/package.json"));
+  } catch {
+    const selfDir = dirname(fileURLToPath(import.meta.url));
+    return resolve(selfDir, "..", "..", "..", "design");
+  }
+}
+async function bundleForRendering(compiledCode, sampleProps, designSrc = resolve(resolveDesignPackageDir(), "src")) {
+  const tmpDir = mkdtempSync(resolve(tmpdir(), "ggui-visual-eval-"));
+  const componentFile = resolve(tmpDir, "component.tsx");
+  const entryFile = resolve(tmpDir, "entry.tsx");
+  const designPkgDir = resolve(designSrc, "..");
+  const wirePkgDir = resolveWirePackageDir();
+  writeFileSync(componentFile, compiledCode);
+  const entryCode = `
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { GguiWireProvider } from '@ggui-ai/wire';
+import Component from './component.tsx';
+
+const props = ${JSON.stringify(sampleProps)};
+const wireConfig = {
+  app: { appId: 'visual-eval', appName: 'Visual evaluation' },
+  render: { sessionId: 'visual-eval', isConnected: true },
+  auth: { isAuthenticated: false },
+  dispatch: () => {},
+  subscribe: () => () => {},
+};
+class RenderErrorBoundary extends React.Component<{ children: React.ReactNode }, { message: string | null }> {
+  state = { message: null as string | null };
+  static getDerivedStateFromError(err: unknown) { return { message: err instanceof Error ? err.message : String(err) }; }
+  render() {
+    return this.state.message === null
+      ? this.props.children
+      : React.createElement('div', { className: 'error' }, 'Render error: ' + this.state.message);
+  }
+}
+const root = createRoot(document.getElementById('root')!);
+try {
+  root.render(
+    React.createElement(GguiWireProvider, { config: wireConfig },
+      React.createElement(RenderErrorBoundary, null, React.createElement(Component, props))),
+  );
+} catch (err) {
+  root.render(React.createElement('div', { className: 'error' }, 'Render error: ' + (err as Error).message));
+}
+`;
+  writeFileSync(entryFile, entryCode);
+  try {
+    const result = await build({
+      entryPoints: [entryFile],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "browser",
+      target: "es2020",
+      jsx: "automatic",
+      jsxImportSource: "react",
+      external: ["react", "react-dom", "react-dom/client", "react/jsx-runtime"],
+      alias: {
+        // The wire hooks: resolved from ui-gen's own module graph so the
+        // alias holds in a workspace checkout AND in a `pnpm deploy` image
+        // (where deps are siblings, not children, of this package).
+        ...wirePkgDir !== null ? { "@ggui-ai/wire": wirePkgDir } : {},
+        // D1: generated code imports the single `@ggui-ai/design` barrel.
+        // The subpath aliases stay for any first-party / legacy code.
+        "@ggui-ai/design": resolve(designPkgDir, "src", "index.ts"),
+        "@ggui-ai/design/primitives": resolve(designPkgDir, "src", "primitives", "index.ts"),
+        "@ggui-ai/design/components": resolve(designPkgDir, "src", "components", "index.ts"),
+        "@ggui-ai/design/compositions": resolve(designPkgDir, "src", "compositions", "index.ts"),
+        "@ggui-ai/design/interact": resolve(designPkgDir, "src", "interact", "index.ts")
+      },
+      // Bare imports in the generated component resolve against ui-gen's
+      // own node_modules — the temp entry dir has none. Without this every
+      // wire-bearing component (`@ggui-ai/wire`) failed to bundle.
+      // Workspace layout (deps under this package's node_modules) and the
+      // `pnpm deploy` layout (deps as siblings of this package) — both
+      // searched for any other allowlisted bare import.
+      nodePaths: [resolve(resolveUiGenPackageDir(), "node_modules"), resolve(resolveUiGenPackageDir(), "..")],
+      logLevel: "silent"
+    });
+    return result.outputFiles[0]?.text ?? "";
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function inlineFrameDecls(frame) {
+  if (frame === void 0) {
+    return `background: var(--ggui-color-container); border: ${JUDGE_INLINE_FRAME_BORDER_PX}px solid color-mix(in srgb, var(--ggui-color-onContainer) 8%, transparent); border-radius: ${JUDGE_INLINE_FRAME_RADIUS_PX}px; overflow: hidden;`;
+  }
+  const alphaPct = Math.round(frame.ring.alpha * 1e3) / 10;
+  return `background: ${frame.surface}; border: ${frame.ring.widthPx}px solid color-mix(in srgb, ${frame.ring.color} ${alphaPct}%, transparent); border-radius: ${frame.radiusPx}px; overflow: hidden;`;
+}
+function buildRenderHTML(bundledCode, cssTokens, fit, chrome, presentation, framedCardRadiusPx) {
+  const framedCard = framedCardRadiusPx !== void 0;
+  if (chrome === "panel" && fit !== "fill" && !framedCard) throw new Error("the judge's panel frames a fill canvas only (ggui#1083 cut 3)");
+  if (chrome === "ground" && fit === "fill") throw new Error("the host ground frames an inline card only \u2014 a fill canvas has no natural height (ggui#1475)");
+  const tokens = cssTokens ?? getCssTokens();
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    ${tokens}
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: var(--ggui-font-family-sans, system-ui, -apple-system, sans-serif);
+      /* ggui#1083 \u2014 the host stand-in (neutral-50) under the theme's scrim (its tint at
+         its opacity): the ground a frosted host puts under the card, so the judge scores
+         the card where the visitor sees it. */
+      ${presentation?.frame !== void 0 ? `background: ${presentation.frame.ground};` : presentation?.ground !== void 0 ? `background: ${presentation.ground};` : expandedFrameScrimDecls()}
+      color: var(--ggui-color-neutral-900, #111827);
+    }
+    .error { color: #dc2626; padding: 16px; font-family: monospace; white-space: pre-wrap; }
+    ${/* ggui#1765 — the fit's rules come from the ONE selection the runtime's composeThemeCss uses. */
+  mountFitCss(JUDGE_SCOPE_CLASS, fit === "fill" ? "fill" : framedCard ? "framed-card" : "card", framedCardRadiusPx ?? null)}
+    ${fit === "fill" && chrome === "panel" ? expandedFramePanelRule(JUDGE_PANEL_CLASS, JUDGE_SCOPE_CLASS) : ""}
+    ${framedCard ? `.${JUDGE_PANEL_CLASS} { ${expandedFramePanelDecls()} background: ${FRAMED_CARD_GROUND}; display: flow-root; } body > .${JUDGE_PANEL_CLASS} { margin: ${EXPANDED_FRAME.insetPx}px; height: calc(100vh - ${2 * EXPANDED_FRAME.insetPx}px); }` : ""}
+    ${framedCard && chrome !== "panel" ? `body { background: ${FRAMED_CARD_GROUND}; }` : ""}
+    ${chrome === "ground" ? `.${JUDGE_GROUND_CLASS} { padding: ${JUDGE_GROUND_MARGIN_PX}px; } .${JUDGE_INLINE_FRAME_CLASS} { ${inlineFrameDecls(presentation?.frame)} }` : ""}
+  </style>
+</head>
+<body>
+  ${chrome === "panel" ? `<div class="${JUDGE_PANEL_CLASS}">` : chrome === "ground" ? `<div class="${JUDGE_GROUND_CLASS}"><div class="${JUDGE_INLINE_FRAME_CLASS}">` : ""}<div id="root" class="${JUDGE_SCOPE_CLASS}"></div>${chrome === "panel" ? "</div>" : chrome === "ground" ? "</div></div>" : ""}
+  <script type="importmap">
+  {
+    "imports": {
+      "react": "https://esm.sh/react@18",
+      "react-dom": "https://esm.sh/react-dom@18",
+      "react-dom/client": "https://esm.sh/react-dom@18/client",
+      "react/jsx-runtime": "https://esm.sh/react@18/jsx-runtime"
+    }
+  }
+  </script>
+  <script type="module">
+${bundledCode}
+  </script>
+</body>
+</html>`;
+}
+var EXECUTABLE_PATH_LAUNCH_ARGS = ["--no-sandbox", "--disable-dev-shm-usage"];
+var DEFAULT_SCREENSHOT_VIEWPORT = { width: 1280, height: 800 };
+async function loadSparticuzChromium() {
+  const chromium = await import('@sparticuz/chromium');
+  return chromium.default;
+}
+async function resolveLaunchOptions(viewport, deps = {}) {
+  const env = deps.env ?? process.env;
+  const override = env.PUPPETEER_EXECUTABLE_PATH?.trim();
+  const defaultViewport = integerBox(viewport);
+  if (override) {
+    return {
+      executablePath: override,
+      args: [...EXECUTABLE_PATH_LAUNCH_ARGS],
+      defaultViewport,
+      headless: true
+    };
+  }
+  const chromium = await (deps.loadChromium ?? loadSparticuzChromium)();
+  return {
+    args: chromium.args,
+    defaultViewport,
+    executablePath: await chromium.executablePath(),
+    headless: true
+  };
+}
+async function launchWithPuppeteer(options) {
+  const puppeteer = await import('puppeteer-core');
+  return puppeteer.default.launch(options);
+}
+var CONTENT_HEIGHT_EXPRESSION = "Math.max(document.documentElement.scrollHeight, document.body ? document.body.scrollHeight : 0)";
+function cardHeightExpression(padPx) {
+  return `(() => { const el = document.documentElement; const prev = el.style.height; el.style.height = 'max-content'; const h = Math.ceil(el.getBoundingClientRect().height); el.style.height = prev; return h - ${2 * padPx}; })()`;
+}
+var CARD_HEIGHT_EXPRESSION = cardHeightExpression(JUDGE_INLINE_PAD_PX);
+var OVERFLOW_X_ROUNDING_PX = 1;
+var CARD_OVERFLOW_X_EXPRESSION = "(() => { const r = document.getElementById('root'); return r ? Math.max(0, Math.ceil(r.scrollWidth - r.clientWidth)) : null; })()";
+function naturalClip(window, cardHeightPx, padPx = JUDGE_INLINE_PAD_PX) {
+  const m = padPx;
+  const box = window.height - 2 * m;
+  return { x: 0, y: 0, width: window.width, height: Math.max(1, Math.min(Math.ceil(cardHeightPx), box)) + 2 * m };
+}
+var CARD_BOX_EXPRESSION = `(() => { const r = document.querySelector('.${JUDGE_SCOPE_CLASS}'); if (!r) return null; const b = r.getBoundingClientRect(); return { x: b.x, y: b.y, width: b.width, height: b.height }; })()`;
+async function measureCardBox(page) {
+  try {
+    const v = await page.evaluate(CARD_BOX_EXPRESSION);
+    if (typeof v !== "object" || v === null) return null;
+    const n = (k) => {
+      const x2 = Reflect.get(v, k);
+      return typeof x2 === "number" && Number.isFinite(x2) ? x2 : null;
+    };
+    const [x, y, width, height] = [n("x"), n("y"), n("width"), n("height")];
+    return x === null || y === null || width === null || height === null || width <= 0 || height <= 0 ? null : { x, y, width, height };
+  } catch (e) {
+    console.warn(`[visual-eval] card box unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+function cardBoxClip(window, box) {
+  const m = JUDGE_GROUND_MARGIN_PX;
+  const x = Math.max(0, Math.floor(box.x - m));
+  const y = Math.max(0, Math.floor(box.y - m));
+  return { x, y, width: Math.min(window.width - x, Math.ceil(box.width + 2 * m)), height: Math.max(1, Math.min(window.height - y, Math.ceil(box.height + 2 * m))) };
+}
+async function measureContentHeight(page, expression = CONTENT_HEIGHT_EXPRESSION) {
+  try {
+    const h = await page.evaluate(expression);
+    return typeof h === "number" && Number.isFinite(h) ? Math.round(h) : null;
+  } catch (e) {
+    console.warn(`[visual-eval] content height unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+async function measureEdges(page) {
+  return { edge: await measureEdgesV1(page), edgeV2: await measureEdgesV2(page) };
+}
+async function measureEdgesV2(page) {
+  try {
+    const probe = parseEdgeProbeV2(await page.evaluate(EDGE_BLOCKS_V2_EXPRESSION));
+    if (probe === null) {
+      console.warn("[visual-eval] edge probe v2 unavailable: the page returned no readable blocks");
+      return null;
+    }
+    return judgeEdgesV2(probe.blocks, { cardContent: probe.cardContent, placeholdersOnly: probe.placeholdersOnly });
+  } catch (e) {
+    console.warn(`[visual-eval] edge probe v2 unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+async function measureEdgesV1(page) {
+  try {
+    const probe = parseEdgeProbe(await page.evaluate(EDGE_BLOCKS_EXPRESSION));
+    if (probe === null) {
+      console.warn("[visual-eval] edge probe unavailable: the page returned no readable blocks");
+      return null;
+    }
+    return judgeEdges(probe.blocks, { placeholdersOnly: probe.placeholdersOnly });
+  } catch (e) {
+    console.warn(`[visual-eval] edge probe unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+async function captureScreenshotDetailed(html, viewport = DEFAULT_SCREENSHOT_VIEWPORT, deps = {}, capture = "full-page", natural = { padPx: JUDGE_INLINE_PAD_PX }) {
+  try {
+    const launchOptions = await resolveLaunchOptions(viewport, deps);
+    const browser = await (deps.launch ?? launchWithPuppeteer)(launchOptions);
+    try {
+      const page = await browser.newPage();
+      await page.setContent(html, { waitUntil: "load", timeout: 15e3 });
+      await page.waitForNetworkIdle({ idleTime: 500, timeout: 15e3 }).catch(() => {
+      });
+      await page.waitForSelector("#root > *", { timeout: 1e4 }).catch(() => {
+      });
+      await new Promise((r) => setTimeout(r, deps.settleMs ?? 1e3));
+      if (capture === "natural") {
+        const cardHeightPx = await measureContentHeight(page, natural.padPx === JUDGE_INLINE_PAD_PX ? CARD_HEIGHT_EXPRESSION : cardHeightExpression(natural.padPx));
+        const overflowX = await measureContentHeight(page, CARD_OVERFLOW_X_EXPRESSION);
+        const floorPx = natural.floorPx;
+        if (floorPx !== void 0 && cardHeightPx !== null && cardHeightPx < floorPx) {
+          await page.evaluate(`(() => { const f = document.querySelector('.${JUDGE_INLINE_FRAME_CLASS}'); if (f) f.style.minHeight = '${floorPx}px'; })()`);
+        }
+        const framed = cardHeightPx === null ? viewport.height - 2 * natural.padPx : floorPx !== void 0 ? Math.max(cardHeightPx, floorPx) : cardHeightPx;
+        const clip = naturalClip(viewport, framed, natural.padPx);
+        const edges2 = await measureEdges(page);
+        const screenshot2 = await page.screenshot({ type: "png", fullPage: false, clip });
+        return { png: Buffer.from(screenshot2), contentHeight: cardHeightPx, overflowX, ...edges2 };
+      }
+      if (capture === "card-box") {
+        const box = await measureCardBox(page);
+        if (box === null) return { png: null, reason: `card-box capture: the card's own box (.${JUDGE_SCOPE_CLASS}) could not be measured`, contentHeight: null };
+        const clip = cardBoxClip(viewport, box);
+        const edges2 = await measureEdges(page);
+        const screenshot2 = await page.screenshot({ type: "png", fullPage: false, clip });
+        return { png: Buffer.from(screenshot2), contentHeight: Math.round(box.height), ...edges2 };
+      }
+      const contentHeight = await measureContentHeight(page);
+      const edges = await measureEdges(page);
+      const screenshot = await page.screenshot({ type: "png", fullPage: capture === "full-page" });
+      return { png: Buffer.from(screenshot), contentHeight, ...edges };
+    } finally {
+      await browser.close();
+    }
+  } catch (e) {
+    const reason = `screenshot failed: ${e instanceof Error ? e.message : String(e)}`;
+    console.warn(`[visual-eval] ${reason}`);
+    return { png: null, reason, contentHeight: null };
+  }
+}
+async function captureScreenshot(html, viewport = DEFAULT_SCREENSHOT_VIEWPORT, deps = {}) {
+  return (await captureScreenshotDetailed(html, viewport, deps)).png;
+}
+var VISUAL_EVAL_PROMPT = `You are a visual quality evaluator for ggui \u2014 a platform where AI agents generate React UI components on demand.
+
+## Context
+The screenshot shows a generated React component built from a design system with CSS variable theming. The component was created by an LLM to fulfill a user's request. Your job is to evaluate whether the generated UI achieves the user's goal AND looks professionally designed.
+
+## Scoring Dimensions (0-100 each)
+
+1. **completeness** (25%): Does the screenshot show ALL features the user requested? Are all sections, controls, data fields, and interactive elements present? Missing features or sections = major deduction. Compare against the original request carefully.
+
+2. **layout** (25%): Is the layout well-composed? Clear sections and grouping? No overlapping elements? Proper spacing between elements? Responsive-looking? Does it look like a professional app UI, not a homework project?
+
+3. **hierarchy** (25%): Clear visual hierarchy? Headings are visually distinct from body text? Primary actions (buttons) are prominent? Information grouped logically with clear section breaks? Color and size used to guide the eye?
+
+4. **aesthetics** (25%): Professional, polished appearance? Consistent color palette? Good use of whitespace \u2014 not too sparse, not too cluttered? Cards, shadows, and borders used effectively? Does it look like something a designer would approve? Would you be comfortable showing this to a client?
+
+## Scoring Guide
+- 90-100: Production-ready. Would ship to real users. Polished layout, clear hierarchy, professional aesthetics.
+- 80-89: Good quality. Minor improvements needed (slightly tight spacing, one section could be better grouped).
+- 70-79: Acceptable but generic. Works correctly but lacks design polish or visual refinement.
+- 60-69: Below standard. Noticeable problems \u2014 cramped layout, poor hierarchy, or missing sections.
+- Below 60: Broken or fundamentally incomplete. Error messages visible, blank areas, or critical features missing.
+
+## Important
+- Check the screenshot against the "Original Request" \u2014 does it actually deliver what was asked for?
+- Error messages like "Render error" or blank white space = rendering score 0
+- A component that renders but is just a wall of text with no structure should score low on layout and hierarchy
+
+List AT MOST 6 issues, most severe first, one sentence each for "description" and "fix" \u2014 a longer list is cut off and lost.
+
+Respond with ONLY a JSON object (no markdown, no explanation):
+{
+  "completeness": <0-100>,
+  "layout": <0-100>,
+  "hierarchy": <0-100>,
+  "aesthetics": <0-100>,
+  "issues": [
+    { "dimension": "<dimension>", "severity": "<critical|major|minor>", "description": "<what's wrong>", "fix": "<specific fix>" }
+  ],
+  "critique": "<2-3 sentences: what's good, what needs improvement, does it achieve the user's goal?>"
+}`;
+var VISUAL_JUDGE_MAX_OUTPUT_TOKENS = 4096;
+var VISUAL_JUDGE_PROMPT_VERSION = "v2-bounded-issues";
+var VISUAL_JUDGE_PROMPT_DIGEST = createHash("sha256").update(VISUAL_EVAL_PROMPT, "utf8").digest("hex");
+async function callMultimodalLLM(config, model, prompt, screenshot, originalPrompt, profileBlock = "", criteriaBlock = "") {
+  const userPrompt = `## Original Request
+${originalPrompt}
+
+` + (profileBlock.length > 0 ? `${profileBlock}
+
+` : "") + (criteriaBlock.length > 0 ? `${criteriaBlock}
+
+` : "") + "Evaluate the screenshot of the generated component.";
+  const agent = createVisionAgent({
+    provider: config.provider === "claude" ? "anthropic" : config.provider,
+    model,
+    routeOverride: config.routeOverride,
+    onRetry: config.onRetry
+  });
+  return agent.callVision(
+    model,
+    prompt,
+    userPrompt,
+    { mediaType: "image/png", base64: screenshot.toString("base64") },
+    VISUAL_JUDGE_MAX_OUTPUT_TOKENS
+  );
+}
+function mountCanvasOf(compiledCode) {
+  const name = GGUI_MOUNT_CANVAS_EXPORT;
+  const binding = new RegExp(`([A-Za-z_$][\\w$]*)\\s+as\\s+${name}\\b`).exec(compiledCode)?.[1] ?? name;
+  return new RegExp(`(?:^|[^\\w$.])${binding.replace(/\$/g, "\\$")}\\s*=\\s*"([^"\\\\]*)"`).exec(compiledCode)?.[1];
+}
+function themeVarsOf(css) {
+  const vars = {};
+  for (const [, name, value] of css.matchAll(/(--ggui-[\w-]+)\s*:\s*([^;}]+)/g)) {
+    if (name !== void 0 && value !== void 0) vars[name] = value.trim();
+  }
+  return vars;
+}
+function readInk(png, chrome, canvas, inlineInkInsetPx = JUDGE_INLINE_INK_INSET_PX) {
+  if (png === null) return null;
+  const ink = readInkExtent(png, chrome === "panel" ? JUDGE_INK_INSET_PX : chrome === "ground" ? inlineInkInsetPx : 0);
+  if ("reason" in ink) {
+    console.warn(`[visual-eval] ink extent unreadable at canvas ${canvas}: ${ink.reason}`);
+    return null;
+  }
+  return ink;
+}
+function blankVerdict(canvas, frame) {
+  if (frame.chrome === "ground" && frame.attempt.contentHeight !== null && frame.attempt.contentHeight <= 0) {
+    return canvasBlankIssue(canvas, frame.viewport);
+  }
+  return frame.ink !== null && frame.ink.lastInkRow === null ? canvasBlankIssue(canvas, frame.viewport) : null;
+}
+async function frameCanvas(bundledCode, context, canvas, canvasViewports, deps, hostPresentations) {
+  const declaredBox = canvasViewports?.[canvas];
+  const viewport = declaredBox !== void 0 ? integerBox(declaredBox) : CANVAS_VIEWPORTS[canvas];
+  const mountFit = resolveMountFit({ canvas: mountCanvasOf(context.compiledCode), displayMode: displayModeForCanvas(canvas) });
+  const policy = mountFit === "framed-card" ? { capture: "card-box", overflow: "fail" } : canvasFitPolicy(canvas);
+  const fit = mountFit === "framed-card" ? void 0 : canvasFit(canvas);
+  const chrome = canvasChrome(canvas);
+  const outcome = resolvePresentation(canvas, hostPresentations?.[canvas]);
+  const presentation = outcome?.status === "applied" ? outcome.applied : void 0;
+  const geometry = inlineGeometry(presentation?.frame);
+  const framedCardRadiusPx = mountFit === "framed-card" ? inlineCardRadius(themeVarsOf(context.cssTokens ?? getCssTokens())).radiusPx : void 0;
+  const canvasHtml = buildRenderHTML(bundledCode, context.cssTokens, fit, chrome, presentation, framedCardRadiusPx);
+  const capture = policy.capture;
+  const captured = await captureScreenshotDetailed(canvasHtml, judgeWindow(viewport, chrome, geometry.padPx), deps, capture, {
+    padPx: geometry.padPx,
+    ...geometry.floorPx !== void 0 ? { floorPx: geometry.floorPx } : {}
+  });
+  const attempt = { ...captured, contentHeight: capture === "card-box" ? captured.contentHeight : cardHeight(captured.contentHeight, chrome) };
+  const cardBoxInk = JUDGE_GROUND_MARGIN_PX + JUDGE_INLINE_FRAME_BORDER_PX + (framedCardRadiusPx ?? JUDGE_INLINE_FRAME_RADIUS_PX);
+  return {
+    viewport,
+    policy,
+    mountFit,
+    fit,
+    chrome,
+    declared: declaredBox !== void 0,
+    attempt,
+    ink: capture === "card-box" ? readInk(captured.png, "ground", canvas, cardBoxInk) : readInk(captured.png, chrome, canvas, geometry.inkInsetPx),
+    ...outcome !== void 0 ? { presentation: outcome } : {}
+  };
+}
+function fitCeiling(frame) {
+  return frame.mountFit === "framed-card" ? { width: frame.viewport.width, height: frame.viewport.height - 2 * EXPANDED_FRAME.insetPx } : frame.viewport;
+}
+function fitVerdict(canvas, frame) {
+  const contentHeight = frame.attempt.contentHeight;
+  const ceiling = fitCeiling(frame);
+  if (contentHeight === null || contentHeight <= ceiling.height || frame.policy.overflow === "none") return null;
+  return canvasOverflowIssue(canvas, ceiling, contentHeight, frame.policy.overflow);
+}
+function overflowXVerdict(canvas, frame) {
+  const px = frame.attempt.overflowX;
+  if (px === void 0 || px === null || px <= OVERFLOW_X_ROUNDING_PX || frame.policy.overflow === "none") return null;
+  return canvasOverflowXIssue(canvas, frame.viewport, px, frame.policy.overflow);
+}
+function judgeSalvageOf(error, text, finishReason) {
+  const cause = finishReason === void 0 ? "unknown" : finishReason === "length" ? "output-cap" : finishReason === "stop" ? "malformed" : "stopped";
+  const message = error instanceof Error ? error.message : String(error);
+  const position = /position (\d+)/.exec(message);
+  const start = text.indexOf("{");
+  const offset = position !== null ? (start > 0 ? start : 0) + Number(position[1]) : void 0;
+  const parseError = message.startsWith("Visual evaluator did not return valid JSON") ? "no complete JSON object in the answer" : message.replace(/"(?:[^"\\]|\\.)*"/g, '"\u2026"').slice(0, 160);
+  return { cause, ...finishReason !== void 0 ? { finishReason } : {}, parseError, ...offset !== void 0 ? { offset } : {}, chars: text.length };
+}
+function judgeRecordOf(k, parsed, samples, criteria, requestedModel) {
+  const salvaged = parsed.flatMap((a) => a.salvage !== void 0 ? [a.salvage.cause] : []);
+  const answered = [...parsed, ...criteria?.kind === "ok" ? [criteria] : []];
+  const served = [...new Set(answered.flatMap((a) => a.servedModel !== void 0 ? [a.servedModel] : []))];
+  const criteriaSalvaged = criteria?.kind === "ok" ? criteria.salvage?.cause : void 0;
+  return {
+    k,
+    rule: "median",
+    samples,
+    sigma: populationSigma(samples),
+    notes: parsed.map((a) => a.result.critique ?? ""),
+    ...salvaged.length > 0 ? { salvaged } : {},
+    ...criteriaSalvaged !== void 0 ? { criteriaSalvaged } : {},
+    models: { requested: requestedModel, served }
+  };
+}
+function callFacts(response) {
+  return {
+    ...response.finishReason !== void 0 ? { finishReason: response.finishReason } : {},
+    ...response.servedModel !== void 0 ? { servedModel: response.servedModel } : {}
+  };
+}
+var NO_CRITERIA_ARRAY = { array: false, received: 0, kept: 0, dropped: { notObject: 0, badId: 0, badVerdict: 0 } };
+function criteriaCallOf(criteria) {
+  if (criteria?.kind !== "ok") return {};
+  const answer = criteria.result.criteriaCounts ?? NO_CRITERIA_ARRAY;
+  return { call: { answer, ...criteria.finishReason !== void 0 ? { finishReason: criteria.finishReason } : {} } };
+}
+async function judgeFrame(judge, config, model, png, originalPrompt, profileBlock, canvas, k, criteriaBlock) {
+  const [scoring, criteria] = await Promise.all([
+    Promise.all(Array.from({ length: k }, () => judgeAndParse(judge, config, model, png, originalPrompt, profileBlock, canvas))),
+    criteriaBlock.length > 0 ? judgeAndParse(judge, config, model, png, originalPrompt, profileBlock, canvas, criteriaBlock) : void 0
+  ]);
+  return { scoring, criteria };
+}
+function criteriaCallTokens(criteria) {
+  return criteria?.kind === "ok" ? { inputTokens: criteria.inputTokens, outputTokens: criteria.outputTokens } : void 0;
+}
+function criteriaReads(criteria) {
+  return criteria?.kind === "ok" && criteria.salvage === void 0 ? [criteria.result.criteriaAnswers ?? []] : [];
+}
+function criteriaUnansweredReason(criteria) {
+  return criteria?.kind === "ok" && criteria.salvage !== void 0 ? { unansweredReason: `not answered: the criteria answer was salvaged (${criteria.salvage.cause})` } : {};
+}
+function judgeCountFor(config, canvas) {
+  const k = Math.max(1, Math.floor(config.judgeK ?? 1));
+  if (k === 1) return 1;
+  return config.judgeKCanvases === void 0 || config.judgeKCanvases.includes(canvas) ? k : 1;
+}
+function medianOf(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.floor((sorted.length - 1) / 2)];
+}
+function populationSigma(values) {
+  if (values.length < 2) return 0;
+  const mean = values.reduce((a, b) => a + b, 0) / values.length;
+  const variance = values.reduce((a, b) => a + (b - mean) ** 2, 0) / values.length;
+  return Math.round(Math.sqrt(variance) * 10) / 10;
+}
+async function judgeAndParse(judge, config, model, screenshot, originalPrompt, profileBlock, canvas, criteriaBlock = "") {
+  let firstReason;
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    const response = await judge(config, model, VISUAL_EVAL_PROMPT, screenshot, originalPrompt, profileBlock, criteriaBlock);
+    try {
+      const result = parseVisualResponse(response.text, config.passThreshold);
+      return { kind: "ok", result, inputTokens: response.inputTokens, outputTokens: response.outputTokens, ...callFacts(response) };
+    } catch (e) {
+      const salvaged = salvageTruncatedVisualAnswer(response.text, config.passThreshold);
+      if (salvaged !== null) {
+        const salvage = judgeSalvageOf(e, response.text, response.finishReason);
+        const token = criteriaBlock.length > 0 ? "visual_criteria_salvaged" : "visual_judge_salvaged";
+        console.warn(
+          `[visual-eval] ${token}${canvas ? ` canvas=${canvas}` : ""} cause=${salvage.cause} finish=${salvage.finishReason ?? "unreported"} at=${salvage.offset ?? "?"}/${salvage.chars} (${salvage.parseError}): score recovered from the closed prefix, issues list partial`
+        );
+        return { kind: "ok", result: salvaged, inputTokens: response.inputTokens, outputTokens: response.outputTokens, salvage, ...callFacts(response) };
+      }
+      const reason = `judge answer unparsable: ${e instanceof Error ? e.message : String(e)}`;
+      if (attempt === 1) {
+        firstReason = reason;
+        console.warn(`[visual-eval] visual_judge_retry${canvas ? ` canvas=${canvas}` : ""}: ${reason}`);
+      } else {
+        console.warn(`[visual-eval] visual_judge_retry failed again${canvas ? ` canvas=${canvas}` : ""}: ${reason}`);
+      }
+    }
+  }
+  return { kind: "unparsable", reason: firstReason ?? "judge answer unparsable" };
+}
+async function runVisualEvaluation(context, config, deps = {}) {
+  return (await runVisualEvaluationDetailed(context, config, deps)).result;
+}
+async function runVisualEvaluationDetailed(context, config, deps = {}) {
+  const startTime = Date.now();
+  const judge = deps.judge ?? callMultimodalLLM;
+  const designSrc = config.designSrcDir ?? resolve(resolveDesignPackageDir(), "src");
+  const design = judgeDesignIdentity(designSrc);
+  const stamp = (r) => ({
+    ...r,
+    ...design !== null ? { design } : {},
+    ...config.themeMode !== void 0 ? { themeMode: config.themeMode } : {}
+  });
+  let bundledCode;
+  try {
+    bundledCode = await bundleForRendering(context.compiledCode, config.sampleProps ?? {}, designSrc);
+  } catch (e) {
+    const unavailableReason = `bundle failed: ${e instanceof Error ? e.message : String(e)}`;
+    console.warn(`[visual-eval] ${unavailableReason}`);
+    return { result: null, unavailableReason };
+  }
+  console.log(`[visual-eval] bundled: ${bundledCode.length}B (${Date.now() - startTime}ms)`);
+  const html = buildRenderHTML(bundledCode, context.cssTokens);
+  const model = config.model ?? getDefaultVisualModel(config.provider);
+  if (config.canvases !== void 0 && config.canvases.length > 0) {
+    const perCanvas = [];
+    const perCanvasResults = [];
+    for (const canvas of config.canvases) {
+      const frame = await frameCanvas(bundledCode, context, canvas, config.canvasViewports, deps, config.hostPresentations);
+      const { viewport, policy, fit, attempt: attempt2 } = frame;
+      const screenshot2 = attempt2.png;
+      if (!screenshot2) {
+        const unavailableReason = attempt2.reason ?? "no browser available";
+        console.warn(`[visual-eval] ${unavailableReason} at canvas ${canvas} \u2014 skipping visual evaluation`);
+        return { result: null, unavailableReason, canvas };
+      }
+      const k = judgeCountFor(config, canvas);
+      const profileBlock = buildStylingProfileJudgeBlock(context.profile);
+      const criteriaContext = context.criteria !== void 0 ? { ...context.criteria.context, canvas } : void 0;
+      const criteriaSelected = context.criteria !== void 0 && criteriaContext !== void 0 ? selectCriteria(context.criteria.bank, criteriaContext) : void 0;
+      const criteriaBlock = context.criteria !== void 0 && criteriaSelected !== void 0 ? buildCriteriaJudgeBlock(context.criteria.bank, criteriaSelected, {
+        frame: { canvas, width: viewport.width, height: viewport.height, fit: frame.mountFit, ...frame.presentation?.status === "applied" ? { hostLabel: frame.presentation.applied.label } : {} },
+        ...config.sampleProps !== void 0 ? { propsJson: JSON.stringify(config.sampleProps) } : {}
+      }) : "";
+      const { scoring: answers, criteria: criteriaAnswer } = await judgeFrame(
+        judge,
+        config,
+        model,
+        screenshot2,
+        context.originalPrompt,
+        profileBlock,
+        canvas,
+        k,
+        criteriaBlock
+      );
+      const parsed = answers.filter((a) => a.kind === "ok");
+      if (parsed.length === 0) {
+        const first = answers.find((a) => a.kind === "unparsable");
+        return { result: null, unavailableReason: first?.reason ?? "judge answer unparsable", canvas };
+      }
+      const samples = parsed.map((a) => a.result.finalScore);
+      const median = medianOf(samples);
+      const representative = parsed[samples.indexOf(median)];
+      const result2 = representative.result;
+      result2.finalScore = median;
+      result2.passed = median >= config.passThreshold;
+      result2.inputTokens = parsed.reduce((sum3, a) => sum3 + a.inputTokens, 0);
+      result2.outputTokens = parsed.reduce((sum3, a) => sum3 + a.outputTokens, 0);
+      const response2 = { inputTokens: result2.inputTokens, outputTokens: result2.outputTokens };
+      const criteriaTokens = criteriaCallTokens(criteriaAnswer);
+      const judgeRecord = judgeRecordOf(k, parsed, samples, criteriaAnswer, model);
+      const contentHeight = attempt2.contentHeight;
+      const overflow = contentHeight !== null && contentHeight > viewport.height;
+      const fitIssue = fitVerdict(canvas, frame);
+      if (fitIssue !== null) {
+        result2.issues.push(fitIssue);
+        if (policy.overflow === "fail") result2.passed = false;
+      }
+      const overflowXIssue = overflowXVerdict(canvas, frame);
+      if (overflowXIssue !== null) {
+        result2.issues.push(overflowXIssue);
+        if (policy.overflow === "fail") result2.passed = false;
+      }
+      const blankIssue = blankVerdict(canvas, frame);
+      if (blankIssue !== null) {
+        result2.issues.push(blankIssue);
+        result2.passed = false;
+      }
+      const inkRatio = frame.ink?.ratio ?? null;
+      const criteria = context.criteria !== void 0 && criteriaContext !== void 0 && criteriaSelected !== void 0 ? resolveCriteriaBlock({
+        bank: context.criteria.bank,
+        context: criteriaContext,
+        selected: criteriaSelected,
+        answers: criteriaReads(criteriaAnswer),
+        measurements: { overflow, contentHeight, viewportHeight: viewport.height, inkRatio, edge: attempt2.edge ?? null, edgeV2: attempt2.edgeV2 ?? null },
+        ...criteriaUnansweredReason(criteriaAnswer),
+        ...criteriaCallOf(criteriaAnswer)
+      }) : void 0;
+      perCanvasResults.push(result2);
+      perCanvas.push({
+        canvas,
+        viewport,
+        score: result2.finalScore,
+        passed: result2.passed,
+        screenshotPng: screenshot2,
+        contentHeight,
+        overflow,
+        inkRatio,
+        judge: judgeRecord,
+        ...fit !== void 0 ? { fit } : {},
+        ...frame.declared ? { declared: true } : {},
+        ...criteria !== void 0 ? { criteria } : {},
+        ...criteriaTokens !== void 0 ? { criteriaTokens } : {},
+        ...frame.presentation !== void 0 ? { presentation: frame.presentation } : {}
+      });
+      console.log(
+        `[visual-eval] canvas=${canvas} ${viewport.width}\xD7${viewport.height} score=${result2.finalScore}${k > 1 ? ` (median of ${judgeRecord.samples.length}/${k}: ${judgeRecord.samples.join(",")} \u03C3=${judgeRecord.sigma})` : ""} ${result2.passed ? "pass" : "FAIL"} | content=${contentHeight ?? "?"}px${overflow ? ` OVERFLOW (${policy.overflow})` : ""} ink=${inkRatio ?? "?"}${blankIssue !== null ? " BLANK" : ""} | in=${response2.inputTokens} out=${response2.outputTokens}` + (criteriaTokens !== void 0 ? ` | criteria in=${criteriaTokens.inputTokens} out=${criteriaTokens.outputTokens}` : "")
+      );
+    }
+    const aggregate = aggregateCanvasResults(perCanvas, perCanvasResults);
+    const elapsed2 = Date.now() - startTime;
+    console.log(
+      `[visual-eval] score=${aggregate.finalScore} (mean of ${perCanvas.length} canvases; ${aggregate.passed ? "every canvas passed" : `${perCanvas.filter((c) => !c.passed).length} failed`}) (${elapsed2}ms)`
+    );
+    return { result: stamp(aggregate) };
+  }
+  const attempt = await captureScreenshotDetailed(html, config.viewport, deps);
+  const screenshot = attempt.png;
+  if (!screenshot) {
+    const unavailableReason = attempt.reason ?? "no browser available";
+    console.warn(`[visual-eval] ${unavailableReason} \u2014 skipping visual evaluation`);
+    return { result: null, unavailableReason };
+  }
+  console.log(`[visual-eval] screenshot: ${screenshot.length}B (${Date.now() - startTime}ms)`);
+  const answer = await judgeAndParse(
+    judge,
+    config,
+    model,
+    screenshot,
+    context.originalPrompt,
+    buildStylingProfileJudgeBlock(context.profile)
+  );
+  if (answer.kind === "unparsable") {
+    return { result: null, unavailableReason: answer.reason };
+  }
+  const result = answer.result;
+  result.inputTokens = answer.inputTokens;
+  result.outputTokens = answer.outputTokens;
+  const response = { inputTokens: answer.inputTokens, outputTokens: answer.outputTokens };
+  const elapsed = Date.now() - startTime;
+  console.log(`[visual-eval] score=${result.finalScore} (${elapsed}ms) | in=${response.inputTokens} out=${response.outputTokens}`);
+  return { result: stamp(result) };
+}
+function canvasScopedIssue(canvas, issue) {
+  return { ...issue, description: `[${canvas}] ${issue.description}` };
+}
+function aggregateCanvasResults(perCanvas, results) {
+  const n = results.length;
+  const mean = (pick) => Math.round(results.reduce((sum3, r) => sum3 + pick(r), 0) / n);
+  const dimensions = {
+    completeness: mean((r) => r.dimensions.completeness),
+    visualPolish: mean((r) => r.dimensions.visualPolish),
+    interactivity: mean((r) => r.dimensions.interactivity),
+    accessibility: mean((r) => r.dimensions.accessibility),
+    codeQuality: mean((r) => r.dimensions.codeQuality)
+  };
+  const issues = [];
+  const critiques = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  results.forEach((r, i) => {
+    const canvas = perCanvas[i].canvas;
+    for (const issue of r.issues) issues.push(canvasScopedIssue(canvas, issue));
+    if (r.critique) critiques.push(`${canvas}: ${r.critique}`);
+    inputTokens += r.inputTokens ?? 0;
+    outputTokens += r.outputTokens ?? 0;
+  });
+  const criteriaSpent = perCanvas.flatMap((c) => c.criteriaTokens !== void 0 ? [c.criteriaTokens] : []);
+  const judgeSalvage = {
+    scoring: {
+      salvaged: perCanvas.reduce((sum3, c) => sum3 + (c.judge.salvaged?.length ?? 0), 0),
+      answers: perCanvas.reduce((sum3, c) => sum3 + c.judge.samples.length, 0)
+    },
+    criteria: {
+      salvaged: perCanvas.filter((c) => c.judge.criteriaSalvaged !== void 0).length,
+      answered: perCanvas.filter((c) => c.criteriaTokens !== void 0).length
+    }
+  };
+  return {
+    judgeSalvage,
+    passed: perCanvas.every((c) => c.passed),
+    finalScore: mean((r) => r.finalScore),
+    dimensions,
+    issues,
+    ...critiques.length > 0 ? { critique: critiques.join("\n") } : {},
+    inputTokens,
+    outputTokens,
+    ...criteriaSpent.length > 0 ? {
+      criteriaTokens: {
+        inputTokens: criteriaSpent.reduce((sum3, t) => sum3 + t.inputTokens, 0),
+        outputTokens: criteriaSpent.reduce((sum3, t) => sum3 + t.outputTokens, 0)
+      }
+    } : {},
+    canvases: [...perCanvas]
+  };
+}
+function summarizeVisualResult(result) {
+  if (result.canvases === void 0) return void 0;
+  const canvases = result.canvases.map((c) => ({
+    canvas: c.canvas,
+    viewport: c.viewport,
+    score: c.score,
+    passed: c.passed,
+    contentHeight: c.contentHeight,
+    overflow: c.overflow,
+    inkRatio: c.inkRatio,
+    judge: c.judge,
+    ...c.fit !== void 0 ? { fit: c.fit } : {},
+    ...c.criteria !== void 0 ? { criteria: c.criteria } : {},
+    ...c.presentation !== void 0 ? { presentation: c.presentation } : {}
+  }));
+  const blocks = result.canvases.map((c) => c.criteria).filter((b) => b !== void 0);
+  const idsWhere = (severity, verdict) => [
+    ...new Set(blocks.flatMap((b) => b.verdicts.filter((v) => v.severity === severity && v.verdict === verdict).map((v) => v.id)))
+  ];
+  const rollup = blocks.length > 0 ? { mustFailed: idsWhere("must", "fail"), shouldFailed: idsWhere("should", "fail"), mustNa: idsWhere("must", "n/a") } : void 0;
+  const fitCanvas = result.canvases.find((c) => canvasFitPolicy(c.canvas).overflow === "fail" && c.contentHeight !== null);
+  const fit = fitCanvas !== void 0 && fitCanvas.contentHeight !== null ? {
+    canvas: fitCanvas.canvas,
+    ceiling: { width: fitCanvas.viewport.width, height: fitCanvas.viewport.height },
+    // Declared = the order carried a box, even one equal to the class box (the review's point).
+    declared: fitCanvas.declared === true,
+    overflowPx: Math.max(0, fitCanvas.contentHeight - fitCanvas.viewport.height)
+  } : void 0;
+  return {
+    score: result.finalScore,
+    passed: result.passed,
+    canvases,
+    ...fit !== void 0 ? { fit } : {},
+    ...result.design !== void 0 ? { design: result.design } : {},
+    ...result.themeMode !== void 0 ? { themeMode: result.themeMode } : {},
+    ...rollup !== void 0 ? { criteria: rollup } : {}
+  };
+}
+async function judgeStoredCapture(input, config, deps = {}) {
+  const judge = deps.judge ?? callMultimodalLLM;
+  const model = config.model ?? getDefaultVisualModel(config.provider);
+  const { canvas, viewport, png } = input;
+  const chrome = canvasChrome(canvas);
+  const ink = readInk(png, chrome, canvas);
+  const inkRatio = ink?.ratio ?? null;
+  const k = judgeCountFor(config, canvas);
+  const profileBlock = buildStylingProfileJudgeBlock(input.profile);
+  const criteriaContext = input.criteria !== void 0 ? { ...input.criteria.context, canvas } : void 0;
+  const criteriaSelected = input.criteria !== void 0 && criteriaContext !== void 0 ? selectCriteria(input.criteria.bank, criteriaContext) : void 0;
+  const criteriaBlock = input.criteria !== void 0 && criteriaSelected !== void 0 ? buildCriteriaJudgeBlock(input.criteria.bank, criteriaSelected, {
+    frame: { canvas, width: viewport.width, height: viewport.height, fit: input.mountFit ?? (canvasFit(canvas) === "fill" ? "fill" : "card") },
+    ...input.sampleProps !== void 0 ? { propsJson: JSON.stringify(input.sampleProps) } : {}
+  }) : "";
+  const { scoring: answers, criteria: criteriaAnswer } = await judgeFrame(judge, config, model, png, input.originalPrompt, profileBlock, canvas, k, criteriaBlock);
+  const parsed = answers.filter((a) => a.kind === "ok");
+  if (parsed.length === 0) {
+    const first = answers.find((a) => a.kind === "unparsable");
+    return { kind: "unavailable", reason: first?.reason ?? "judge answer unparsable" };
+  }
+  const samples = parsed.map((a) => a.result.finalScore);
+  const median = medianOf(samples);
+  const result = parsed[samples.indexOf(median)].result;
+  const issues = [...result.issues];
+  let passed = median >= config.passThreshold;
+  const contentHeight = input.contentHeight;
+  const overflow = contentHeight !== null && contentHeight > viewport.height;
+  const policy = canvasFitPolicy(canvas);
+  if (overflow && contentHeight !== null && policy.overflow !== "none") {
+    issues.push(canvasOverflowIssue(canvas, viewport, contentHeight, policy.overflow));
+    if (policy.overflow === "fail") passed = false;
+  }
+  if (ink !== null && ink.lastInkRow === null) {
+    issues.push(canvasBlankIssue(canvas, viewport));
+    passed = false;
+  }
+  const criteria = input.criteria !== void 0 && criteriaContext !== void 0 && criteriaSelected !== void 0 ? resolveCriteriaBlock({
+    bank: input.criteria.bank,
+    context: criteriaContext,
+    selected: criteriaSelected,
+    answers: criteriaReads(criteriaAnswer),
+    measurements: { overflow, contentHeight, viewportHeight: viewport.height, inkRatio },
+    ...criteriaUnansweredReason(criteriaAnswer),
+    ...criteriaCallOf(criteriaAnswer)
+  }) : void 0;
+  const criteriaTokens = criteriaCallTokens(criteriaAnswer);
+  return {
+    kind: "ok",
+    verdict: {
+      canvas,
+      viewport,
+      score: median,
+      passed,
+      issues,
+      judge: judgeRecordOf(k, parsed, samples, criteriaAnswer, model),
+      contentHeight,
+      overflow,
+      inkRatio,
+      ...criteria !== void 0 ? { criteria } : {},
+      inputTokens: parsed.reduce((sum3, a) => sum3 + a.inputTokens, 0),
+      outputTokens: parsed.reduce((sum3, a) => sum3 + a.outputTokens, 0),
+      ...criteriaTokens !== void 0 ? { criteriaTokens } : {}
+    }
+  };
+}
+function salvageTruncatedVisualAnswer(text, passThreshold) {
+  const dim = (name) => {
+    const m = text.match(new RegExp(`"${name}"\\s*:\\s*(\\d+(?:\\.\\d+)?)`));
+    return m ? Number(m[1]) : null;
+  };
+  const completeness = dim("completeness");
+  const layout = dim("layout");
+  const hierarchy = dim("hierarchy");
+  const aesthetics = dim("aesthetics");
+  if (completeness === null || layout === null || hierarchy === null || aesthetics === null) return null;
+  const issues = [];
+  const issuesAt = text.indexOf('"issues"');
+  if (issuesAt >= 0) {
+    for (const m of text.slice(issuesAt).matchAll(/\{[^{}]*\}/g)) {
+      try {
+        const o = JSON.parse(m[0]);
+        if (typeof o.description === "string") {
+          issues.push({
+            dimension: typeof o.dimension === "string" ? o.dimension : "layout",
+            severity: typeof o.severity === "string" ? o.severity : "minor",
+            description: o.description,
+            fix: typeof o.fix === "string" ? o.fix : ""
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  const rebuilt = JSON.stringify({
+    completeness,
+    layout,
+    hierarchy,
+    aesthetics,
+    issues,
+    critique: `[salvaged judge answer \u2014 it did not parse; score recovered from the closed prefix; ${issues.length} issue(s) kept, the rest and the critique lost]`
+  });
+  return parseVisualResponse(rebuilt, passThreshold);
+}
+function parseVisualResponse(text, passThreshold) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Visual evaluator did not return valid JSON: " + text.slice(0, 200));
+  }
+  const raw = JSON.parse(jsonMatch[0]);
+  const completeness = raw.completeness ?? 0;
+  const layout = raw.layout ?? 0;
+  const hierarchy = raw.hierarchy ?? 0;
+  const aesthetics = raw.aesthetics ?? 0;
+  const finalScore = Math.round(
+    completeness * 0.25 + layout * 0.25 + hierarchy * 0.25 + aesthetics * 0.25
+  );
+  const dimensions = {
+    completeness,
+    visualPolish: aesthetics,
+    interactivity: 0,
+    // can't assess interactivity from screenshot
+    accessibility: 0,
+    // can't assess a11y from screenshot
+    codeQuality: 0
+    // can't assess code from screenshot
+  };
+  const issues = (raw.issues || []).map((i) => ({
+    dimension: i.dimension || "visual",
+    origin: "judge",
+    severity: i.severity || "minor",
+    description: i.description || "",
+    fix: i.fix || ""
+  }));
+  const criteria = parseCriteriaAnswers(raw.criteria);
+  return {
+    passed: finalScore >= passThreshold,
+    finalScore,
+    dimensions,
+    issues,
+    critique: raw.critique,
+    ...criteria.answers !== void 0 ? { criteriaAnswers: criteria.answers } : {},
+    criteriaCounts: criteria.counts
+  };
+}
+function parseCriteriaAnswers(raw) {
+  if (!Array.isArray(raw)) return { counts: NO_CRITERIA_ARRAY };
+  const answers = [];
+  const dropped = { notObject: 0, badId: 0, badVerdict: 0 };
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) {
+      dropped.notObject += 1;
+      continue;
+    }
+    const o = entry;
+    if (typeof o.id !== "string") {
+      dropped.badId += 1;
+      continue;
+    }
+    if (o.verdict !== "pass" && o.verdict !== "fail" && o.verdict !== "n/a") {
+      dropped.badVerdict += 1;
+      continue;
+    }
+    answers.push({ id: o.id, verdict: o.verdict, evidence: typeof o.evidence === "string" ? o.evidence : "" });
+  }
+  return { answers, counts: { array: true, received: raw.length, kept: answers.length, dropped } };
+}
+function getDefaultVisualModel(provider) {
+  switch (provider) {
+    case "claude":
+      return "claude-haiku-5-5";
+    case "google":
+      return "gemini-3-flash-preview";
+  }
+}
+async function runVisualEval(context, config, deps = {}) {
+  const detailed = await runVisualEvaluationDetailed(context, config, deps);
+  const result = detailed.result;
+  if (!result) {
+    const reason = detailed.unavailableReason ?? "no browser available";
+    return { issues: [], coverage: { status: "skipped", reason } };
+  }
+  const issues = (result.issues || []).map(toEvalIssue);
+  const summary = summarizeVisualResult(result);
+  const coverage = { status: "ran" };
+  const tokens = result.inputTokens !== void 0 && result.outputTokens !== void 0 ? {
+    inputTokens: result.inputTokens,
+    outputTokens: result.outputTokens,
+    ...result.criteriaTokens !== void 0 ? { criteria: result.criteriaTokens } : {}
+  } : void 0;
+  return { issues, ...summary !== void 0 ? { summary } : {}, coverage, ...tokens !== void 0 ? { tokens } : {} };
+}
+function toEvalIssue(issue) {
+  return {
+    tier: 2,
+    result: issue.severity === "critical" ? "fail" : "warn",
+    category: "visual",
+    subcategory: issue.dimension,
+    severity: issue.severity === "critical" ? "critical" : "major",
+    description: issue.description,
+    fix: issue.fix || "",
+    ...issue.origin !== void 0 ? { origin: issue.origin } : {}
+  };
+}
+async function runVisualFit(context, config, deps = {}) {
+  if (config.canvases === void 0 || config.canvases.length === 0) {
+    return { status: "unavailable", reason: "no canvases \u2014 the fit verdict is taken per canvas" };
+  }
+  const designSrc = config.designSrcDir ?? resolve(resolveDesignPackageDir(), "src");
+  let bundledCode;
+  try {
+    bundledCode = await bundleForRendering(context.compiledCode, config.sampleProps ?? {}, designSrc);
+  } catch (e) {
+    return { status: "unavailable", reason: `bundle failed: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  const issues = [];
+  const readings = [];
+  for (const canvas of config.canvases) {
+    const frame = await frameCanvas(bundledCode, context, canvas, config.canvasViewports, deps, config.hostPresentations);
+    if (!frame.attempt.png) {
+      return { status: "unavailable", reason: `${frame.attempt.reason ?? "no browser available"} at canvas ${canvas}` };
+    }
+    const contentHeight = frame.attempt.contentHeight;
+    const overflow = contentHeight !== null && contentHeight > frame.viewport.height;
+    const verdict = fitVerdict(canvas, frame);
+    if (verdict !== null) issues.push(toEvalIssue(canvasScopedIssue(canvas, verdict)));
+    const overflowXIssue = overflowXVerdict(canvas, frame);
+    if (overflowXIssue !== null) issues.push(toEvalIssue(canvasScopedIssue(canvas, overflowXIssue)));
+    const blank = blankVerdict(canvas, frame);
+    if (blank !== null) issues.push(toEvalIssue(canvasScopedIssue(canvas, blank)));
+    const inkRatio = frame.ink?.ratio ?? null;
+    readings.push({
+      canvas,
+      viewport: frame.viewport,
+      contentHeight,
+      overflow,
+      inkRatio,
+      ...frame.declared ? { declared: true } : {},
+      ...frame.presentation !== void 0 ? { presentation: frame.presentation } : {}
+    });
+    console.log(
+      `[visual-fit] canvas=${canvas} ${frame.viewport.width}\xD7${frame.viewport.height} content=${contentHeight ?? "?"}px${overflow ? ` OVERFLOW (${frame.policy.overflow})` : ""} ink=${inkRatio ?? "?"}${blank !== null ? " BLANK" : ""} | no judge`
+    );
+  }
+  return { status: "measured", issues, readings };
+}
+
+export { CARD_BOX_EXPRESSION, CARD_HEIGHT_EXPRESSION, CARD_OVERFLOW_X_EXPRESSION, CONTENT_HEIGHT_EXPRESSION, CRITERIA_SELECTOR_VERSION, EDGE_BLOCKS_EXPRESSION, EDGE_TOLERANCE_PX, EXECUTABLE_PATH_LAUNCH_ARGS, HOST_COLOUR_PATTERN, HOST_FRAME_BOUNDS, INK_TOLERANCE, INSTRUMENT_BESIDE_JUDGE, INSTRUMENT_BY_ID, JUDGE_GROUND_CLASS, JUDGE_GROUND_MARGIN_PX, JUDGE_INK_INSET_PX, JUDGE_INLINE_FRAME_BORDER_PX, JUDGE_INLINE_FRAME_CLASS, JUDGE_INLINE_FRAME_RADIUS_PX, JUDGE_INLINE_INK_INSET_PX, JUDGE_INLINE_PAD_PX, JUDGE_PANEL_CLASS, JUDGE_SCOPE_CLASS, OVERFLOW_X_ROUNDING_PX, VISUAL_EVAL_PROMPT, VISUAL_JUDGE_MAX_OUTPUT_TOKENS, VISUAL_JUDGE_PROMPT_DIGEST, VISUAL_JUDGE_PROMPT_VERSION, bankRows, buildCriteriaJudgeBlock, buildRenderHTML, bundleForRendering, callMultimodalLLM, canonicalCriteriaContext, canvasBlankIssue, canvasChrome, canvasFit, canvasFitPolicy, canvasOverflowIssue, canvasOverflowXIssue, captureScreenshot, captureScreenshotDetailed, cardBoxClip, cardHeightExpression, criteriaBankSchema, criteriaSetIdFor, decodePng, designTreeSha256, findPackageRootAbove, fitCeiling, integerBox, isDeclaredViewport, judgeDesignIdentity, judgeEdges, judgeStoredCapture, judgeWindow, mountCanvasOf, naturalClip, parseCriteriaBank, parseEdgeProbe, readInkExtent, resetJudgeDesignIdentityCache, resolveCriteriaBlock, resolveDesignPackageDir, resolveLaunchOptions, resolveUiGenPackageDir, resolveWirePackageDir, runVisualEval, runVisualEvaluation, runVisualEvaluationDetailed, runVisualFit, salvageTruncatedVisualAnswer, selectCriteria, summarizeVisualResult };
+//# sourceMappingURL=chunk-732IBFEJ.js.map
+//# sourceMappingURL=chunk-732IBFEJ.js.map