@ggui-ai/ui-gen 0.23.0 → 0.25.0

package/dist/{types-public-Ow-tNtFE.d.ts → types-public-BJTLpzWn.d.ts}

@@ -1,7 +1,8 @@
+import { GenerationRuntimeProbeStatus, GenerationRuntimeProbeOutcome } from '@ggui-ai/mcp-server-core';
 import { C as CanvasClass, D as DesignMode } from './design-mode-DLufhrNp.js';
-import { DataContract } from '@ggui-ai/protocol';
-import { C as Classification, A as AxisVector } from './axes-CzLEMDeB.js';
-import { A as AxisKey } from './types-BOvHNG7K.js';
+import { R as RiskTier, a as RenderShape, S as StateShape, W as WriteShape, F as FetchShape, L as LayoutShape, C as Classification, A as AxisVector } from './axes-CKVCzR_x.js';
+import { DataContract, JsonObject } from '@ggui-ai/protocol';
+import { A as AxisKey } from './types-Dh1s4K9j.js';
 
 type Priority = "P0" | "P1" | "P2";
 
@@ -27,8 +28,10 @@ interface EvalIssue {
     line?: number;
 }
 /**
- * Runtime-render probe execution status — three-valued so "the probe
- * never ran" is never conflated with "the probe ran clean".
+ * Runtime-render probe execution status — four-valued so "the probe
+ * never ran" is never conflated with "the probe ran clean". ONE union: the
+ * same values a generation's metadata reports (`GenerationRuntimeProbeStatus`
+ * in `@ggui-ai/mcp-server-core`), declared there and named here.
  *
  *   - `ran`           — probe executed; its findings (possibly none) are
  *                       in the issue stream under `runtime:*` subcategories.
@@ -47,7 +50,7 @@ interface EvalIssue {
  *                       `hostLoad` say how long it ran and how busy the
  *                       host was, so a reader can tell the two cases apart.
  */
-type RuntimeProbeStatus = "ran" | "infra-skipped" | "not-applicable" | "timed-out";
+type RuntimeProbeStatus = GenerationRuntimeProbeStatus;
 /**
  * The host's 1-minute load average at a probe's start and end, beside the
  * number of CPUs the process can use (ggui#1299). A load well above
@@ -60,20 +63,79 @@ interface ProbeHostLoad {
     readonly cores: number;
 }
 /**
- * Probe execution meta stamped onto an `EvalResult` at the exit-decision
- * points that invoke the probe. Absence of this field means the eval
- * path never reached a probe invocation at all — consumers treat that
- * the same as not-run, never as a pass.
+ * The engine's own fields on a probe's meta, beside the outcome a
+ * generation's metadata reports: why a probe did not finish, its render
+ * time, the host's load around it. Present on every arm of
+ * {@link RuntimeProbeMeta}; each is absent when the probe had nothing to
+ * say about it.
  */
