@ggui-ai/ui-gen 0.24.0 → 0.26.0

package/dist/types-public-Bk6d1WLN.d.ts

@@ -1,451 +0,0 @@
-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';
-
-type Priority = "P0" | "P1" | "P2";
-
-type EvalTier = 0 | 1 | 2;
-type EvalOutcome = "fail" | "warn" | "pass";
-type EvalCategory = "compile" | "security" | "contract" | "types" | "imports" | "tokens" | "mode" | "functionality" | "crash" | "interactivity" | "accessibility" | "layout" | "loading" | "visual";
-interface EvalIssue {
-    tier: EvalTier;
-    result: EvalOutcome;
-    category: EvalCategory;
-    /**
-     * Priority tier — threaded through to the retry formatter so the LLM can
-     * rank its next patch against the prompt's P0/P1/P2 priority schema.
-     * Derived from (category, result) via {@link priorityForIssue} when not
-     * explicitly set. Optional on construction; check-runners typically
-     * populate it before returning.
-     */
-    priority?: Priority;
-    subcategory?: string;
-    severity?: "critical" | "major";
-    description: string;
-    fix: string;
-    line?: number;
-}
-/**
- * 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.
- *   - `infra-skipped` — probe could NOT execute (environment failure:
- *                       happy-dom load, user-event document capture,
- *                       ESM/CJS interop). Carries ZERO probe evidence;
- *                       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 = 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.
- */
-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
- * ran clean", and neither is conflated with "not evaluated by design".
- * Same doctrine and vocabulary family as `RuntimeProbeStatus` above.
- *
- *   - `ran`            — the LLM call completed and returned a verdict
- *                        for this criterion; its findings (possibly
- *                        none) are in `issues`.
- *   - `skipped`        — the call errored or returned no tool call. The
- *                        criterion carries ZERO evidence; the evaluator
- *                        fail-opens it into `pass` to avoid blocking
- *                        generation on flaky LLM calls, so consumers
- *                        MUST consult this field before treating `pass`
- *                        membership as a verdict. Counts AGAINST
- *                        coverage.
- *   - `not-applicable` — the evaluator was bypassed by design for this
- *                        cell (e.g. the same-image low-risk bypass:
- *                        axis checks clean, tier-1/2 never invoked).
- *                        `reason` names the bypass. Excluded from
- *                        coverage denominators — it is neither evidence
- *                        nor a silent absence.
- */
-type CriterionRunStatus = "ran" | "skipped" | "not-applicable";
-/** Coverage row for one evaluation criterion of one eval run. */
-interface CriterionCoverage {
-    readonly criterion: string;
-    readonly tier: 1 | 2;
-    readonly status: CriterionRunStatus;
-    /** Populated for `skipped` / `not-applicable` — why no verdict. */
-    readonly reason?: string;
-}
-/**
- * Coverage of the screenshot JUDGE leg for one eval round (ggui#1221) — a
- * different surface from the `visual` CRITERION in `criteriaCoverage` (the
- * LLM evaluator's read of the source). `ran` = a frame was captured and
- * judged; `skipped` = the leg was configured but produced no verdict
- * (no browser, a launch or in-page failure, an unbundlable component, an
- * unparsable judge answer) with `reason` naming why; `not-applicable` =
- * the round had no visual leg configured. Before this row a skipped leg
- * left NO trace on the result — `{ issues: [] }` read exactly like a
- * clean run, and every bootstrap mint on a browserless runtime "passed"
- * its visual round that way.
- */
-interface VisualCoverage {
-    readonly status: CriterionRunStatus;
-    /** Populated for `skipped` / `not-applicable` — why no verdict. */
-    readonly reason?: string;
-}
-/**
- * The static criteria `runLLMEvaluation` runs, in stamp order — the
- * ONE list both the evaluator's coverage stamp and the harness's
- * bypass stamp derive from, so the two can never disagree on the set.
- * Tier 1 = binary pass/fail gates; tier 2 = fail/warn/pass quality.
- */
-declare const LLM_EVAL_STATIC_CRITERIA: ReadonlyArray<{
-    readonly criterion: string;
-    readonly tier: 1 | 2;
-}>;
-/**
- * Coverage rows for a cell where the evaluator was BYPASSED BY DESIGN
- * (never invoked) — one `not-applicable` row per static criterion, all
- * carrying `reason`. Harness exits that skip tier-1/2 evaluation stamp
- * this so the cell is neither a silent absence (field missing) nor
- * evidence. Same shape contract as `runLLMEvaluation`'s stamp: always
- * every criterion. Lives here (not in llm-evaluator) because the bypass
- * exit runs before the evaluator module is lazily loaded.
- */
-declare function notApplicableCoverage(reason: string): CriterionCoverage[];
-/** One contract-feedback round (ggui#1261): what bought it, and the source it was fed back on. */
-interface ContractFeedbackRecord {
-    /** The exit-probe issue subcategories that bought the round, e.g. `runtime:prop-sensitivity:currentUser`. */
-    readonly firedOn: readonly string[];
-    /** The component source as it stood when the model was told — the round's BEFORE. */
-    readonly sourceBefore: string;
-}
-interface EvalResult {
-    issues: EvalIssue[];
-    pass: string[];
-    /**
-     * Per-criterion coverage for this eval run — one row per static
-     * criterion, ALWAYS all of them when present. Stamped by
-     * `runLLMEvaluation` (`ran` / `skipped`) and by the harness on
-     * evaluator-bypass exits (`not-applicable` + reason). The harness
-     * carries it unchanged through every later re-stamp of this result.
-     * Absent = coverage UNKNOWN (paths that predate the instrument, e.g.
-     * `parseEvalResponse` replays) — never assume `ran`, never assume
-     * bypass.
-     */
-    criteriaCoverage?: CriterionCoverage[];
-    /**
-     * Runtime-render probe execution meta. Stamped by the exit-decision
-     * 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
-     * model was told. `runtimeProbe` and the `runtime:*` issues on this result
-     * are the probe's verdict AFTER that round; `sourceBefore` beside the final
-     * source is the round's before/after. Absent when no such round fired.
-     */
-    contractFeedback?: ContractFeedbackRecord;
-    /**
-     * Per-canvas visual verdicts. Stamped by the harness ONLY when the
-     * visual leg ran with `visualEvaluation.canvases` set (arm-neutral —
-     * the same judge in every design mode); absent on the single-shot
-     * visual path and whenever the visual leg did not run. PNGs stay on
-     * `runVisualEvaluation`'s own result (`VisualEvaluationResult.canvases[*].screenshotPng`),
-     * never here — this object is serialized into reports.
-     */
-    visual?: VisualEvalSummary;
-    /**
-     * Whether the screenshot judge leg ran, was skipped (with the reason) or
-     * was not configured — ALWAYS stamped by the harness's eval round
-     * (ggui#1221), so a consumer can tell a clean visual run from a leg
-     * that silently could not run. See {@link VisualCoverage}.
-     */
-    visualCoverage?: VisualCoverage;
-}
-/** One canvas's visual verdict, PNG-free — see `EvalResult.visual`. */
-/**
- * How one canvas's `score` was reached (ggui#1072): `k` vision calls on the
- * SAME captured frame, aggregated by `rule`. Always present — `k: 1` ⇒
- * `samples: [score]`, `sigma: 0`, `notes: [critique]` — so one shape serves
- * a single judgement and a median of many. `samples`/`notes` carry only the
- * calls the judge could parse (in call order); `k` stays the requested count,
- * so a short `samples` is visible on the row rather than filled in.
- */
-interface CanvasJudgeRecord {
-    readonly k: number;
-    readonly rule: 'median';
-    readonly samples: number[];
-    /** Population σ of `samples` (0 when one sample). */
-    readonly sigma: number;
-    /** The judge's per-canvas critique per sample — the words beside a swing. */
-    readonly notes: string[];
-}
-interface CanvasVisualSummary {
-    canvas: CanvasClass;
-    viewport: {
-        width: number;
-        height: number;
-    };
-    /** The judge's weighted score at this canvas (0-100). */
-    score: number;
-    /** `score >= passThreshold`, and on the inline card: no overflow (ggui#1027). */
-    passed: boolean;
-    /** The document's scroll height at this canvas, CSS px; `null` when unmeasurable (ggui#1027). */
-    contentHeight: number | null;
-    /** `contentHeight > viewport.height` — measured on every canvas, judged per `canvasFitPolicy`. */
-    overflow: boolean;
-    /** How `score` was reached — always present (ggui#1072). */
-    judge: CanvasJudgeRecord;
-    /**
-     * How the judge composed the mount (ggui#1100): `'fill'` on every
-     * fullscreen canvas — the served runtime's fit, the root stretched to
-     * the frame; absent on the inline card, which keeps its natural height.
-     */
-    fit?: 'fill';
-}
-/**
- * ggui#1195 — the fit reading on the canvas whose policy FAILS an overflow
- * (the inline chat card): the box it was judged at (`ceiling` — the order's
- * declared viewport when one was carried, else the class box), whether that
- * box was declared, and how many px of content sit below it (0 = fits).
- * Present only when such a canvas was judged with a measurable height, so
- * the bar and the ledger read one number for "does the hello fit".
- */
-interface VisualFitStamp {
-    readonly canvas: CanvasClass;
-    readonly ceiling: {
-        readonly width: number;
-        readonly height: number;
-    };
-    readonly declared: boolean;
-    readonly overflowPx: number;
-}
-/** The visual leg's per-canvas summary — see `EvalResult.visual`. */
-interface VisualEvalSummary {
-    /** Mean of the canvas scores (rounded). */
-    score: number;
-    /** Every canvas passed. */
-    passed: boolean;
-    canvases: CanvasVisualSummary[];
-    /** ggui#1195 — see {@link VisualFitStamp}; absent when no fail-policy canvas was judged. */
-    fit?: VisualFitStamp;
-    /** The design tree the judge painted with (ggui#1042): `src` + `srcSha256` — `design@judge`. */
-    design?: {
-        readonly src: string;
-        readonly srcSha256: string;
-    };
-    /** The mode the judge's tokens were composed in, when the caller said (ggui#1076). */
-    themeMode?: 'light' | 'dark';
-}
-type QualityMode = "fast" | "auto-improve" | "high-quality";
-interface QualityConfig {
-    quality: QualityMode;
-    visualEval: boolean;
-    maxCostPerGeneration: number;
-    model?: {
-        provider?: string;
-        model?: string;
-    };
-}
-declare const DEFAULT_QUALITY_CONFIG: QualityConfig;
-
-interface AxisCheckInput {
-    sourceCode: string;
-    compiledCode: string | null;
-    contract?: DataContract;
-    originalPrompt: string;
-    /** Full classification — checks may read sibling axes. */
-    classification: Classification;
-    /**
-     * Which triad produced the source. Checks that assert a design-package
-     * component (e.g. `layout.multi_step.stepper_adopted`) read it and
-     * stand down in `free` mode, where the primitive is optional. Absent
-     * means `constrained`.
-     */
-    designMode?: DesignMode;
-    /**
-     * The rendering canvas the source is judged FOR (ggui#1117). A width cap on
-     * the outermost element is a defect on a fullscreen canvas and a no-op in a
-     * chat bubble, so a check that reads width must know the surface. Populated
-     * where the harness is built (`Harness.canvas`); ABSENT for callers with no
-     * rendering context — a check handles `undefined`, it never assumes a
-     * default (a silent `lg` would be the same guess with a nicer face).
-     */
-    canvas?: CanvasClass;
-}
-/**
- * A gated check. Runs only when the classification's axis value matches
- * one of the gate's accepted values. Multiple gates (implicit AND) support
- * cross-axis combinations.
- */
-interface AxisCheck {
-    /** Stable id used in issue subcategories. */
-    id: string;
-    /** Primary axis this check gates on. */
-    axis: AxisKey;
-    /** Which values of that axis activate the check. */
-    values: readonly string[];
-    /** Optional extra gate on a sibling axis (e.g., only when state=merge AND writes=per-item). */
-    and?: {
-        axis: AxisKey;
-        values: readonly string[];
-    };
-    /** Execute the check and emit zero or more issues. */
-    run(input: AxisCheckInput): EvalIssue[];
-}
-/**
- * Whether a check's gate(s) match the given axis vector. Pure function,
- * no issue emission.
- */
-declare function matches(vector: AxisVector, check: AxisCheck): boolean;
-/**
- * Map a tier-0 issue category to the canonical P0/P1/P2 priority.
- *
- * Sourced from the criteria priority assignments:
- *   - P0 (must): compile, security, imports, contract, types, mode
- *   - P1 (safety): tokens, crash, functionality
- *   - P2 (quality): interactivity, accessibility, layout, loading, visual
- */
-declare function priorityForIssue(category: EvalCategory): Priority;
-/** Whether any issue blocks shipping (has result = 'fail'). */
-declare function isBlocked(result: EvalResult): boolean;
-/**
- * Return the issues the agent should act on, depending on quality mode.
- * - fast: only fails (blocking issues)
- * - auto-improve / high-quality: fails + warns
- */
-declare function getActionableIssues(result: EvalResult, mode: QualityMode): EvalIssue[];
-interface EvalCriterion {
-    /** Unique identifier matching the eval tool name (e.g., 'functionality') */
-    id: string;
-    /** Human-readable name shown to both agents */
-    name: string;
-    /** Priority tier — P0 must, P1 should, P2 nice */
-    priority: Priority;
-    /** What the coding agent should DO to satisfy this criterion */
-    codingGuidance: string;
-    /** What the eval agent should CHECK — the evaluation prompt */
-    evalInstruction: string;
-    /** Tier 0 = programmatic, Tier 1 = LLM critical, Tier 2 = LLM quality */
-    tier: 0 | 1 | 2;
-    /** Eval outcome when this criterion fails */
-    failOutcome: "fail" | "warn";
-}
-declare const CRITERIA: readonly EvalCriterion[];
-/**
- * The criteria registry for a design mode. `constrained` IS `CRITERIA`
- * (same array, byte-identical summary); `free` swaps in the two
- * overrides above by id, preserving order.
- */
-declare function criteriaFor(designMode?: DesignMode): readonly EvalCriterion[];
-/** Get all criteria for a specific priority level */
-declare function getCriteriaByPriority(priority: Priority, designMode?: DesignMode): EvalCriterion[];
-/** Get a specific criterion by ID */
-declare function getCriterionById(id: string, designMode?: DesignMode): EvalCriterion | undefined;
-/** Get all LLM-evaluated criteria (tier 1 + 2) */
-declare function getLLMCriteria(designMode?: DesignMode): EvalCriterion[];
-/**
- * Build the coding agent's criteria summary from the single source of truth.
- * Grouped by priority for the P0→P1→P2 hierarchy.
- */
-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 };