@ggui-ai/ui-gen 0.25.0 → 0.26.0

package/dist/evaluation/index.d.ts

@@ -1,22 +1,22 @@
-import { C as CriteriaContext, d as CriteriaChroma, e as CanvasJudgeRecord, f as CriteriaBlock, g as CanvasPresentationOutcome, h as CanvasHostPresentation, E as EvalIssue, V as VisualEvalSummary, i as VisualCoverage, j as CriteriaSelection } from '../types-public-BJTLpzWn.js';
-export { A as AxisCheck, a as AxisCheckInput, k as CRITERIA, l as CanvasVisualSummary, n as ContractFeedbackRecord, o as CriterionCoverage, p as CriterionRunStatus, D as DEFAULT_QUALITY_CONFIG, q as EvalCategory, r as EvalCriterion, s as EvalOutcome, b as EvalResult, c as EvalTier, H as HostInlineFrame, t as HostPresentationIgnoredReason, L as LLM_EVAL_STATIC_CRITERIA, u as Priority, Q as QualityConfig, v as QualityMode, w as buildCodingCriteriaSummary, x as criteriaFor, y as getActionableIssues, z as getCriteriaByPriority, B as getCriterionById, F as getLLMCriteria, G as isBlocked, m as matches, I as notApplicableCoverage, J as priorityForIssue } from '../types-public-BJTLpzWn.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, 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-CStl9eAw.js';
-import { A as AgentConfig, L as LLMResponse } from '../llm-router-nfO7wPec.js';
-import { G as GenerationProfileInput } from '../styling-profile-CxfvV48g.js';
-import { C as CriteriaBank } from '../bank-CT4eEkta.js';
-export { B as BankRow, a as CriteriaScope, b as bankRows, c as criteriaBankSchema, p as parseCriteriaBank } from '../bank-CT4eEkta.js';
-import { DataContract, JsonObject, AppTheme } from '@ggui-ai/protocol';
-import { C as Classification } from '../axes-CKVCzR_x.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 { 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 '../llm.js';
+import '../styling-profile-CxfvV48g.js';
+import 'puppeteer-core';
 import 'zod';
 
 /**
@@ -189,531 +189,6 @@ declare function extractCompiledCode(messages: SdkMessage[]): string | undefined
  */
 declare function extractSourceCode(messages: SdkMessage[]): string | undefined;
 