-interface RuntimeProbeMeta {
-    readonly status: RuntimeProbeStatus;
+interface RuntimeProbeMetaDetail {
     /** Populated for `infra-skipped` / `not-applicable` / `timed-out` — why the probe didn't finish. */
     readonly reason?: string;
-    /** `timed-out` only: how long the probe ran before it was stopped. */
-    readonly elapsedMs?: number;
+    /** `ran` only: the check's own render time, inside `elapsedMs`. */
+    readonly renderMs?: number;
     /** Host load around the probe, when it ran isolated (absent for an in-process probe). */
     readonly hostLoad?: ProbeHostLoad;
+    /** Time the check waited for a probe slot before it started, ms; present only when > 0 (ggui#1380 C2b). */
+    readonly queuedMs?: number;
 }
+/**
+ * Probe execution meta stamped onto an `EvalResult` at the exit-decision
+ * points that invoke the probe. Absence of this field means the eval
+ * path never reached a probe invocation at all — consumers treat that
+ * the same as not-run, never as a pass.
+ *
+ * ONE union with the generation metadata's probe outcome
+ * (`GenerationRuntimeProbeOutcome` in `@ggui-ai/mcp-server-core`, declared
+ * there and carried here with {@link RuntimeProbeMetaDetail} on every arm),
+ * so the round's stamp and the metadata's record cannot say different
+ * things (ggui#1380):
+ *
+ *   - `ran` + `verdict: 'pass'` — the probe executed and no check failed;
+ *   - `ran` + `verdict: 'fail'` — ANY check failed; `failChecks` lists the
+ *     distinct check kinds that did (`RenderCheckKind`, the engine's name
+ *     for the same union), never empty, in the order `RENDER_CHECK_KINDS`
+ *     declares them, parsed from the probe's own
+ *     `runtime:<check>[:<subject>]` issues;
+ *   - `timed-out` / `infra-skipped` / `not-applicable` — no verdict, and the
+ *     type carries none. `elapsedMs` (on every status that reached the
+ *     check) and `hostLoad` say how long it ran and how busy the host was.
+ *
+ * The verdict and the repair trigger are two different questions. The
+ * verdict is `fail` on any failing check. The one repair turn a probe-only
+ * round buys fires on a `render-no-throw` fail the engine recognises
+ * (`isRecoverableRenderCrash`) and on nothing else: on the PROBE-ONLY round a
+ * `fail` verdict whose checks are `prop-sensitivity`, `action-wiring` or any
+ * other kind is recorded here and never fed back. The same meta is stamped on
+ * the EVALUATION lane, where a `prop-sensitivity` fail buys that lane's own
+ * contract-feedback round (ggui#1261, `FEEDBACK_PROBE_CHECKS`) — a different
+ * turn under a different rule, not the repair turn.
+ */
+type RuntimeProbeMeta = GenerationRuntimeProbeOutcome & RuntimeProbeMetaDetail;
+/**
+ * The one repair turn a probe-only round buys (ggui#1380). A serving
+ * deployment that wires the runtime probe and configures no evaluator runs
+ * the probe once after the coding turns; a render crash the engine
+ * recognises buys exactly one repair turn, then one re-probe. This records
+ * what came of it:
+ *   - `compiled: false` — the repair turn's code did not pass self-check, so
+ *     no re-probe ran (there is no `after`) and the pre-repair card is the
+ *     one served;
+ *   - `compiled: true` — the re-probe ran and `after` is its whole meta:
+ *     its status, its verdict when it ran, and the checks that still fail.
+ *     Whether the crash class the turn was bought for is still there is
+ *     `after.verdict === 'fail' && after.failChecks.includes('render-no-throw')`.
+ * The two arms are exclusive by type.
+ */
+type RuntimeProbeRepair = {
+    readonly attempted: true;
+    readonly compiled: false;
+    readonly trigger?: never;
+} | {
+    readonly attempted: true;
+    readonly compiled: true;
+    readonly trigger: RuntimeProbeMeta;
+};
 /**
  * Per-criterion execution status — three-valued so "the criterion
  * silently produced no verdict" is never conflated with "the criterion
@@ -169,6 +231,13 @@ interface EvalResult {
      * probe runner; absent on eval paths that never invoke the probe.
      */
     runtimeProbe?: RuntimeProbeMeta;
+    /**
+     * The probe-only round's repair record (ggui#1380) — present only when a
+     * recoverable render crash bought the one repair turn. See
+     * {@link RuntimeProbeRepair}. `runtimeProbe` beside it is the re-probe's
+     * verdict when the repair compiled, else the pre-repair probe's.
+     */
+    runtimeProbeRepair?: RuntimeProbeRepair;
     /**
      * The contract-feedback round, when one fired this generation (ggui#1261):
      * which exit-probe findings bought it and the source as it stood when the
@@ -212,6 +281,109 @@ interface CanvasJudgeRecord {
     /** The judge's per-canvas critique per sample — the words beside a swing. */
     readonly notes: string[];
 }
