@ggui-ai/ui-gen 0.22.0 → 0.24.0

package/dist/{types-public-mM_-1Yk3.d.ts → types-public-Bk6d1WLN.d.ts}

@@ -1,3 +1,4 @@
+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';
@@ -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.
@@ -38,19 +41,98 @@ interface EvalIssue {
  *                       consumers MUST NOT count it as a pass.
  *   - `not-applicable`— nothing to probe (no compiled code, no contract
  *                       surface, or no runtimeRender check configured).
+ *   - `timed-out`     — probe started but did not finish inside its
+ *                       wall-clock bound (ggui#1299). Carries ZERO
+ *                       evidence about the component: on a contended
+ *                       host an ordinary component crosses the bound.
+ *                       Consumers MUST NOT count it as a pass, and MUST
+ *                       NOT count it as a crash either. `elapsedMs` and
+ *                       `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";
+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
+ * `cores` means the probe competed for CPU; a wall-clock bound crossed
+ * there says more about the host than about the component.
+ */
+interface ProbeHostLoad {
+    readonly start: number;
+    readonly end: number;
+    readonly cores: number;
+}
+/**
+ * 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 RuntimeProbeMetaDetail {
+    /** Populated for `infra-skipped` / `not-applicable` / `timed-out` — why the probe didn't finish. */
+    readonly reason?: string;
+    /** `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: a `fail` verdict whose
+ * checks are `prop-sensitivity`, `action-wiring` or any other kind is
+ * recorded here and never fed back.
  */
-interface RuntimeProbeMeta {
-    readonly status: RuntimeProbeStatus;
-    /** Populated for `infra-skipped` / `not-applicable` — why the probe didn't run. */
-    readonly reason?: string;
-}
+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
@@ -146,6 +228,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
@@ -359,4 +448,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 Priority 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 QualityMode as n, buildCodingCriteriaSummary as o, criteriaFor as p, getActionableIssues as q, getCriteriaByPriority as r, getCriterionById as s, getLLMCriteria as t, isBlocked as u, notApplicableCoverage as v, priorityForIssue as w };
+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 };