@ggui-ai/ui-gen 0.24.0 → 0.25.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 { 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 * 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';
+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';
-import { AppTheme } from '@ggui-ai/protocol';
 import '@ggui-ai/mcp-server-core';
-import '../axes-CzLEMDeB.js';
-import '../types-BOvHNG7K.js';
+import '../types-Dh1s4K9j.js';
 import '../llm.js';
+import 'zod';
 
 /**
  * Options for running the evaluation loop.
@@ -186,6 +189,26 @@ 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;
@@ -260,6 +283,14 @@ interface VisualEvalConfig {
      * `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
@@ -292,6 +323,14 @@ interface VisualEvalConfig {
      */
     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;
@@ -311,32 +350,91 @@ interface CanvasVisualResult {
     /** `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';
+type CaptureMode = 'viewport' | 'full-page' | 'natural';
 interface CanvasFitPolicy {
-    /** `viewport` = the judge sees the box the user sees; `full-page` = the whole scrolled document. */
+    /**
+     * `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 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.
+ * 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
@@ -345,6 +443,11 @@ declare function canvasOverflowIssue(canvas: CanvasClass, viewport: CanvasViewpo
  */
 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). */
@@ -364,6 +467,11 @@ interface VisualEvalContext {
     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
@@ -380,6 +488,13 @@ interface VisualEvalContext {
  * 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: {
@@ -398,6 +513,7 @@ interface ScreenshotPage {
     screenshot(options: {
         type: 'png';
         fullPage: boolean;
+        clip?: ScreenshotClip;
     }): Promise<Uint8Array>;
 }
 /** The browser surface the capture uses — a structural subset of puppeteer's `Browser`. */
@@ -446,13 +562,22 @@ interface ScreenshotAttempt {
     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): Promise<ScreenshotAttempt>;
+}, deps?: ScreenshotDeps, capture?: CaptureMode, natural?: NaturalCaptureOptions): Promise<ScreenshotAttempt>;
 declare function captureScreenshot(html: string, viewport?: {
     width: number;
     height: number;
@@ -485,7 +610,7 @@ declare const VISUAL_JUDGE_MAX_OUTPUT_TOKENS = 4096;
  */
 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 callMultimodalLLM(config: VisualEvalConfig, model: string, prompt: string, screenshot: Buffer, originalPrompt: string, profileBlock?: string, criteriaBlock?: string): Promise<LLMResponse>;
 /**
  * Run visual evaluation on a compiled component.
  *
@@ -513,6 +638,58 @@ declare function runVisualEvaluation(context: VisualEvalContext, config: VisualE
 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 {
@@ -537,13 +714,113 @@ interface VisualEvalOutcome {
  */
 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 {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+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];
+}
+/** Why a capture could not be read — reported, never mistaken for a blank. */
+interface InkUnreadable {
+    readonly reason: string;
+}
+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 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.
+ */
+declare function readInkExtent(png: Uint8Array, insetPx?: number): InkExtent | InkUnreadable;
+
 /**
  * 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.
+ * 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 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[];
+}
+/**
+ * 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.
+ */
+declare function selectCriteria(bank: CriteriaBank, ctx: CriteriaContext): CriteriaSelectionResult;
+
+/**
+ * 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 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 };
+/** 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'>>;
+interface CriteriaMeasurements {
+    readonly overflow: boolean;
+    readonly contentHeight: number | null;
+    readonly viewportHeight: number;
+    readonly inkRatio: number | null;
+}
+declare function resolveCriteriaBlock(args: {
+    readonly bank: CriteriaBank;
+    readonly context: CriteriaContext;
+    readonly selected: CriteriaSelectionResult;
+    readonly answers: readonly CriteriaAnswer[][];
+    readonly measurements: CriteriaMeasurements;
+}): 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;
+
+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 };