-/**
- * The selector's inputs for one card — ggui#1436. Every key here is hashed into `criteriaSetId`
- * and STORED in the block (the CTO's A1), so a stored verdict reproduces its own set from the
- * record alone. `canvas` is added per canvas inside the judge; the rest is the harness's.
- */
-
-/** Read the theme's chroma off its tokens; `unknown` when no primary is named. */
-declare function chromaOfCssTokens(cssTokens: string | undefined): CriteriaChroma;
-interface CriteriaContextSources {
-    readonly classification: Classification;
-    readonly contract: DataContract | undefined;
-    readonly cssTokens: string | undefined;
-    readonly profile: GenerationProfileInput | undefined;
-    readonly shell: string;
-    readonly kind?: string;
-}
-/** The context minus `canvas` — the judge fills that per canvas. */
-type CriteriaContextInput = Omit<CriteriaContext, 'canvas'>;
-declare function criteriaContextFor(src: CriteriaContextSources): CriteriaContextInput;
-
-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;
-}
-/**
- * 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>>>;
-    /**
-     * ggui#1492 — how a host presents each canvas, as data the caller supplies (a lane that knows its host). Keyed by
-     * canvas; a canvas without an entry is judged exactly as before (the generic stand-in round the inline card, the
-     * scrim under a panel). The box stays in {@link canvasViewports}. An entry this judge cannot use (a colour that is
-     * not `#rrggbb`, a number out of range, a frame on a canvas that is not the inline card) is ignored for its canvas,
-     * said once in the log, never partly applied.
-     */
-    hostPresentations?: Partial<Readonly<Record<CanvasClass, CanvasHostPresentation>>>;
-    /**
-     * 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'];
-}
-/**
- * ggui#1436 — what the report-only criteria call spent. Kept APART from the scoring calls' `inputTokens` /
- * `outputTokens`: those price the judgement a caller may meter, and the criteria call is a measurement beside it.
- */
-interface CriteriaCallTokens {
-    readonly inputTokens: number;
-    readonly outputTokens: 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). */
-    /**
-     * ggui#1120 — how far down the capture anything was painted (the last inked row over the measured
-     * region's height, read against the capture's dominant colour, inside a drawn panel's chrome); `0`
-     * is the blank the judge fails, `null` an unreadable capture.
-     */
-    inkRatio: number | null;
-    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;
-    /** ggui#1436 — the typed criteria block, when a bank was configured. */
-    criteria?: CriteriaBlock;
-    /** ggui#1436 — the criteria call's own spend, when one was asked and answered; never inside the canvas's scoring tokens. */
-    criteriaTokens?: CriteriaCallTokens;
-    /** ggui#1492 — what the judge did with this canvas's host presentation (drawn, or ignored and why), when one was supplied. */
-    presentation?: CanvasPresentationOutcome;
-}
-/** How a canvas is captured for the judge and what an overflow means there (ggui#1027). */
-type CaptureMode = 'viewport' | 'full-page' | 'natural';
-interface CanvasFitPolicy {
-    /**
-     * `viewport` = the whole box; `full-page` = the whole scrolled document; `natural` (ggui#1475) = the
-     * card at its OWN height, clipped to its extent and capped at the box — the inline card a host sizes
-     * to its content, on the host's ground ({@link JUDGE_GROUND_MARGIN_PX}).
-     */
-    readonly capture: CaptureMode;
-    /** The verdict an overflow earns on this canvas. */
-    readonly overflow: 'fail' | 'warn' | 'none';
-}
-/**
- * The inline chat card takes its NATURAL height under a ceiling (ggui#1475):
- * an MCP Apps host sizes the inline frame to the card's content
- * (`ui/notifications/size-changed`, auto-resize) up to its maximum, so the
- * visitor sees the card and nothing under it. The judge captures exactly
- * that — the card's own extent on the host's ground, capped at the box — and
- * never the box's remainder (a fixed 640 px capture scored every hello
- * against a void no visitor sees). The box stays the ceiling: content taller
- * than it is a critical layout issue that fails the canvas (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). 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;
-/**
- * How far in from a panelled page's edges the ink is read (ggui#1120): past the panel's gap, its
- * largest rounded corner (the `round` bucket, 24 px — the scrim shows through the corner) and its
- * 1 px hairline, so the host's chrome never counts as paint. The card's own inset is 16 px, so the
- * band skipped inside the card is 25 px of a canvas — reported ratios are over the region.
- */
-declare const JUDGE_INK_INSET_PX: number;
-/**
- * The host ground round a naturally-captured inline card (ggui#1475): the card is mounted this far in
- * from the page's edges and captured with this margin, so its edge and radius are read against the
- * host surface — the page's scrim ground, never the card's own. The design's one gap (the panel's).
- */
-declare const JUDGE_GROUND_MARGIN_PX: 16;
-/**
- * The bounds a host frame must meet to be drawn (ggui#1492), exported so a lane's reader applies exactly the frames
- * this judge draws: an entry the reader accepts and the judge ignores would be echoed as applied while never drawn.
- */
-declare const HOST_COLOUR_PATTERN: RegExp;
-declare const HOST_FRAME_BOUNDS: {
-    readonly ringWidthPx: {
-        readonly min: 0;
-        readonly max: 8;
-    };
-    readonly ringAlpha: {
-        readonly min: 0;
-        readonly max: 1;
-    };
-    readonly radiusPx: {
-        readonly min: 0;
-        readonly max: 64;
-    };
-    readonly minHeightPx: {
-        readonly min: 0;
-        readonly max: 2560;
-    };
-};
-/** 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;
-/** ggui#1120 — the deterministic blank: the capture is one flat colour, so the component mounted and painted nothing. */
-declare function canvasBlankIssue(canvas: CanvasClass, viewport: CanvasViewport): 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`).
- */
-interface VisualEvaluationResult extends EvaluationResult {
-    canvases?: CanvasVisualResult[];
-    /**
-     * ggui#1436 — the criteria calls' spend across canvases, when any was asked and answered. `inputTokens` /
-     * `outputTokens` stay the SCORING calls' alone, so a cost read off them never includes the report-only block.
-     */
-    criteriaTokens?: CriteriaCallTokens;
-    /** 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;
-    /** ggui#1436 — a criteria bank and the card's context; the judge selects per canvas and answers report-only. */
-    criteria?: {
-        readonly bank: CriteriaBank;
-        readonly context: CriteriaContextInput;
-    };
-}
-/**
- * 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.
- */
-declare function resolveDesignPackageDir(): string;
-/** A screenshot's region in page px (puppeteer's `clip`). */
-interface ScreenshotClip {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-/** 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;
-        clip?: ScreenshotClip;
-    }): 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>;
-}
-/**
- * Injection points for the capture — every default is the production
- * path; tests replace them to pin branch selection without launching a
- * browser.
- */
-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;
-}
-/**
- * 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.
- */
-declare function resolveLaunchOptions(viewport: {
-    width: number;
-    height: number;
-}, deps?: Pick<ScreenshotDeps, 'env' | 'loadChromium'>): Promise<LaunchOptions>;
-/**
- * Take a screenshot of the rendered component.
- * Returns the PNG bytes, or null if no browser could be launched.
- */
-/** 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. */
-    readonly contentHeight: number | null;
-    /** ggui#1475 — a natural capture's horizontal overflow: how many px the card's content runs past its width; absent on every other capture. */
-    readonly overflowX?: number | 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)";
-/** The stand-in page's card height ({@link cardHeightExpression} at the stand-in's pad). */
-declare const CARD_HEIGHT_EXPRESSION: string;
-/** ggui#1492 — a natural capture's geometry: the page's pad per side, and the host's floor when it has one. */
-interface NaturalCaptureOptions {
-    readonly padPx: number;
-    readonly floorPx?: number;
-}
-declare function captureScreenshotDetailed(html: string, viewport?: {
-    width: number;
-    height: number;
-}, deps?: ScreenshotDeps, capture?: CaptureMode, natural?: NaturalCaptureOptions): 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, criteriaBlock?: string): Promise<LLMResponse>;
-/**
- * Run visual evaluation on a compiled component.
- *
- * 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
- *
- * 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).
- */
-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;
-/** One stored capture to judge: the frame the judge saw at capture time, plus what the capture measured. */
-interface StoredCaptureInput {
-    readonly canvas: CanvasClass;
-    /** The capture as saved (`canvas-<class>.png`). */
-    readonly png: Buffer;
-    /** The box the capture was taken at — the class box, or the declared one. */
-    readonly viewport: CanvasViewport;
-    /** The document's scroll height the capture recorded; `null` when it did not. */
-    readonly contentHeight: number | null;
-    readonly originalPrompt: string;
-    readonly profile?: GenerationProfileInput;
-    /** ggui#1436 — the bank and the card's context; absent = today's judge, no block. */
-    readonly criteria?: {
-        readonly bank: CriteriaBank;
-        readonly context: CriteriaContextInput;
-    };
-    /** The props the capture was rendered with — handed to the criteria block for the rows whose evidence names props. */
-    readonly sampleProps?: JsonObject;
-}
-interface StoredCaptureVerdict {
-    readonly canvas: CanvasClass;
-    readonly viewport: CanvasViewport;
-    readonly score: number;
-    readonly passed: boolean;
-    readonly issues: EvaluationIssue[];
-    readonly judge: CanvasJudgeRecord;
-    readonly contentHeight: number | null;
-    readonly overflow: boolean;
-    readonly inkRatio: number | null;
-    readonly criteria?: CriteriaBlock;
-    /** The scoring calls' spend. */
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    /** ggui#1436 — the report-only criteria call's spend, apart from the scoring calls'; absent when none was asked or answered. */
-    readonly criteriaTokens?: CriteriaCallTokens;
-}
-type StoredCaptureOutcome = {
-    readonly kind: 'ok';
-    readonly verdict: StoredCaptureVerdict;
-} | {
-    readonly kind: 'unavailable';
-    readonly reason: string;
-};
-/**
- * Judge a STORED capture exactly as the per-canvas leg judges a fresh one — the same K scoring calls on the
- * same frame, the same median, the same fit and blank verdicts, the same report-only criteria call — without
- * rendering.
- * This is the calibration's path (ggui#1438): the frame his eye marks is the frame the judge saw, and a
- * re-judge costs judge tokens only. Fit reads the capture's recorded `contentHeight`; ink is read off the
- * PNG inside the canvas's chrome, as at capture.
- */
-declare function judgeStoredCapture(input: StoredCaptureInput, config: VisualEvalConfig, deps?: Pick<VisualEvalDeps, 'judge'>): Promise<StoredCaptureOutcome>;
-
-/** 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;
-}
-/**
- * Run visual evaluation and return tier 2 EvalIssues (+ the per-canvas
- * summary when canvases were requested).
- */
-declare function runVisualEval(context: VisualEvalContext, config: VisualEvalConfig, deps?: VisualEvalDeps): Promise<VisualEvalOutcome>;
-
 /** A channel difference at or below this is the same colour (anti-aliasing and compositing noise). */
 declare const INK_TOLERANCE = 8;
 interface PixelRegion {
@@ -792,11 +267,21 @@ declare function selectCriteria(bank: CriteriaBank, ctx: CriteriaContext): Crite
 
 /** 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'>>;
+/**
+ * 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.
+ */
+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;
 }
 declare function resolveCriteriaBlock(args: {
     readonly bank: CriteriaBank;
@@ -804,6 +289,16 @@ declare function resolveCriteriaBlock(args: {
     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). */
@@ -823,4 +318,77 @@ interface CriteriaJudgeInputs {
 /** 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;
 
-export { CARD_HEIGHT_EXPRESSION, CONTENT_HEIGHT_EXPRESSION, CRITERIA_SELECTOR_VERSION, CanvasClass, type CanvasFitPolicy, CanvasHostPresentation, CanvasJudgeRecord, CanvasPresentationOutcome, CanvasViewport, type CanvasVisualResult, type CaptureMode, type ChromiumProvider, CriteriaBank, type CriteriaCallTokens, type CriteriaContextInput, type CriteriaContextSources, type CriteriaMeasurements, type CriteriaSelectionResult, type DecodedImage, EvalIssue, type EvaluateScoreInput, EvaluationConfig, EvaluationContext, EvaluationIssue, type EvaluationLoopOptions, type EvaluationLoopResult, EvaluationResult, HOST_COLOUR_PATTERN, HOST_FRAME_BOUNDS, INK_TOLERANCE, INSTRUMENT_BY_ID, type InkExtent, type InkUnreadable, JUDGE_GROUND_MARGIN_PX, JUDGE_INK_INSET_PX, type JudgeDesignIdentity, type NaturalCaptureOptions, type PixelRegion, QualityMetadata, type ScreenshotAttempt, type ScreenshotBrowser, type ScreenshotClip, type ScreenshotDeps, type ScreenshotLauncher, type ScreenshotPage, type SdkMessage, type StoredCaptureInput, type StoredCaptureOutcome, type StoredCaptureVerdict, 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, buildCriteriaJudgeBlock, buildFixPrompt, callMultimodalLLM, canonicalCriteriaContext, canvasBlankIssue, canvasFitPolicy, canvasOverflowIssue, captureScreenshot, captureScreenshotDetailed, chromaOfCssTokens, computeEvaluationScore, createEvaluationToolsServer, criteriaContextFor, criteriaSetIdFor, cssTokensForAppTheme, decodePng, designTreeSha256, extractCompiledCode, extractCompiledCodeFromMessage, extractEvalResult, extractSourceCode, extractSourceCodeFromMessage, extractToolResultTexts, getEvaluatorSystemPrompt, judgeDesignIdentity, judgeStoredCapture, readInkExtent, resetJudgeDesignIdentityCache, resolveCriteriaBlock, resolveDesignPackageDir, resolveLaunchOptions, runEvaluation, runEvaluationLoop, runVisualEval, runVisualEvaluation, runVisualEvaluationDetailed, selectCriteria, summarizeVisualResult };
+/**
+ * `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.
+ *
+ * What it measures, under `#root`, in CSS px from the card's left edge:
+ *
+ * - **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.
+ */
+
+/** 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;
+/**
+ * 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 parseEdgeProbe(value: unknown): EdgeProbe | null;
+
+/**
+ * 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.
+ */
+
+/** 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 };