@ggui-ai/ui-gen 0.24.0 → 0.26.0

package/dist/evaluation/index.d.ts

@@ -1,20 +1,23 @@
-import { C as CanvasJudgeRecord, E as EvalIssue, V as VisualEvalSummary, d as VisualCoverage } from '../types-public-Bk6d1WLN.js';
-export { A as AxisCheck, a as AxisCheckInput, e as CRITERIA, f as CanvasVisualSummary, g as ContractFeedbackRecord, h as CriterionCoverage, i as CriterionRunStatus, D as DEFAULT_QUALITY_CONFIG, j as EvalCategory, k as EvalCriterion, l as EvalOutcome, b as EvalResult, c as EvalTier, L as LLM_EVAL_STATIC_CRITERIA, n as Priority, Q as QualityConfig, o as QualityMode, p as buildCodingCriteriaSummary, q as criteriaFor, r as getActionableIssues, s as getCriteriaByPriority, t as getCriterionById, u as getLLMCriteria, v as isBlocked, m as matches, w as notApplicableCoverage, x as priorityForIssue } from '../types-public-Bk6d1WLN.js';
+import { r as CriteriaSelection, h as CriteriaContext, C as CriteriaAnswerCounts, s as VisionFinishReason, k as CriteriaBlock } from '../types-public-B7wn4ce5.js';
+export { A as AxisCheck, a as AxisCheckInput, t as CRITERIA, n as CanvasHostPresentation, j as CanvasJudgeRecord, l as CanvasPresentationOutcome, u as CanvasVisualSummary, v as ContractFeedbackRecord, w as CriterionCoverage, x as CriterionRunStatus, D as DEFAULT_QUALITY_CONFIG, y as EvalCategory, z as EvalCriterion, E as EvalIssue, B as EvalOutcome, e as EvalResult, q as EvalTier, H as HostInlineFrame, F as HostPresentationIgnoredReason, G as LLM_EVAL_STATIC_CRITERIA, I as Priority, Q as QualityConfig, K as QualityMode, o as VisualEvalSummary, M as buildCodingCriteriaSummary, N as criteriaFor, O as getActionableIssues, S as getCriteriaByPriority, T as getCriterionById, U as getLLMCriteria, W as isBlocked, m as matches, X as notApplicableCoverage, Y as priorityForIssue } from '../types-public-B7wn4ce5.js';
 import * as _anthropic_ai_claude_agent_sdk from '@anthropic-ai/claude-agent-sdk';
 import { McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
-import { EvaluationContext, EvaluationConfig, QualityMetadata, EvaluationResult, EvaluationIssue } from './types.js';
+import { EvaluationContext, EvaluationConfig, QualityMetadata, EvaluationResult, EvaluationIssue, CriteriaAnswer } from './types.js';
 export { DEFAULT_EVAL_MAX_ROUNDS, DimensionScores, MAX_EVAL_ROUNDS_HARD_LIMIT } from './types.js';
-export { R as RunAxisChecksInput, r as runAxisChecks } from '../dispatch-BnAH56p4.js';
-import { A as AgentConfig, L as LLMResponse } from '../llm-router-DwwUK1bz.js';
-import { G as GenerationProfileInput } from '../styling-profile-CxfvV48g.js';
-import { LaunchOptions } from 'puppeteer-core';
-import { C as CanvasClass, g as CanvasViewport } from '../design-mode-DLufhrNp.js';
-export { a as CANVAS_BREAKPOINTS, b as CANVAS_CLASSES, c as CANVAS_DESCRIPTORS, d as CANVAS_VIEWPORTS, e as CanvasDescriptor, f as CanvasDisplayMode, j as canvasDisplayModeForShell, k as canvasForRendering, l as canvasForViewportWidth, m as describeCanvas } from '../design-mode-DLufhrNp.js';
+export { R as RunAxisChecksInput, r as runAxisChecks } from '../dispatch-BUoXRj_r.js';
+import { E as EdgeVerdict, a as EdgeBlock, C as CriteriaCallTokens } from '../visual-evaluator-C9L-o6ap.js';
+export { b as CARD_HEIGHT_EXPRESSION, c as CONTENT_HEIGHT_EXPRESSION, d as CanvasFitPolicy, e as CanvasVisualResult, f as CaptureMode, g as ChromiumProvider, h as CriteriaContextInput, i as CriteriaContextSources, j as EDGE_TOLERANCE_PX, k as EdgeOffset, H as HOST_COLOUR_PATTERN, l as HOST_FRAME_BOUNDS, J as JUDGE_GROUND_MARGIN_PX, m as JUDGE_INK_INSET_PX, n as JudgeDesignIdentity, N as NaturalCaptureOptions, S as ScreenshotAttempt, o as ScreenshotBrowser, p as ScreenshotClip, q as ScreenshotDeps, r as ScreenshotLauncher, s as ScreenshotPage, t as StoredCaptureInput, u as StoredCaptureOutcome, v as StoredCaptureVerdict, w as VISUAL_EVAL_PROMPT, x as VISUAL_JUDGE_MAX_OUTPUT_TOKENS, y as VISUAL_JUDGE_PROMPT_DIGEST, z as VISUAL_JUDGE_PROMPT_VERSION, A as VisualEvalConfig, B as VisualEvalContext, D as VisualEvalDeps, F as VisualEvalDetailed, G as VisualEvalOutcome, I as VisualEvaluationResult, V as VisualLegTokens, K as callMultimodalLLM, L as canvasBlankIssue, M as canvasFitPolicy, O as canvasOverflowIssue, P as captureScreenshot, Q as captureScreenshotDetailed, R as chromaOfCssTokens, T as criteriaContextFor, U as designTreeSha256, W as judgeDesignIdentity, X as judgeEdges, Y as judgeStoredCapture, Z as resetJudgeDesignIdentityCache, _ as resolveDesignPackageDir, $ as resolveLaunchOptions, a0 as runVisualEval, a1 as runVisualEvaluation, a2 as runVisualEvaluationDetailed, a3 as summarizeVisualResult } from '../visual-evaluator-C9L-o6ap.js';
+export { b as CANVAS_BREAKPOINTS, c as CANVAS_CLASSES, d as CANVAS_DESCRIPTORS, e as CANVAS_VIEWPORTS, C as CanvasClass, f as CanvasDescriptor, g as CanvasDisplayMode, a as CanvasViewport, j as canvasDisplayModeForShell, k as canvasForRendering, l as canvasForViewportWidth, m as describeCanvas } from '../design-mode-DGWN_Gkm.js';
 import { AppTheme } from '@ggui-ai/protocol';
-import '@ggui-ai/mcp-server-core';
-import '../axes-CzLEMDeB.js';
-import '../types-BOvHNG7K.js';
+import { C as CriteriaBank } from '../bank-Ctdp3FUA.js';
+export { B as BankRow, a as CriteriaScope, b as bankRows, c as criteriaBankSchema, p as parseCriteriaBank } from '../bank-Ctdp3FUA.js';
 import '../llm.js';
+import '@ggui-ai/mcp-server-core';
+import '../axes-CKVCzR_x.js';
+import '../types-Dh1s4K9j.js';
+import '../styling-profile-CxfvV48g.js';
+import 'puppeteer-core';
+import 'zod';
 
 /**
  * Options for running the evaluation loop.
@@ -186,364 +189,206 @@ declare function extractCompiledCode(messages: SdkMessage[]): string | undefined
  */
 declare function extractSourceCode(messages: SdkMessage[]): string | undefined;
 
-interface JudgeDesignIdentity {
-    /** Absolute path of the design `src` tree the judge bundled against. */
-    readonly src: string;
-    /** sha256 over every rendering input under `src` (see {@link isDesignRenderingInput}) — sorted relative path, then contents. */
-    readonly srcSha256: string;
+/** A channel difference at or below this is the same colour (anti-aliasing and compositing noise). */
+declare const INK_TOLERANCE = 8;
+interface PixelRegion {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
 }
-/**
- * sha256 over every rendering input under `root` (sorted relative path +
- * contents) — the identity of a design tree as it paints.
- *
- * A function of the TREE, not of the spelling of `root`: the relative keys
- * are taken against the RESOLVED root, so `…/design/src`, `…/design/src/` and
- * `…/ui-gen/../design/src` hash the same bytes. Before this the key was
- * sliced by the unresolved root's length while each entry had already been
- * resolved, so an un-normalised root produced a different hash for the same
- * tree — a phantom design skew for any caller composing the path.
- */
-declare function designTreeSha256(root: string): string;
-/**
- * The identity of the tree at `src`, computed once per process per path (a
- * judge run paints hundreds of frames from one tree).
- *
- * `null` when the tree cannot be READ (ggui#1110): a deployed image ships the
- * design package as built output with no `src/`, and an identity is a receipt
- * about a judgement — never a precondition for making one. Before this,
- * `scandir` threw ENOENT inside the evaluation round wherever the package ships
- * built output only, the round returned no evaluation at all, and a bar refused
- * a card that had cleared it. A row without the receipt says so; a round that cannot
- * stamp one still runs.
- */
-declare function judgeDesignIdentity(src: string): JudgeDesignIdentity | null;
-/** Test seam: forget cached identities (a test that rewrites a tree between runs). */
-declare function resetJudgeDesignIdentityCache(): void;
-
-interface VisualEvalConfig {
-    /** LLM provider for multimodal evaluation */
-    provider: 'claude' | 'google';
-    /** Model ID (must support vision/multimodal) */
-    model?: string;
-    /** Pass threshold for visual score (0-100) */
-    passThreshold: number;
-    /** Sample props to render the component with */
-    sampleProps?: Record<string, unknown>;
-    /** Viewport dimensions for screenshot */
-    viewport?: {
-        width: number;
-        height: number;
-    };
-    /**
-     * Per-canvas judging — ARM-NEUTRAL (the same judge, prompt and
-     * threshold in every design mode). When set, the SAME rendered HTML
-     * shell is screenshotted once per class at `CANVAS_VIEWPORTS[class]`
-     * and judged once per class; the result carries one entry per class
-     * in `canvases`, and the single-shot fields aggregate: `finalScore` =
-     * mean of the canvas scores (rounded), `passed` = every canvas passed,
-     * `dimensions` = per-dimension means, `issues` = every canvas's issues
-     * (description prefixed `[<canvas>]`). Unset (or empty) = today's
-     * single screenshot at `viewport`; no `canvases` field on the result.
-     */
-    canvases?: readonly CanvasClass[];
-    /**
-     * ggui#1195 — the box a canvas is COMPOSED for and CAPTURED at when the
-     * order declared one (the chat card at the visitor's real column, not the
-     * class's 400×640). Keyed by canvas; a canvas without an entry is judged
-     * at `CANVAS_VIEWPORTS[canvas]` as before. The composer's
-     * `rendering.viewport` and this entry are ONE value written once (the
-     * seam derives it), so the judge never scores a box the mint did not
-     * target. Only read in per-canvas mode. Captured at WHOLE CSS px: the
-     * browser's device-metrics override takes integers (measured — a 383.5 px
-     * width is refused by CDP), so a fractional declared box is rounded once
-     * where it enters and the capture, the ceiling and the reported
-     * `viewport` all carry that same integer box.
-     */
-    canvasViewports?: Partial<Readonly<Record<CanvasClass, CanvasViewport>>>;
-    /**
-     * Optional provider-routing override — see
-     * `AgentConfig.routeOverride`. Threaded onto the agent this
-     * evaluator constructs so its multimodal call never falls back to
-     * `process.env` for credentials or model routing.
-     */
-    /**
-     * Vision calls per judged canvas on the SAME captured frame, aggregated by
-     * the median (ggui#1072). Default 1 — a single judgement, byte-identical to
-     * the instrument before this option existed. K is an instrument dial: a
-     * run mixes K at its own peril.
-     */
-    judgeK?: number;
-    /** The canvases sampled `judgeK` times; default = every judged canvas when `judgeK > 1`. */
-    judgeKCanvases?: readonly CanvasClass[];
-    /**
-     * The design `src` tree the judge bundles the component against
-     * (ggui#1042): an explicit input, so a judge-only re-judge names the tree
-     * it painted with. Default: the design package beside this one.
-     */
-    designSrcDir?: string;
-    /** The mode the caller composed `cssTokens` in — a receipt on the row, never a switch (ggui#1076: judge and runtime must name the same mode). */
-    themeMode?: 'light' | 'dark';
-    routeOverride?: AgentConfig['routeOverride'];
-    /**
-     * Provider-429-retry observer — see `AgentConfig.onRetry`.
-     * Without it, a rate-limited retry inside the evaluation call
-     * happens (the agent's retry loop is unconditional) but never
-     * reaches the caller's structured log.
-     */
-    onRetry?: AgentConfig['onRetry'];
+interface InkExtent {
+    /** `(lastInkRow + 1) / region.height`, rounded to 3 places; `0` when nothing differs from the ground. */
+    readonly ratio: number;
+    /** The last region row (0-based from the region's top) carrying ink; `null` when there is none — the blank. */
+    readonly lastInkRow: number | null;
+    /** The region read, in image px. */
+    readonly region: PixelRegion;
+    /** The dominant colour the ink was read against, `[r, g, b]`. */
+    readonly ground: readonly [number, number, number];
 }
-/** One canvas's verdict — screenshot + judge score at that class's viewport. */
-interface CanvasVisualResult {
-    canvas: CanvasClass;
-    viewport: CanvasViewport;
-    /** The judge's weighted score for this canvas (0-100). */
-    score: number;
-    /** `score >= passThreshold`. */
-    passed: boolean;
-    /** The PNG the judge saw — kept for artefact persistence + the human look. */
-    screenshotPng: Buffer;
-    /**
-     * The document's scroll height at this canvas's viewport, CSS px — what
-     * the box would have to be for nothing to be hidden (ggui#1027). `null`
-     * when the page could not be measured.
-     */
-    contentHeight: number | null;
-    /** `contentHeight > viewport.height` — a measurement; what it MEANS is {@link canvasFitPolicy}'s. */
-    overflow: boolean;
-    /** How `score` was reached — always present (ggui#1072). */
-    judge: CanvasJudgeRecord;
-    /** How the judge composed the mount (ggui#1100): `'fill'` on every fullscreen canvas, absent on the inline card. */
-    fit?: 'fill';
-    /** ggui#1195 — `true` when the order DECLARED this canvas's box (`config.canvasViewports` carried an entry), whatever its value. */
-    declared?: true;
+/** Why a capture could not be read — reported, never mistaken for a blank. */
+interface InkUnreadable {
+    readonly reason: string;
 }
-/** How a canvas is captured for the judge and what an overflow means there (ggui#1027). */
-type CaptureMode = 'viewport' | 'full-page';
-interface CanvasFitPolicy {
-    /** `viewport` = the judge sees the box the user sees; `full-page` = the whole scrolled document. */
-    readonly capture: CaptureMode;
-    /** The verdict an overflow earns on this canvas. */
-    readonly overflow: 'fail' | 'warn' | 'none';
+interface DecodedImage {
+    readonly width: number;
+    readonly height: number;
+    readonly channels: 3 | 4;
+    /** Row-major, `channels` bytes per pixel, scanline filters undone. */
+    readonly pixels: Uint8Array;
 }
+/** The PNG subset the judge's browser writes: 8-bit RGB (colour type 2) or RGBA (6), not interlaced. */
+declare function decodePng(png: Uint8Array): DecodedImage | InkUnreadable;
 /**
- * The inline chat card is a BOX — the bubble bounds the component and it
- * does not scroll — so the judge captures the viewport (a 1289 px hello on
- * a 640 px card was scored 86 from a full-page capture that showed the
- * judge what no user sees) and an overflow is a critical layout issue that
- * fails the canvas. A phone's first screen may scroll, so the overflow is
- * reported as a major issue and the score stands. Pages (`md`/`lg`/`xl`)
- * scroll by design: measured, never judged.
- */
-declare function canvasFitPolicy(canvas: CanvasClass): CanvasFitPolicy;
-/** The deterministic fit issue — one per overflowing canvas, in the judge's issue shape so it rides the same channel. */
-declare function canvasOverflowIssue(canvas: CanvasClass, viewport: CanvasViewport, contentHeight: number, verdict: 'fail' | 'warn'): EvaluationIssue;
-/**
- * `runVisualEvaluation`'s result. Identical to `EvaluationResult` when
- * `config.canvases` is unset; with canvases set, `canvases` holds the
- * per-class verdicts and the base fields aggregate them (see
- * `VisualEvalConfig.canvases`).
+ * The ink extent of a capture, read `insetPx` in from every edge — the judge's inset skips a host
+ * panel's gap, rounded corners and hairline ({@link JUDGE_INK_INSET_PX}); `0` reads the whole image.
  */
-interface VisualEvaluationResult extends EvaluationResult {
-    canvases?: CanvasVisualResult[];
-    /** The design tree the judge painted with (ggui#1042) — present on every per-canvas judgement. */
-    design?: JudgeDesignIdentity;
-    /** The mode `cssTokens` were composed in, when the caller said (ggui#1076). */
-    themeMode?: 'light' | 'dark';
-}
-/** Injection points for `runVisualEvaluation` — screenshot deps plus the judge call (tests). */
-interface VisualEvalDeps extends ScreenshotDeps {
-    /** The multimodal judge call (default: `callMultimodalLLM`). */
-    judge?: typeof callMultimodalLLM;
-}
-interface VisualEvalContext {
-    /** Compiled JavaScript code (ESM with imports) */
-    compiledCode: string;
-    /** Original user prompt */
-    originalPrompt: string;
-    /** Design system CSS tokens */
-    cssTokens?: string;
-    /** The app's generation profile (#991) — judged relative to, never against. */
-    profile?: GenerationProfileInput;
-}
+declare function readInkExtent(png: Uint8Array, insetPx?: number): InkExtent | InkUnreadable;
+
 /**
- * The `@ggui-ai/design` package root — resolved by MODULE ID, never by counting
- * directories (ggui#1110).
- *
- * The arithmetic this replaced (`…/'..','..','..','design'`) was correct only
- * for the layout it was written against — `node_modules/@ggui-ai/ui-gen/dist/
- * evaluation` → `node_modules/@ggui-ai/` + `design`. Under a deploy-flattened
- * layout it landed one level too high, at `node_modules/design`, a path that is
- * not the design package at all: the judge then walked a directory that does not
- * exist, threw ENOENT inside every evaluation round on that deployment, and a
- * bar refused cards no one could judge. `@ggui-ai/design` exports `./package.json`,
- * so the module resolver answers correctly in every layout — scoped, flattened,
- * hoisted — and the receipt keeps working inside the image.
+ * The stylesheet a visual judge renders under for an app: the app's theme
+ * composed the way the runtime composes it (`composeThemeCss`, layer `page`
+ * — one composition, never a second), so a judged canvas paints the tokens a
+ * visitor's page paints. `themeId` is the registered ladder the app's theme
+ * sits on (the runtime's base layer); an unknown id composes the default
+ * ladder. Neither given ⇒ the design's default tokens, byte-for-byte what the
+ * judge used before.
  */
-declare function resolveDesignPackageDir(): string;
-/** The page surface the capture uses — a structural subset of puppeteer's `Page`. */
-interface ScreenshotPage {
-    setContent(html: string, options: {
-        waitUntil: 'load';
-        timeout: number;
-    }): Promise<void>;
-    waitForNetworkIdle(options: {
-        idleTime: number;
-        timeout: number;
-    }): Promise<void>;
-    waitForSelector(selector: string, options: {
-        timeout: number;
-    }): Promise<unknown>;
-    /** Evaluates a JS expression in the page and returns its serialised value — the fit measurement (ggui#1027). */
-    evaluate(expression: string): Promise<unknown>;
-    screenshot(options: {
-        type: 'png';
-        fullPage: boolean;
-    }): Promise<Uint8Array>;
-}
-/** The browser surface the capture uses — a structural subset of puppeteer's `Browser`. */
-interface ScreenshotBrowser {
-    newPage(): Promise<ScreenshotPage>;
-    close(): Promise<void>;
-}
-type ScreenshotLauncher = (options: LaunchOptions) => Promise<ScreenshotBrowser>;
-/** The two members of `@sparticuz/chromium` the fallback launch path reads. */
-interface ChromiumProvider {
-    readonly args: string[];
-    executablePath(): Promise<string>;
+declare function cssTokensForAppTheme(theme: AppTheme | undefined, mode?: 'light' | 'dark', themeId?: string): string;
+
+/** Bump when a selection rule changes: it is hashed into every `criteriaSetId`. */
+declare const CRITERIA_SELECTOR_VERSION = "selector@2";
+/** The context as one string, keys sorted at every level — what the id hashes and what the record stores. */
+declare function canonicalCriteriaContext(ctx: CriteriaContext): string;
+/** sha256(bank version | selector version | canonical context), 16 hex — a label at this scale, not a security digest. */
+declare function criteriaSetIdFor(bankVersion: string, ctx: CriteriaContext): string;
+interface CriteriaSelectionResult {
+    readonly criteriaSetId: string;
+    readonly selection: CriteriaSelection[];
 }
 /**
- * Injection points for the capture — every default is the production
- * path; tests replace them to pin branch selection without launching a
- * browser.
+ * Select the bank's rows for one card. The bank-level `applies` gate is read first (canvases always;
+ * kind only when the caller named one and the bank names kinds other than `*`); then each row's
+ * `scope`. An empty scope is `static`; a matched scope is `context` with the keys that matched.
  */
-interface ScreenshotDeps {
-    /** Launches the browser (default: `puppeteer-core`'s `launch`). */
-    launch?: ScreenshotLauncher;
-    /** Environment the executable-path override is read from (default: `process.env`). */
-    env?: NodeJS.ProcessEnv;
-    /** Loads `@sparticuz/chromium` (default: dynamic import) — only consulted when no override is set. */
-    loadChromium?: () => Promise<ChromiumProvider>;
-    /** Post-load settle time before the screenshot, ms (default 1000). */
-    settleMs?: number;
-}
+declare function selectCriteria(bank: CriteriaBank, ctx: CriteriaContext): CriteriaSelectionResult;
+
 /**
- * Pick the browser binary. `PUPPETEER_EXECUTABLE_PATH` (a system
- * Chromium — the bench runner image, a dev box) wins and skips the
- * `@sparticuz/chromium` load entirely; otherwise the bundled Lambda
- * Chromium supplies both binary and flags, as before.
+ * From K judge answers and the capture's measurements to one `CriteriaBlock` — ggui#1436.
+ *
+ * The judge is asked every `evaluation: judge` row (this block IS their implementation; the row's
+ * `status` is carried on the verdict as the author wrote it). An `instrument` row is answered by a
+ * measurement the capture already ran when its status is `live` and a binding exists; otherwise it
+ * reads `n/a` with the reason from `status`. A `human` row reads `n/a` for the judge. K-majority per
+ * id; a tie or an unanswered id reads `n/a` (the CTO's A2) — a `must` at `n/a` is never a pass when
+ * a gate later reads the set.
  */
-declare function resolveLaunchOptions(viewport: {
-    width: number;
-    height: number;
-}, deps?: Pick<ScreenshotDeps, 'env' | 'loadChromium'>): Promise<LaunchOptions>;
+
+/** The instruments the capture runs today, by the bank ids they answer (v1 binding; a bank field may replace it). */
+declare const INSTRUMENT_BY_ID: Readonly<Record<string, 'fit' | 'fill'>>;
 /**
- * Take a screenshot of the rendered component.
- * Returns the PNG bytes, or null if no browser could be launched.
+ * ggui#1663 — instruments that read BESIDE a judge row, report-only: the row keeps the judge's verdict and gains the
+ * measurement as `instrument`, so the two can be compared before any verdict moves.
  */
-/** Screenshot plus the reason when none could be taken — the judge's `unavailableReason`. */
-interface ScreenshotAttempt {
-    readonly png: Buffer | null;
-    readonly reason?: string;
-    /** The document's scroll height at the viewport (ggui#1027); `null` when unmeasurable. */
+declare const INSTRUMENT_BESIDE_JUDGE: Readonly<Record<string, 'edge'>>;
+interface CriteriaMeasurements {
+    readonly overflow: boolean;
     readonly contentHeight: number | null;
+    readonly viewportHeight: number;
+    readonly inkRatio: number | null;
+    /**
+     * ggui#1663 — the edge rule on the capture's DOM: absent when this capture had no page to read (a stored frame),
+     * `null` when the probe ran and failed.
+     */
+    readonly edge?: EdgeVerdict | null;
 }
-/** The expression the fit measurement evaluates in the page — the taller of the two scroll heights. */
-declare const CONTENT_HEIGHT_EXPRESSION = "Math.max(document.documentElement.scrollHeight, document.body ? document.body.scrollHeight : 0)";
-declare function captureScreenshotDetailed(html: string, viewport?: {
-    width: number;
-    height: number;
-}, deps?: ScreenshotDeps, capture?: CaptureMode): Promise<ScreenshotAttempt>;
-declare function captureScreenshot(html: string, viewport?: {
-    width: number;
-    height: number;
-}, deps?: ScreenshotDeps): Promise<Buffer | null>;
-declare const VISUAL_EVAL_PROMPT = "You are a visual quality evaluator for ggui \u2014 a platform where AI agents generate React UI components on demand.\n\n## Context\nThe 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.\n\n## Scoring Dimensions (0-100 each)\n\n1. **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.\n\n2. **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?\n\n3. **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?\n\n4. **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?\n\n## Scoring Guide\n- 90-100: Production-ready. Would ship to real users. Polished layout, clear hierarchy, professional aesthetics.\n- 80-89: Good quality. Minor improvements needed (slightly tight spacing, one section could be better grouped).\n- 70-79: Acceptable but generic. Works correctly but lacks design polish or visual refinement.\n- 60-69: Below standard. Noticeable problems \u2014 cramped layout, poor hierarchy, or missing sections.\n- Below 60: Broken or fundamentally incomplete. Error messages visible, blank areas, or critical features missing.\n\n## Important\n- Check the screenshot against the \"Original Request\" \u2014 does it actually deliver what was asked for?\n- Error messages like \"Render error\" or blank white space = rendering score 0\n- A component that renders but is just a wall of text with no structure should score low on layout and hierarchy\n\nList AT MOST 6 issues, most severe first, one sentence each for \"description\" and \"fix\" \u2014 a longer list is cut off and lost.\n\nRespond with ONLY a JSON object (no markdown, no explanation):\n{\n  \"completeness\": <0-100>,\n  \"layout\": <0-100>,\n  \"hierarchy\": <0-100>,\n  \"aesthetics\": <0-100>,\n  \"issues\": [\n    { \"dimension\": \"<dimension>\", \"severity\": \"<critical|major|minor>\", \"description\": \"<what's wrong>\", \"fix\": \"<specific fix>\" }\n  ],\n  \"critique\": \"<2-3 sentences: what's good, what needs improvement, does it achieve the user's goal?>\"\n}";
-/**
- * Send the screenshot to the configured multimodal provider through
- * the shared `LLMAgent` machinery. Routing through `createVisionAgent`
- * (rather than constructing provider SDK clients inline) is what puts
- * this call inside the same `apiCall()` choke point as every other
- * completion: provider 429s retry with `Retry-After` honoring, the
- * caller's `onRetry` observer sees each retry, and `routeOverride`
- * governs credentials and model routing (including the Anthropic
- * Bedrock path) instead of `process.env`.
- */
-/**
- * Output budget for the judge's answer. 1500 cut a board's issue list
- * mid-array (`Expected ',' or ']' after array element`, six kanban cells
- * on 2026-09-11) — deterministic on the content, so a same-prompt retry
- * could never clear it. 4096 fits the bounded list the prompt now asks for
- * with room; the salvage path covers the remainder.
- */
-declare const VISUAL_JUDGE_MAX_OUTPUT_TOKENS = 4096;
-/**
- * The judge instrument's name and content digest, for the record a run
- * stamps beside every visual score. The NAME is for readers; the DIGEST
- * is computed from the prompt text at module load, so a stamped row can
- * never claim a prompt version it did not run — change the prompt and the
- * digest moves with it (the pin ties the name to the bounded-list text).
- */
-declare const VISUAL_JUDGE_PROMPT_VERSION = "v2-bounded-issues";
-declare const VISUAL_JUDGE_PROMPT_DIGEST: string;
-declare function callMultimodalLLM(config: VisualEvalConfig, model: string, prompt: string, screenshot: Buffer, originalPrompt: string, profileBlock?: string): Promise<LLMResponse>;
+declare function resolveCriteriaBlock(args: {
+    readonly bank: CriteriaBank;
+    readonly context: CriteriaContext;
+    readonly selected: CriteriaSelectionResult;
+    readonly answers: readonly CriteriaAnswer[][];
+    readonly measurements: CriteriaMeasurements;
+    /**
+     * ggui#1127 — why a judge row has no answer, when the caller knows: a salvaged criteria answer keeps no criteria,
+     * so its rows say so instead of reading as a clean `n/a`. Absent ⇒ "not answered".
+     */
+    readonly unansweredReason?: string;
+    /** ggui#1687 — the call that answered, as it came back: its answer's counts and its stop reason. */
+    readonly call?: {
+        readonly answer: CriteriaAnswerCounts;
+        readonly finishReason?: VisionFinishReason;
+    };
+}): CriteriaBlock;
+/** The judge's prompt block for the selected `judge` rows; empty when none is selected. */
+/** The capture the judge is handed: its canvas class and the box it was taken at (the class box, or a declared one). */
+interface CriteriaJudgeFrame {
+    readonly canvas: CriteriaContext['canvas'];
+    readonly width: number;
+    readonly height: number;
+    /** ggui#1492 — the host whose presentation framed this canvas (e.g. "a chat widget, inline, reference theme"); absent ⇒ the judge's own stand-in. */
+    readonly hostLabel?: string;
+}
+/** What the block carries besides the selected rows: the frame's box, and the props the card was rendered with. */
+interface CriteriaJudgeInputs {
+    readonly frame?: CriteriaJudgeFrame;
+    /** JSON text of the props the card was rendered with; bounded by {@link CRITERIA_PROPS_MAX_CHARS}. */
+    readonly propsJson?: string;
+}
+/** The judge's prompt block for the selected `judge` rows; empty when none is selected. */
+declare function buildCriteriaJudgeBlock(bank: CriteriaBank, selected: CriteriaSelectionResult, inputs?: CriteriaJudgeInputs): string;
+
 /**
- * Run visual evaluation on a compiled component.
+ * `space.edge`'s measurement (#1663): the expression a capture evaluates in the page to produce {@link EdgeBlock}s for
+ * {@link judgeEdges}. It runs where the screenshot is taken, on the same DOM at the same width, so the rule reads what
+ * the judge's frame shows. It only reads layout; it never writes to the page.
  *
- * 1. Builds an HTML page with the component + sample props
- * 2. Takes a screenshot via puppeteer (if available)
- * 3. Sends screenshot to multimodal LLM for visual scoring
+ * What it measures, under `#root`, in CSS px from the card's left edge:
  *
- * Returns null if puppeteer is not available (graceful fallback).
- */
-/**
- * The judge's answer WITH the reason when it could not judge: `result` is
- * null exactly when no screenshot could be taken (no browser, a launch or
- * in-page failure) or the component could not be bundled; `unavailableReason`
- * names why in words and `canvas` the canvas it happened at. A production
- * caller records the reason in its receipt — a `judge_unavailable` that only
- * says "null" cost a log dive on 2026-09-10 (puppeteer-core missing in the
- * deploy image).
+ * - **Text blocks.** Text is grouped by its nearest non-inline element. A block's edge is its first visible character
+ *   in ink: text in a transparent colour, private-use icon-font glyphs and formatting characters are not characters of
+ *   the block. Its extent is the union of its inked line boxes. A marker before the text (an icon or image that paints,
+ *   or a number or bullet on the same line) makes it a hanging marker: `edge` is the marker's, `textEdge` the text's.
+ * - **Control groups.** Native and ARIA controls, and bounded boxes the visitor clicks (a pointer cursor or a tab stop,
+ *   holding no control of their own), group by their parent and are measured at the first control: the border box
+ *   when bounded, else its text. A control's contents are never blocks of the enclosing column.
+ * - **Surfaces.** A non-inline box with a border on at least three sides, its own fill different from what it sits on,
+ *   or a shadow. A table is a surface measured at its rule and not descended into. A box with no text, control, image
+ *   or icon inside (a loading bar) is a `placeholder`, which is not a block.
+ * - **Roles.** A list item is `list-item` when its list follows a paragraph; text centred in a box wider than it, or
+ *   controls in a centring row, are `centred`.
+ * - **Rows, first, read by geometry.** Items set on one line, however the CSS lays them out: 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.
+ * - **Ornaments:** text with no letters or digits is not measured.
+ *
+ * Hidden elements (through any ancestor), zero-size ones and transparent text are skipped. What the rows and ornament
+ * rules set aside is counted. A frame with no text in ink is reported as placeholders only. The expression returns a
+ * JSON value; {@link parseEdgeProbe} is its typed read. *
+ * **Validated instrument (#1663, 2026-10-02):** this file as of `cec465319` (with `7bb4da13e`) passed a fresh sealed
+ * blind draw at the registered bar (27/30, κ 0.76), stricter than the design lead's reading on its disagreements. Any
+ * later change to what this file measures or decides is a new instrument until another fresh sealed draw.
  */
-interface VisualEvalDetailed {
-    readonly result: VisualEvaluationResult | null;
-    readonly unavailableReason?: string;
-    readonly canvas?: CanvasClass;
-}
-declare function runVisualEvaluation(context: VisualEvalContext, config: VisualEvalConfig, deps?: VisualEvalDeps): Promise<VisualEvaluationResult | null>;
-declare function runVisualEvaluationDetailed(context: VisualEvalContext, config: VisualEvalConfig, deps?: VisualEvalDeps): Promise<VisualEvalDetailed>;
-/** The per-canvas verdicts without the PNGs — what the harness stamps on `EvalResult.visual`. */
-declare function summarizeVisualResult(result: VisualEvaluationResult): VisualEvalSummary | undefined;
 
-/** What the harness's eval round consumes from the visual leg. */
-interface VisualEvalOutcome {
-    /** Tier-2 issues (empty when no browser is available). */
-    issues: EvalIssue[];
-    /**
-     * Per-canvas summary — present ONLY when `config.canvases` was set and
-     * the leg ran; the harness stamps it on `EvalResult.visual`. Absent on
-     * the single-shot path (byte-identical to the pre-canvas result).
-     */
-    summary?: VisualEvalSummary;
-    /**
-     * ggui#1221 — whether the judge leg ran or was skipped (with the reason
-     * `runVisualEvaluationDetailed` names). Always present: the absence of a
-     * summary used to be indistinguishable from a clean single-shot run.
-     */
-    coverage: VisualCoverage;
+/** What the probe returns: the measured blocks, and whether the frame showed nothing to evaluate. */
+interface EdgeProbe {
+    readonly blocks: readonly EdgeBlock[];
+    readonly placeholdersOnly: boolean;
+    /** What the probe saw and did not measure, by rule, so a dropped block is counted rather than silent. */
+    readonly skipped: {
+        readonly rowItems: number;
+        readonly ornaments: number;
+    };
 }
+declare const EDGE_BLOCKS_EXPRESSION: string;
 /**
- * Run visual evaluation and return tier 2 EvalIssues (+ the per-canvas
- * summary when canvases were requested).
+ * The probe's typed read: `null` when the page had no `#root` or returned something else, so a failed measurement is
+ * reported as unmeasured and never read as "no offsets". A malformed block fails the whole read for the same reason.
  */
-declare function runVisualEval(context: VisualEvalContext, config: VisualEvalConfig, deps?: VisualEvalDeps): Promise<VisualEvalOutcome>;
+declare function parseEdgeProbe(value: unknown): EdgeProbe | null;
 
 /**
- * The stylesheet a visual judge renders under for an app: the app's theme
- * composed the way the runtime composes it (`composeThemeCss`, layer `page`
- * — one composition, never a second), so a judged canvas paints the tokens a
- * visitor's page paints. Absent theme ⇒ the design's default tokens,
- * byte-for-byte what the judge used before.
+ * ggui#1640 — one judged frame's (or one visual evaluation's) spend, summed over EVERY leg the judge reports.
+ *
+ * The judge reports its legs apart: the scoring calls' `inputTokens` / `outputTokens`, and, since ggui#1436, the
+ * report-only criteria call's `criteriaTokens`. A caller that sums only the first leg under-counts, and a dollar
+ * ceiling built on that sum stops late. {@link judgedFrameTokens} is the one sum. The two `satisfies` tables below list
+ * every `*Tokens` member of the results it reads, so a leg added to either result type fails the build here until the
+ * sum counts it.
  */
-declare function cssTokensForAppTheme(theme: AppTheme | undefined, mode?: 'light' | 'dark'): string;
 
-export { CONTENT_HEIGHT_EXPRESSION, CanvasClass, type CanvasFitPolicy, CanvasJudgeRecord, CanvasViewport, type CanvasVisualResult, type CaptureMode, type ChromiumProvider, EvalIssue, type EvaluateScoreInput, EvaluationConfig, EvaluationContext, EvaluationIssue, type EvaluationLoopOptions, type EvaluationLoopResult, EvaluationResult, type JudgeDesignIdentity, QualityMetadata, type ScreenshotAttempt, type ScreenshotBrowser, type ScreenshotDeps, type ScreenshotLauncher, type ScreenshotPage, type SdkMessage, VISUAL_EVAL_PROMPT, VISUAL_JUDGE_MAX_OUTPUT_TOKENS, VISUAL_JUDGE_PROMPT_DIGEST, VISUAL_JUDGE_PROMPT_VERSION, type VisualEvalConfig, type VisualEvalContext, type VisualEvalDeps, type VisualEvalDetailed, type VisualEvalOutcome, VisualEvalSummary, type VisualEvaluationResult, buildFixPrompt, callMultimodalLLM, canvasFitPolicy, canvasOverflowIssue, captureScreenshot, captureScreenshotDetailed, computeEvaluationScore, createEvaluationToolsServer, cssTokensForAppTheme, designTreeSha256, extractCompiledCode, extractCompiledCodeFromMessage, extractEvalResult, extractSourceCode, extractSourceCodeFromMessage, extractToolResultTexts, getEvaluatorSystemPrompt, judgeDesignIdentity, resetJudgeDesignIdentityCache, resolveDesignPackageDir, resolveLaunchOptions, runEvaluation, runEvaluationLoop, runVisualEval, runVisualEvaluation, runVisualEvaluationDetailed, summarizeVisualResult };
+/** A spend in tokens: input and output, over every leg. */
+interface JudgeSpend {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+/** The legs {@link judgedFrameTokens} reads, as both result types carry them. */
+interface JudgedTokens {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly criteriaTokens?: CriteriaCallTokens;
+}
+/** A judged frame's spend over every leg: the scoring calls plus the report-only criteria call, when one ran. */
+declare function judgedFrameTokens(result: JudgedTokens): JudgeSpend;
+
+export { CRITERIA_SELECTOR_VERSION, CriteriaBank, CriteriaCallTokens, type CriteriaMeasurements, type CriteriaSelectionResult, type DecodedImage, EDGE_BLOCKS_EXPRESSION, EdgeBlock, type EdgeProbe, EdgeVerdict, type EvaluateScoreInput, EvaluationConfig, EvaluationContext, EvaluationIssue, type EvaluationLoopOptions, type EvaluationLoopResult, EvaluationResult, INK_TOLERANCE, INSTRUMENT_BESIDE_JUDGE, INSTRUMENT_BY_ID, type InkExtent, type InkUnreadable, type JudgeSpend, type JudgedTokens, type PixelRegion, QualityMetadata, type SdkMessage, buildCriteriaJudgeBlock, buildFixPrompt, canonicalCriteriaContext, computeEvaluationScore, createEvaluationToolsServer, criteriaSetIdFor, cssTokensForAppTheme, decodePng, extractCompiledCode, extractCompiledCodeFromMessage, extractEvalResult, extractSourceCode, extractSourceCodeFromMessage, extractToolResultTexts, getEvaluatorSystemPrompt, judgedFrameTokens, parseEdgeProbe, readInkExtent, resolveCriteriaBlock, runEvaluation, runEvaluationLoop, selectCriteria };