+
+type CriteriaSeverity = "must" | "should";
+type CriteriaVerdict = "pass" | "fail" | "n/a";
+/** The method that produces a verdict: an instrument's measurement, the vision judge off the frame, or a person's eye. */
+type CriteriaMethod = "instrument" | "judge" | "human";
+/** The method's readiness, as the bank's author wrote it — the only source of an `n/a` that is not the judge's own. */
+type CriteriaStatus = "live" | "reference" | "planned" | "manual";
+/**
+ * How a criterion entered the selection: bank-level (`static`, an empty scope) or by the selector's
+ * rules for this card (`context`). A model PROPOSING a criterion at judge time is RESERVED and not a
+ * member until a consumer exists — it would be `should`-only, recorded verbatim, never a gate.
+ */
+type CriteriaSource = "static" | "context";
+type CriteriaChroma = "achromatic" | "chromatic" | "unknown";
+/** The classifier's shape axes, as hashed into the set id. */
+interface CriteriaAxes {
+    render: RenderShape;
+    state: StateShape;
+    writes: WriteShape;
+    fetch: FetchShape;
+    layout: LayoutShape;
+}
+/** The selector's inputs, stored with the verdict so a reader recomputes `criteriaSetId` from the record alone. */
+interface CriteriaContext {
+    canvas: CanvasClass;
+    hasActions: boolean;
+    riskTier: RiskTier;
+    axes: CriteriaAxes;
+    chroma: CriteriaChroma;
+    profilePresent: boolean;
+    /** The harness's shell as named; `unknown` when the round carries none. */
+    shell: string;
+    /** The caller's item kind (a bootstrap mint's `hello`); hashed when present. */
+    kind?: string;
+    /** The styling preset in force (the profile's aesthetic id); a recipe is selected only under its preset. */
+    preset?: string;
+}
+/** What was asked and why — recorded BEFORE the judge runs. Omission is the selector's decision. */
+interface CriteriaSelection {
+    id: string;
+    source: CriteriaSource;
+    reason: string;
+}
+/** One criterion's verdict; `n/a` is the judge's answer ("cannot read this off the frame"), an unanswered id, a tie, or a method whose `status` is not live. */
+interface CriterionVerdict {
+    id: string;
+    severity: CriteriaSeverity;
+    method: CriteriaMethod;
+    status: CriteriaStatus;
+    source: CriteriaSource;
+    verdict: CriteriaVerdict;
+    evidence: string;
+}
+interface CriteriaBlock {
+    /** sha256(bank version | selector version | canonical context), 16 hex — the block's own digest. */
+    criteriaSetId: string;
+    bankVersion: string;
+    selectorVersion: string;
+    context: CriteriaContext;
+    selection: CriteriaSelection[];
+    verdicts: CriterionVerdict[];
+}
+/** The roll-up across canvases; a `must` at `n/a` is listed, never counted as a pass. */
+interface CriteriaRollup {
+    mustFailed: string[];
+    shouldFailed: string[];
+    mustNa: string[];
+}
+/** ggui#1492 — a host"s frame round the inline card, as data. Colours are `#rrggbb`; the ring"s `alpha` is 0..1. */
+interface HostInlineFrame {
+    /** The frame"s surface — what shows behind a transparent card, and under the floor"s residual. */
+    readonly surface: string;
+    /** The room the frame sits in (the page ground round it). */
+    readonly ground: string;
+    readonly ring: {
+        readonly widthPx: number;
+        readonly color: string;
+        readonly alpha: number;
+    };
+    readonly radiusPx: number;
+    /** The host"s minimum frame height: a card shorter than it sits in a frame this tall, and the visitor sees the rest as void. */
+    readonly minHeightPx?: number;
+}
+/** ggui#1492 — how a host presents one canvas: the label the judge is told, the page ground, and (the inline card only) its frame. */
+interface CanvasHostPresentation {
+    readonly label: string;
+    /** The page ground under a fill canvas"s panel; the inline card"s ground lives on its {@link HostInlineFrame}. */
+    readonly ground?: string;
+    readonly frame?: HostInlineFrame;
+}
+/** ggui#1492 — why the judge did not draw a canvas's host presentation. The codes are the lane reader's own. */
+type HostPresentationIgnoredReason = "label_missing" | "color_not_hex" | "frame_off_inline" | "frame_malformed" | "ground_on_inline";
+/**
+ * ggui#1492 — what the judge DID with a canvas's host presentation, read from the judge itself: `applied` carries
+ * the presentation it drew, `ignored` the reason it drew none. Absent when the caller supplied no presentation.
+ */
+type CanvasPresentationOutcome = {
+    readonly status: "applied";
+    readonly applied: CanvasHostPresentation;
+} | {
+    readonly status: "ignored";
+    readonly reason: HostPresentationIgnoredReason;
+};
 interface CanvasVisualSummary {
     canvas: CanvasClass;
     viewport: {
@@ -226,8 +398,19 @@ interface CanvasVisualSummary {
     contentHeight: number | null;
     /** `contentHeight > viewport.height` — measured on every canvas, judged per `canvasFitPolicy`. */
     overflow: boolean;
+    /**
+     * ggui#1120 — how far down the capture anything was painted: the last inked row over the measured
+     * region's height (inside a drawn host panel's chrome on md/lg/xl), read from the screenshot's
+     * pixels against their dominant colour. `0` is the blank the judge fails (`canvas-blank`); every
+     * other value is reported, never scored. `null` when the capture could not be read.
+     */
+    inkRatio: number | null;
     /** How `score` was reached — always present (ggui#1072). */
     judge: CanvasJudgeRecord;
+    /** ggui#1436 — the typed criteria block, when a bank was configured; report-only. */
+    criteria?: CriteriaBlock;
+    /** ggui#1492 — what the judge did with this canvas's host presentation, when one was supplied. */
+    presentation?: CanvasPresentationOutcome;
     /**
      * How the judge composed the mount (ggui#1100): `'fill'` on every
      * fullscreen canvas — the served runtime's fit, the root stretched to
@@ -268,6 +451,8 @@ interface VisualEvalSummary {
     };
     /** The mode the judge's tokens were composed in, when the caller said (ggui#1076). */
     themeMode?: 'light' | 'dark';
+    /** ggui#1436 — the criteria roll-up across canvases, when any canvas carries a block; report-only. */
+    criteria?: CriteriaRollup;
 }
 type QualityMode = "fast" | "auto-improve" | "high-quality";
 interface QualityConfig {
@@ -304,6 +489,14 @@ interface AxisCheckInput {
      * default (a silent `lg` would be the same guess with a nicer face).
      */
     canvas?: CanvasClass;
+    /**
+     * The props the probe and the judge RENDERED the source with (ggui#1285) — a bootstrap order's
+     * `sampleProps`, the bench commit's fixture. They are judging data, not the request: a literal in
+     * the source that equals one of these values, and that the request never stated, is baked copy a
+     * visitor sees whenever the agent leaves the prop out. Populated on the served loop and at
+     * auto-commit; ABSENT where the caller has none — the check stands down, it never guesses.
+     */
+    fixtureProps?: JsonObject;
 }
 /**
  * A gated check. Runs only when the classification's axis value matches
@@ -382,4 +575,4 @@ declare function getLLMCriteria(designMode?: DesignMode): EvalCriterion[];
  */
 declare function buildCodingCriteriaSummary(designMode?: DesignMode): string;
 
-export { type AxisCheck as A, type CanvasJudgeRecord as C, DEFAULT_QUALITY_CONFIG as D, type EvalIssue as E, LLM_EVAL_STATIC_CRITERIA as L, type ProbeHostLoad as P, type QualityConfig as Q, type RuntimeProbeStatus as R, type VisualEvalSummary as V, type AxisCheckInput as a, type EvalResult as b, type EvalTier as c, type VisualCoverage as d, CRITERIA as e, type CanvasVisualSummary as f, type ContractFeedbackRecord as g, type CriterionCoverage as h, type CriterionRunStatus as i, type EvalCategory as j, type EvalCriterion as k, type EvalOutcome as l, matches as m, type Priority as n, type QualityMode as o, buildCodingCriteriaSummary as p, criteriaFor as q, getActionableIssues as r, getCriteriaByPriority as s, getCriterionById as t, getLLMCriteria as u, isBlocked as v, notApplicableCoverage as w, priorityForIssue as x };
+export { type AxisCheck as A, getCriterionById as B, type CriteriaContext as C, DEFAULT_QUALITY_CONFIG as D, type EvalIssue as E, getLLMCriteria as F, isBlocked as G, type HostInlineFrame as H, notApplicableCoverage as I, priorityForIssue as J, LLM_EVAL_STATIC_CRITERIA as L, type ProbeHostLoad as P, type QualityConfig as Q, type RuntimeProbeStatus as R, type VisualEvalSummary as V, type AxisCheckInput as a, type EvalResult as b, type EvalTier as c, type CriteriaChroma as d, type CanvasJudgeRecord as e, type CriteriaBlock as f, type CanvasPresentationOutcome as g, type CanvasHostPresentation as h, type VisualCoverage as i, type CriteriaSelection as j, CRITERIA as k, type CanvasVisualSummary as l, matches as m, type ContractFeedbackRecord as n, type CriterionCoverage as o, type CriterionRunStatus as p, type EvalCategory as q, type EvalCriterion as r, type EvalOutcome as s, type HostPresentationIgnoredReason as t, type Priority as u, type QualityMode as v, buildCodingCriteriaSummary as w, criteriaFor as x, getActionableIssues as y, getCriteriaByPriority as z };