@vitest-agent/ui 1.0.0

package/index.d.ts

@@ -0,0 +1,1843 @@
+import { Context, Effect, Layer, PubSub, Queue, Schema, Scope, Stream } from "effect";
+import { FC, ReactElement } from "react";
+
+//#region ../sdk/dist/dev/pkg/DataReader-2kJ9I9Hh.d.ts
+//#region src/schemas/Coverage.d.ts
+/**
+ * Aggregate coverage percentages across four istanbul metrics.
+ * @public
+ */
+declare const CoverageTotals: Schema.Struct<{
+  statements: typeof Schema.Number;
+  branches: typeof Schema.Number;
+  functions: typeof Schema.Number;
+  lines: typeof Schema.Number;
+}>;
+/** @public */
+type CoverageTotals = typeof CoverageTotals.Type;
+/**
+ * Per-file coverage data including uncovered line ranges.
+ * @public
+ */
+declare const FileCoverageReport: Schema.Struct<{
+  file: typeof Schema.String;
+  summary: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  uncoveredLines: typeof Schema.String;
+}>;
+/** @public */
+type FileCoverageReport = typeof FileCoverageReport.Type;
+/**
+ * Complete coverage report attached to an AgentReport.
+ * @public
+ */
+/**
+ * Complete per-project test report written to disk as JSON.
+ * @public
+ */
+declare const AgentReport: Schema.Struct<{
+  timestamp: typeof Schema.String;
+  project: Schema.optional<typeof Schema.String>;
+  reason: Schema.Literal<["passed", "failed", "interrupted"]>;
+  summary: Schema.Struct<{
+    total: typeof Schema.Number;
+    passed: typeof Schema.Number;
+    failed: typeof Schema.Number;
+    skipped: typeof Schema.Number;
+    duration: typeof Schema.Number;
+  }>;
+  failed: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+    duration: Schema.optional<typeof Schema.Number>;
+    errors: Schema.optional<Schema.Array$<Schema.Struct<{
+      message: typeof Schema.String;
+      stack: Schema.optional<typeof Schema.String>;
+      diff: Schema.optional<typeof Schema.String>;
+      expected: Schema.optional<typeof Schema.String>;
+      received: Schema.optional<typeof Schema.String>;
+    }>>>;
+    tests: Schema.Array$<Schema.Struct<{
+      name: typeof Schema.String;
+      fullName: typeof Schema.String;
+      state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+      duration: Schema.optional<typeof Schema.Number>;
+      flaky: Schema.optional<typeof Schema.Boolean>;
+      slow: Schema.optional<typeof Schema.Boolean>;
+      errors: Schema.optional<Schema.Array$<Schema.Struct<{
+        message: typeof Schema.String;
+        stack: Schema.optional<typeof Schema.String>;
+        diff: Schema.optional<typeof Schema.String>;
+        expected: Schema.optional<typeof Schema.String>;
+        received: Schema.optional<typeof Schema.String>;
+      }>>>;
+      classification: Schema.optional<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+    }>>;
+  }>>;
+  unhandledErrors: Schema.Array$<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+  failedFiles: Schema.Array$<typeof Schema.String>;
+  coverage: Schema.optional<Schema.Struct<{
+    totals: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    thresholds: Schema.Struct<{
+      global: Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>;
+      patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>>>, {
+        default: () => never[];
+      }>;
+    }>;
+    targets: Schema.optional<Schema.Struct<{
+      global: Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>;
+      patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>>>, {
+        default: () => never[];
+      }>;
+    }>>;
+    baselines: Schema.optional<Schema.Struct<{
+      global: Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>;
+      patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>>>, {
+        default: () => never[];
+      }>;
+    }>>;
+    scoped: Schema.optionalWith<typeof Schema.Boolean, {
+      default: () => false;
+    }>;
+    scopedFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    lowCoverage: Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      summary: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: typeof Schema.String;
+    }>>;
+    lowCoverageFiles: Schema.Array$<typeof Schema.String>;
+    belowTarget: Schema.optional<Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      summary: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: typeof Schema.String;
+    }>>>;
+    belowTargetFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+  }>>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    passed: Schema.optional<typeof Schema.Number>;
+    failed: Schema.optional<typeof Schema.Number>;
+    skipped: Schema.optional<typeof Schema.Number>;
+  }>>>;
+}>;
+/** @public */
+type AgentReport = typeof AgentReport.Type; //#endregion
+//#region src/schemas/Identity.d.ts
+/**
+ * Canonical UUID for an LLM agent invocation. Generated server-side at
+ * `register_agent` time. Stable across transport reconnects within an
+ * agent's lifetime.
+ * @public
+ */
+//#endregion
+//#region ../sdk/dist/dev/pkg/index.d.ts
+//#region src/schemas/RenderState.d.ts
+/**
+ * Per-test record accumulated as `TestStarted` / `TestFinished` events arrive.
+ * @public
+ */
+declare const TestRecord: Schema.Struct<{
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
+  durationMs: Schema.NullOr<typeof Schema.Number>;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+}>;
+/** @public */
+type TestRecord = typeof TestRecord.Type;
+/**
+ * Per-module aggregation. The reducer keeps modules keyed on
+ * `modulePath` so out-of-order events can update the right slot.
+ * @public
+ */
+declare const ModuleRecord: Schema.Struct<{
+  modulePath: typeof Schema.String;
+  status: Schema.Literal<["queued", "running", "finished"]>;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  timeoutCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  tests: Schema.Array$<Schema.Struct<{
+    testName: typeof Schema.String;
+    suitePath: Schema.Array$<typeof Schema.String>;
+    status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
+    durationMs: Schema.NullOr<typeof Schema.Number>;
+    error: Schema.optional<Schema.Struct<{
+      message: typeof Schema.String;
+      stack: Schema.optional<typeof Schema.String>;
+      diff: Schema.optional<typeof Schema.String>;
+      expected: Schema.optional<typeof Schema.String>;
+      received: Schema.optional<typeof Schema.String>;
+    }>>;
+  }>>;
+  /**
+   * Owning Vitest project name. Optional — events from project-less
+   * configs or older replays leave it `undefined`, which the renderer
+   * treats as a single anonymous project.
+   */
+  projectName: Schema.optional<typeof Schema.String>;
+  /**
+   * ISO wall-clock stamp captured at `onTestModuleStart`. The live
+   * renderer derives a ticking elapsed column from it while the module
+   * runs; once finished it shows `durationMs` instead. Optional — a
+   * module seeded by `ModuleQueued` (or replayed) has no start stamp.
+   */
+  startedAt: Schema.optional<typeof Schema.String>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+}>;
+/** @public */
+type ModuleRecord = typeof ModuleRecord.Type;
+/**
+ * One row in the failure list. A failure can exist before its
+ * classification arrives (`FailureClassified` is emitted from a
+ * separate pipeline), so `classification` is nullable.
+ * @public
+ */
+declare const FailureRecord: Schema.Struct<{
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+  timedOut: Schema.optional<typeof Schema.Boolean>;
+  classification: Schema.NullOr<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+}>;
+/** @public */
+type FailureRecord = typeof FailureRecord.Type;
+/**
+ * Coverage block, populated only after `CoverageReady`. Threshold
+ * violations are accumulated separately as they arrive.
+ * @public
+ */
+declare const CoverageRenderState: Schema.Struct<{
+  metrics: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  thresholds: Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>;
+  gaps: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    missing: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    uncoveredLines: Schema.optional<typeof Schema.String>;
+  }>>;
+  violations: Schema.Array$<Schema.Struct<{
+    metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+    expected: typeof Schema.Number;
+    actual: typeof Schema.Number;
+  }>>;
+}>;
+/** @public */
+type CoverageRenderState = typeof CoverageRenderState.Type;
+/**
+ * A `SuggestedAction` event, denormalized into the queue the renderer reads.
+ * @public
+ */
+declare const SuggestedActionRecord: Schema.Struct<{
+  severity: Schema.Literal<["info", "warn", "blocker"]>;
+  title: typeof Schema.String;
+  detail: typeof Schema.String;
+  targetTool: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type SuggestedActionRecord = typeof SuggestedActionRecord.Type;
+/**
+ * Per-run totals, recomputed on every `ModuleFinished` and reconciled
+ * against `RunFinished` (which carries the runner's own count).
+ * @public
+ */
+declare const RenderTotals: Schema.Struct<{
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  timeoutCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+}>;
+/** @public */
+type RenderTotals = typeof RenderTotals.Type;
+/**
+ * The renderer state. Both the human (Ink) and agent (string)
+ * renderers read this shape; the reducer is the only producer.
+ *
+ * `phase` is the layout discriminator — agent mode emits one final
+ * frame when `phase === "finished"`; human mode redraws at every
+ * state change. `"timed-out"` is a terminal phase like `"finished"`
+ * — the run is over, but it ended because `onProcessTimeout` fired
+ * rather than the suite completing.
+ * @public
+ */
+declare const RenderState: Schema.Struct<{
+  phase: Schema.Literal<["idle", "running", "finished", "timed-out"]>;
+  runId: Schema.NullOr<typeof Schema.String>;
+  configHash: Schema.NullOr<typeof Schema.String>;
+  startedAt: Schema.NullOr<typeof Schema.String>;
+  finishedAt: Schema.NullOr<typeof Schema.String>;
+  modules: Schema.Record$<typeof Schema.String, Schema.Struct<{
+    modulePath: typeof Schema.String;
+    status: Schema.Literal<["queued", "running", "finished"]>;
+    passCount: typeof Schema.Number;
+    failCount: typeof Schema.Number;
+    skipCount: typeof Schema.Number;
+    timeoutCount: typeof Schema.Number;
+    durationMs: typeof Schema.Number;
+    tests: Schema.Array$<Schema.Struct<{
+      testName: typeof Schema.String;
+      suitePath: Schema.Array$<typeof Schema.String>;
+      status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
+      durationMs: Schema.NullOr<typeof Schema.Number>;
+      error: Schema.optional<Schema.Struct<{
+        message: typeof Schema.String;
+        stack: Schema.optional<typeof Schema.String>;
+        diff: Schema.optional<typeof Schema.String>;
+        expected: Schema.optional<typeof Schema.String>;
+        received: Schema.optional<typeof Schema.String>;
+      }>>;
+    }>>;
+    /**
+     * Owning Vitest project name. Optional — events from project-less
+     * configs or older replays leave it `undefined`, which the renderer
+     * treats as a single anonymous project.
+     */
+    projectName: Schema.optional<typeof Schema.String>;
+    /**
+     * ISO wall-clock stamp captured at `onTestModuleStart`. The live
+     * renderer derives a ticking elapsed column from it while the module
+     * runs; once finished it shows `durationMs` instead. Optional — a
+     * module seeded by `ModuleQueued` (or replayed) has no start stamp.
+     */
+    startedAt: Schema.optional<typeof Schema.String>;
+    tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+  }>>;
+  moduleOrder: Schema.Array$<typeof Schema.String>;
+  totals: Schema.Struct<{
+    passCount: typeof Schema.Number;
+    failCount: typeof Schema.Number;
+    skipCount: typeof Schema.Number;
+    timeoutCount: typeof Schema.Number;
+    durationMs: typeof Schema.Number;
+  }>;
+  coverage: Schema.NullOr<Schema.Struct<{
+    metrics: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    thresholds: Schema.Struct<{
+      lines: Schema.optional<typeof Schema.Number>;
+      functions: Schema.optional<typeof Schema.Number>;
+      branches: Schema.optional<typeof Schema.Number>;
+      statements: Schema.optional<typeof Schema.Number>;
+    }>;
+    gaps: Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      missing: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: Schema.optional<typeof Schema.String>;
+    }>>;
+    violations: Schema.Array$<Schema.Struct<{
+      metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+      expected: typeof Schema.Number;
+      actual: typeof Schema.Number;
+    }>>;
+  }>>;
+  trend: Schema.NullOr<Schema.Struct<{
+    direction: Schema.Literal<["improving", "regressing", "stable"]>;
+    runCount: typeof Schema.Number;
+  }>>;
+  failures: Schema.Array$<Schema.Struct<{
+    modulePath: typeof Schema.String;
+    testName: typeof Schema.String;
+    suitePath: Schema.Array$<typeof Schema.String>;
+    error: Schema.optional<Schema.Struct<{
+      message: typeof Schema.String;
+      stack: Schema.optional<typeof Schema.String>;
+      diff: Schema.optional<typeof Schema.String>;
+      expected: Schema.optional<typeof Schema.String>;
+      received: Schema.optional<typeof Schema.String>;
+    }>>;
+    timedOut: Schema.optional<typeof Schema.Boolean>;
+    classification: Schema.NullOr<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+  }>>;
+  suggestedActions: Schema.Array$<Schema.Struct<{
+    severity: Schema.Literal<["info", "warn", "blocker"]>;
+    title: typeof Schema.String;
+    detail: typeof Schema.String;
+    targetTool: Schema.optional<typeof Schema.String>;
+  }>>;
+}>;
+/** @public */
+type RenderState = typeof RenderState.Type;
+/**
+ * Initial state — what the reducer returns when no events have been
+ * applied yet. Exported so tests and the renderers' bootstrapping
+ * code share one definition.
+ * @public
+ */
+declare const initialRenderState: RenderState; //#endregion
+//#region src/contracts/dispatcher.d.ts
+/**
+ * The four run shapes the dispatcher distinguishes.
+ *
+ * Computed once per run from the reduced state's module count, the
+ * distinct-project count (carried via {@link DispatchInputs.projects}),
+ * and the test count inside each module.
+ *
+ * - `single-test`    — exactly one test by name across the run.
+ * - `single-file`    — exactly one module, more than one test.
+ * - `single-project` — one project, more than one module.
+ * - `workspace`      — more than one project.
+ * @public
+ */
+type RunShape = "single-test" | "single-file" | "single-project" | "workspace";
+/**
+ * The three outcome classes the dispatcher distinguishes.
+ *
+ * - `all-pass`             — `totals.failed === 0` and no coverage threshold violations.
+ * - `some-fail`            — `totals.failed > 0`.
+ * - `threshold-violation`  — `totals.failed === 0` and at least one coverage violation.
+ * @public
+ */
+type RunOutcome = "all-pass" | "some-fail" | "threshold-violation";
+/**
+ * Compact per-project aggregate carried into workspace cells.
+ *
+ * Populated by the plugin from `ReporterRenderInput.reports`. Empty for
+ * non-workspace shapes. `tagCounts`, `belowTarget`, and `violations` are
+ * optional — workspace cells render the columns only when present.
+ * @public
+ */
+interface ProjectSummary {
+  readonly name: string;
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly skipCount: number;
+  readonly durationMs: number;
+  readonly tagCounts?: Record<string, number>;
+  readonly belowTarget?: number;
+  readonly violations?: number;
+}
+/**
+ * Per-run trend direction handed to cells that surface a `Trend: …` line.
+ *
+ * Mirrors the inline `ReporterRenderInput.trendSummary` shape — promoted
+ * to a named type here so the dispatcher and its cells can pass it around
+ * without re-declaring it. The plugin populates this from
+ * `ReporterRenderInput.trendSummary` before invoking `dispatch`.
+ * @public
+ */
+interface TrendSummary {
+  readonly direction: "improving" | "regressing" | "stable";
+  readonly runCount: number;
+  readonly firstMetric?: {
+    readonly name: string;
+    readonly from: number;
+    readonly to: number;
+    readonly target?: number;
+  };
+}
+/**
+ * Inputs each cell renderer reads to produce its output.
+ *
+ * `state` carries the post-reduce projection of the `RunEvent`
+ * stream. `shape` and `outcome` are the classified axes the dispatcher
+ * keyed on to reach this cell. The remaining fields are non-state
+ * helpers the plugin computes once before dispatch so cells stay pure.
+ * @public
+ */
+interface DispatchInputs {
+  readonly state: RenderState;
+  readonly shape: RunShape;
+  readonly outcome: RunOutcome;
+  /**
+   * Per-project aggregates carried into workspace cells. Populated by
+   * the plugin from `ReporterRenderInput.reports`; empty for non-workspace
+   * shapes.
+   */
+  readonly projects: ReadonlyArray<ProjectSummary>;
+  /**
+   * Trend direction for cells that surface a `Trend: …` line. `null`
+   * for scoped runs and any run where trend history is unavailable.
+   */
+  readonly trend: TrendSummary | null;
+  /**
+   * Files below the aspirational `coverageTargets` tier. Workspace and
+   * project cells surface a truncated listing of these; single-file and
+   * single-test cells ignore them.
+   */
+  readonly belowTarget: ReadonlyArray<FileCoverageReport>;
+  /**
+   * Configured run command (e.g. `pnpm test`). Cell footers reference
+   * this so copy-pasted commands stay accurate. `null` when no command
+   * was configured.
+   */
+  readonly runCommand: string | null;
+}
+/**
+ * Render-time options threaded into each cell from the resolved
+ * `ReporterKit`. These are concerns the cell needs to format its
+ * output but that do not belong on the state-derived
+ * {@link DispatchInputs} struct.
+ *
+ * The plugin builds this once per run from the kit and passes it into
+ * `dispatch(inputs, opts)`. Cells destructure only what they consume.
+ * @public
+ */
+interface CellOptions {
+  /**
+   * Resolved value of the `NO_COLOR` env var. Cells gate ANSI escape
+   * sequences and OSC-8 hyperlinks on this.
+   */
+  readonly noColor: boolean;
+  /**
+   * Pre-bound OSC-8 hyperlink helper. The plugin has already decided
+   * whether OSC-8 should be enabled (`target=stdout`, `!noColor`) so
+   * cells can call this directly without re-consulting the environment.
+   */
+  readonly osc8: (url: string, label: string) => string;
+} //#endregion
+//#region src/schemas/Common.d.ts
+/**
+ * Possible states for an individual test case.
+ * @public
+ */
+/**
+ * Classification of a test's failure history across runs.
+ * @public
+ */
+declare const TestClassification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
+/** @public */
+type TestClassification = typeof TestClassification.Type;
+/**
+ * Console output verbosity mode for AgentReporter.
+ * @public
+ */
+//#endregion
+//#region src/schemas/RunEvent.d.ts
+/**
+ * Coverage metric whose threshold can be violated independently.
+ * @public
+ */
+declare const CoverageMetric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+/** @public */
+type CoverageMetric = typeof CoverageMetric.Type;
+/**
+ * Severity tier for a suggested action emitted during a run.
+ * @public
+ */
+declare const ActionSeverity: Schema.Literal<["info", "warn", "blocker"]>;
+/** @public */
+type ActionSeverity = typeof ActionSeverity.Type;
+/**
+ * Lifecycle scope of a Vitest setup/teardown hook.
+ * @public
+ */
+/**
+ * A coverage gap surfaced to the renderer — a per-file shortfall that
+ * a renderer may want to call out individually.
+ * @public
+ */
+declare const CoverageGap: Schema.Struct<{
+  file: typeof Schema.String;
+  missing: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  uncoveredLines: Schema.optional<typeof Schema.String>;
+}>;
+/** @public */
+type CoverageGap = typeof CoverageGap.Type;
+/**
+ * The reducer projects this union into `RenderState`. Renderers
+ * never read the raw event stream — they read the projected state.
+ *
+ * @remarks
+ * Adding a variant here is one change in one place; the reducer's
+ * exhaustive `Match.exhaustive` will surface any renderer that hasn't
+ * been updated to consume the new state shape.
+ * @public
+ */
+declare const RunEvent: Schema.Union<[Schema.TaggedStruct<"RunStarted", {
+  runId: typeof Schema.String;
+  startedAt: typeof Schema.String;
+  configHash: typeof Schema.String;
+}>, Schema.TaggedStruct<"ModuleQueued", {
+  modulePath: typeof Schema.String;
+  projectName: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"ModuleStarted", {
+  modulePath: typeof Schema.String;
+  startedAt: typeof Schema.String;
+  projectName: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TestStarted", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TestFinished", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  status: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+  durationMs: typeof Schema.Number;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+  timedOut: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.TaggedStruct<"ModuleFinished", {
+  modulePath: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  projectName: Schema.optional<typeof Schema.String>;
+  timeoutCount: Schema.optional<typeof Schema.Number>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+}>, Schema.TaggedStruct<"ModuleCollected", {
+  modulePath: typeof Schema.String;
+  testCount: typeof Schema.Number;
+  suiteCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"SuiteStarted", {
+  modulePath: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  suiteName: typeof Schema.String;
+}>, Schema.TaggedStruct<"SuiteFinished", {
+  modulePath: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  suiteName: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"HookStarted", {
+  modulePath: typeof Schema.String;
+  hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
+  scopeName: typeof Schema.String;
+}>, Schema.TaggedStruct<"HookFinished", {
+  modulePath: typeof Schema.String;
+  hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
+  scopeName: typeof Schema.String;
+  durationMs: typeof Schema.Number;
+  status: Schema.Literal<["passed", "failed"]>;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+}>, Schema.TaggedStruct<"ConsoleLog", {
+  modulePath: Schema.optional<typeof Schema.String>;
+  testName: Schema.optional<typeof Schema.String>;
+  level: Schema.Literal<["stdout", "stderr"]>;
+  content: typeof Schema.String;
+  time: typeof Schema.Number;
+}>, Schema.TaggedStruct<"RunTimedOut", {
+  message: typeof Schema.String;
+}>, Schema.TaggedStruct<"TestAnnotated", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  annotation: typeof Schema.String;
+}>, Schema.TaggedStruct<"TestArtifactRecorded", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  artifact: typeof Schema.String;
+}>, Schema.TaggedStruct<"WatcherReady", {}>, Schema.TaggedStruct<"WatcherRerun", {
+  triggerFiles: Schema.Array$<typeof Schema.String>;
+  reason: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TrendComputed", {
+  direction: Schema.Literal<["improving", "regressing", "stable"]>;
+  runCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"CoverageReady", {
+  metrics: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  thresholds: Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>;
+  gaps: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    missing: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    uncoveredLines: Schema.optional<typeof Schema.String>;
+  }>>;
+}>, Schema.TaggedStruct<"ThresholdViolation", {
+  metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+  expected: typeof Schema.Number;
+  actual: typeof Schema.Number;
+}>, Schema.TaggedStruct<"FailureClassified", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  classification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
+}>, Schema.TaggedStruct<"SuggestedAction", {
+  severity: Schema.Literal<["info", "warn", "blocker"]>;
+  title: typeof Schema.String;
+  detail: typeof Schema.String;
+  targetTool: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"RunFinished", {
+  runId: typeof Schema.String;
+  finishedAt: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  timeoutCount: Schema.optional<typeof Schema.Number>;
+}>]>;
+/** @public */
+type RunEvent = typeof RunEvent.Type;
+/**
+ * Convenience: discriminator-keyed map of the individual variants.
+ *
+ * Useful for callers that want to construct an event by tag without
+ * pulling the whole union shape into scope.
+ * @public
+ */
+type RunEventByTag = { [E in RunEvent as E["_tag"]]: E }; //#endregion
+//#region src/schemas/Thresholds.d.ts
+/**
+ * Per-metric threshold values. All optional -- only set metrics are enforced.
+ * @public
+ */
+declare const MetricThresholds: Schema.Struct<{
+  lines: Schema.optional<typeof Schema.Number>;
+  functions: Schema.optional<typeof Schema.Number>;
+  branches: Schema.optional<typeof Schema.Number>;
+  statements: Schema.optional<typeof Schema.Number>;
+}>;
+/** @public */
+type MetricThresholds = typeof MetricThresholds.Type;
+/**
+ * A glob pattern paired with its metric thresholds.
+ * @public
+ */
+//#endregion
+//#region src/utils/build-report.d.ts
+/**
+ * Duck-typed Vitest parsed stack frame.
+ *
+ * Vitest's TestError.stacks is `ParsedStack[]` from `@vitest/utils`, not a
+ * plain string array. Frames must be formatted before joining; otherwise
+ * `[obj].join("\n")` produces "[object Object]".
+ *
+ * @public
+ */
+interface VitestParsedStack {
+  method: string;
+  file: string;
+  line: number;
+  column: number;
+}
+/**
+ * Duck-typed Vitest test error with message, optional diff, and stack traces.
+ *
+ * `stacks` accepts both already-formatted strings (legacy / coercion path)
+ * and `ParsedStack[]` (real Vitest output).
+ *
+ * @public
+ */
+interface VitestTestError {
+  message: string;
+  diff?: string;
+  stacks?: Array<string | VitestParsedStack>;
+}
+/**
+ * Duck-typed Vitest test result returned by `TestCase.result()`.
+ *
+ * Vitest returns `undefined` for tests that have not finished running
+ * (pending/collected state).
+ *
+ * @public
+ */
+interface VitestTestResult {
+  state: string;
+  errors?: ReadonlyArray<VitestTestError>;
+}
+/**
+ * Duck-typed Vitest test diagnostic returned by `TestCase.diagnostic()`.
+ *
+ * @public
+ */
+interface VitestTestDiagnostic {
+  duration: number;
+  flaky: boolean;
+  slow: boolean;
+}
+/**
+ * Duck-typed Vitest TestCase from the Reporter v2 API.
+ *
+ * @remarks
+ * These interfaces mirror the Vitest TestCase shape without importing
+ * Vitest types directly, keeping the formatter a pure data transformer
+ * with no dependency on the Vitest runtime.
+ *
+ * @public
+ */
+interface VitestTestCase {
+  type: "test";
+  name: string;
+  fullName: string;
+  tags: readonly string[];
+  /** Parent suite or module. Optional in the duck-type so unit-test fixtures don't have to fabricate a stub; always present in real Vitest TestCase instances. */
+  parent?: VitestTestSuite | VitestTestModule;
+  result(): VitestTestResult | undefined;
+  diagnostic(): VitestTestDiagnostic | undefined;
+}
+/**
+ * Duck-typed Vitest module diagnostic.
+ *
+ * @public
+ */
+interface VitestModuleDiagnostic {
+  duration: number;
+}
+/**
+ * Duck-typed Vitest module error.
+ *
+ * @public
+ */
+interface VitestModuleError {
+  message: string;
+  stacks?: Array<string | VitestParsedStack>;
+}
+/**
+ * Duck-typed Vitest TestSuite from the Reporter v2 API.
+ *
+ * @public
+ */
+interface VitestTestSuite {
+  type: "suite";
+  name: string;
+  fullName: string;
+  state(): string;
+  parent: VitestTestSuite | VitestTestModule;
+  options: {
+    concurrent?: boolean;
+    shuffle?: boolean;
+    retry?: number;
+    repeats?: number;
+    mode?: string;
+    tags?: string[];
+  };
+  location?: {
+    line: number;
+    column: number;
+  };
+}
+/**
+ * Duck-typed Vitest TestModule from the Reporter v2 API.
+ *
+ * @remarks
+ * Each `TestModule` carries a `.project` reference with a `.name` property,
+ * which `AgentReporter` uses to group results by Vitest project in
+ * monorepo configurations.
+ *
+ * @public
+ */
+interface VitestTestModule {
+  type: "module";
+  moduleId: string;
+  relativeModuleId: string;
+  project: {
+    name: string;
+  };
+  state(): string;
+  children: {
+    allTests(filter?: string): Generator<VitestTestCase>;
+    allSuites(): Generator<VitestTestSuite>;
+  };
+  diagnostic(): VitestModuleDiagnostic | undefined;
+  errors(): Array<VitestModuleError>;
+}
+/**
+ * Convert Vitest TestModule/TestCase objects into an `AgentReport`.
+ *
+ * @remarks
+ * This is a pure data transformation function with no I/O. It tallies
+ * pass/fail/skip counts, extracts error details with diffs, and builds
+ * the complete report structure. Only modules with at least one failing
+ * test are included in the `failed` array to keep reports compact.
+ *
+ * @param testModules - All test modules from the Vitest run
+ * @param unhandledErrors - Unhandled errors from the run
+ * @param reason - Overall run outcome (`"passed"`, `"failed"`, or `"interrupted"`)
+ * @param options - Reporter options; only `omitPassingTests` is used
+ * @param projectName - Optional project name for monorepo grouping
+ * @returns Structured report ready for JSON serialization
+ *
+ * @public
+ */
+//#endregion
+//#region src/dispatcher/cell-types.d.ts
+/**
+ * A cell's agent-string half: pure function from dispatch inputs to a
+ * token-economy string emitted once at end-of-run.
+ *
+ * @public
+ */
+type AgentCellFn = (inputs: DispatchInputs, opts: CellOptions) => string;
+/**
+ * A cell's Ink half: pure function from dispatch inputs to a React
+ * element rendered live to the terminal.
+ *
+ * @public
+ */
+type InkCellFn = (inputs: DispatchInputs, opts: CellOptions) => ReactElement;
+/**
+ * One entry in the dispatcher matrix: an agent-string renderer and an
+ * optional Ink-tree renderer for the same `(RunShape, RunOutcome)` pair.
+ *
+ * @public
+ */
+interface Cell {
+  /** Agent-string half — always present. */
+  readonly agent: AgentCellFn;
+  /** Ink-tree half — omitted for cells where agent output is sufficient. */
+  readonly ink?: InkCellFn;
+}
+//#endregion
+//#region src/dispatcher/classify.d.ts
+/**
+ * Compute the run shape from the reduced state plus the per-project
+ * aggregates the plugin carries through `DispatchInputs.projects`.
+ *
+ * The classification follows the state-shape signal described in the
+ * UI rewrite spec §7 open question 1:
+ *
+ * 1. More than one project → `workspace`.
+ * 2. One module with exactly one test → `single-test`.
+ * 3. One module with more than one test → `single-file`.
+ * 4. Otherwise → `single-project`.
+ *
+ * @param state - the fully-reduced render state
+ * @param projects - per-project summaries from the dispatch inputs
+ * @returns the run shape classification
+ * @public
+ */
+declare const classifyRunShape: (state: RenderState, projects: ReadonlyArray<ProjectSummary>) => RunShape;
+/**
+ * Compute the outcome class from the reduced state.
+ *
+ * Precedence: failures win over threshold violations. A run with one
+ * failing test and a coverage gap classifies as `some-fail`; the
+ * threshold-violation cell is reserved for runs where the test suite
+ * itself is clean but coverage policy is not.
+ *
+ * @param state - the fully-reduced render state
+ * @returns the outcome classification
+ * @public
+ */
+declare const classifyOutcome: (state: RenderState) => RunOutcome;
+//#endregion
+//#region src/dispatcher/dispatch.d.ts
+/**
+ * The 4×3 cell table. Exported for the test harness so spy-based
+ * routing tests can introspect the wiring without re-deriving it from
+ * source.
+ *
+ * @public
+ */
+declare const dispatcherTable: Readonly<Record<RunShape, Readonly<Record<RunOutcome, Cell>>>>;
+/**
+ * Dispatch to the cell that matches `(inputs.shape, inputs.outcome)`
+ * and return its agent-half string output.
+ *
+ * @param inputs - the classified dispatch inputs
+ * @param opts - cell rendering options
+ * @returns the agent-string output for the matched cell
+ * @public
+ */
+declare const dispatch: (inputs: DispatchInputs, opts: CellOptions) => string;
+/**
+ * Dispatch to the cell that matches `(inputs.shape, inputs.outcome)`
+ * and return its Ink-half React tree. Returns `null` when the matched
+ * cell does not expose an `ink` half — callers should fall back to
+ * the agent string in that case.
+ *
+ * @param inputs - the classified dispatch inputs
+ * @param opts - cell rendering options
+ * @returns the Ink React element, or `null` when the cell has no Ink half
+ * @public
+ */
+declare const dispatchInk: (inputs: DispatchInputs, opts: CellOptions) => ReactElement | null;
+//#endregion
+//#region src/dispatcher/footer.d.ts
+/**
+ * Pick the dominant classification from a state's failure list.
+ *
+ * Priority order (most actionable first): `new-failure`, `persistent`,
+ * `flaky`, `recovered`, `stable`. Returns `null` when the failure list
+ * is empty or every failure is unclassified.
+ *
+ * @param state - the fully-reduced render state
+ * @returns the most actionable classification, or `null` when none applies
+ * @public
+ */
+declare const dominantClassification: (state: RenderState) => TestClassification | null;
+/**
+ * Compose the trailing footer lines for a dispatcher cell. Returns an
+ * empty string when no pointer applies. The footer starts with a
+ * leading newline so cells can append it directly without crafting
+ * their own separator.
+ *
+ * @param inputs - the classified dispatch inputs
+ * @returns the footer string, or an empty string when no pointer applies
+ * @public
+ */
+declare const buildFooter: (inputs: DispatchInputs) => string;
+//#endregion
+//#region src/format-duration.d.ts
+/**
+ * Shared display formatter for run / module / test durations.
+ *
+ * Vitest hands the reporter full-float millisecond durations
+ * (`14.87745800000016`). Rendering those verbatim is noise. This is
+ * the single formatter every render path calls — `render-agent.ts`,
+ * the `render-ink/` components, the dispatcher cells, and `StreamApp`
+ * — so a duration looks the same wherever it appears.
+ *
+ * Display only. Full-precision durations continue to persist to the
+ * database unchanged; nothing in the trend / baseline / classification
+ * pipeline reads a duration through a formatter.
+ */
+/**
+ * Format a duration in milliseconds for display.
+ *
+ * Sub-second values round to one decimal place and render as `<N.N>ms`;
+ * values at or above one second render as `<N.N>s`. A value that rounds
+ * to a whole number drops the trailing `.0` naturally (`Number`
+ * stringification), so `1000` → `1s` and `250` → `250ms`.
+ *
+ * @param ms - duration in milliseconds
+ * @returns formatted duration string
+ * @public
+ */
+declare const formatDisplayDuration: (ms: number) => string;
+//#endregion
+//#region src/pubsub/Channel.d.ts
+declare const RunEventChannel_base: Context.TagClass<RunEventChannel, "vitest-agent-ui/RunEventChannel", PubSub.PubSub<{
+  readonly _tag: "RunStarted";
+  readonly runId: string;
+  readonly startedAt: string;
+  readonly configHash: string;
+} | {
+  readonly _tag: "ModuleQueued";
+  readonly modulePath: string;
+  readonly projectName?: string | undefined;
+} | {
+  readonly _tag: "ModuleStarted";
+  readonly startedAt: string;
+  readonly modulePath: string;
+  readonly projectName?: string | undefined;
+} | {
+  readonly _tag: "TestStarted";
+  readonly modulePath: string;
+  readonly testName: string;
+  readonly suitePath: readonly string[];
+} | {
+  readonly _tag: "TestFinished";
+  readonly modulePath: string;
+  readonly testName: string;
+  readonly suitePath: readonly string[];
+  readonly status: "passed" | "failed" | "skipped" | "pending";
+  readonly durationMs: number;
+  readonly error?: {
+    readonly message: string;
+    readonly stack?: string | undefined;
+    readonly diff?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: string | undefined;
+  } | undefined;
+  readonly timedOut?: boolean | undefined;
+} | {
+  readonly _tag: "ModuleFinished";
+  readonly modulePath: string;
+  readonly projectName?: string | undefined;
+  readonly durationMs: number;
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly skipCount: number;
+  readonly timeoutCount?: number | undefined;
+  readonly tagCounts?: {
+    readonly [x: string]: number;
+  } | undefined;
+} | {
+  readonly _tag: "ModuleCollected";
+  readonly modulePath: string;
+  readonly testCount: number;
+  readonly suiteCount: number;
+} | {
+  readonly _tag: "SuiteStarted";
+  readonly modulePath: string;
+  readonly suitePath: readonly string[];
+  readonly suiteName: string;
+} | {
+  readonly _tag: "SuiteFinished";
+  readonly modulePath: string;
+  readonly suitePath: readonly string[];
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly skipCount: number;
+  readonly suiteName: string;
+} | {
+  readonly _tag: "HookStarted";
+  readonly modulePath: string;
+  readonly hookType: "beforeAll" | "afterAll" | "beforeEach" | "afterEach";
+  readonly scopeName: string;
+} | {
+  readonly _tag: "HookFinished";
+  readonly modulePath: string;
+  readonly status: "passed" | "failed";
+  readonly durationMs: number;
+  readonly error?: {
+    readonly message: string;
+    readonly stack?: string | undefined;
+    readonly diff?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly received?: string | undefined;
+  } | undefined;
+  readonly hookType: "beforeAll" | "afterAll" | "beforeEach" | "afterEach";
+  readonly scopeName: string;
+} | {
+  readonly _tag: "ConsoleLog";
+  readonly modulePath?: string | undefined;
+  readonly testName?: string | undefined;
+  readonly level: "stdout" | "stderr";
+  readonly content: string;
+  readonly time: number;
+} | {
+  readonly _tag: "RunTimedOut";
+  readonly message: string;
+} | {
+  readonly _tag: "TestAnnotated";
+  readonly modulePath: string;
+  readonly testName: string;
+  readonly suitePath: readonly string[];
+  readonly annotation: string;
+} | {
+  readonly _tag: "TestArtifactRecorded";
+  readonly modulePath: string;
+  readonly testName: string;
+  readonly suitePath: readonly string[];
+  readonly artifact: string;
+} | {
+  readonly _tag: "WatcherReady";
+} | {
+  readonly _tag: "WatcherRerun";
+  readonly triggerFiles: readonly string[];
+  readonly reason?: string | undefined;
+} | {
+  readonly _tag: "TrendComputed";
+  readonly direction: "improving" | "regressing" | "stable";
+  readonly runCount: number;
+} | {
+  readonly _tag: "CoverageReady";
+  readonly metrics: {
+    readonly statements: number;
+    readonly branches: number;
+    readonly functions: number;
+    readonly lines: number;
+  };
+  readonly thresholds: {
+    readonly statements?: number | undefined;
+    readonly branches?: number | undefined;
+    readonly functions?: number | undefined;
+    readonly lines?: number | undefined;
+  };
+  readonly gaps: readonly {
+    readonly file: string;
+    readonly missing: {
+      readonly statements: number;
+      readonly branches: number;
+      readonly functions: number;
+      readonly lines: number;
+    };
+    readonly uncoveredLines?: string | undefined;
+  }[];
+} | {
+  readonly _tag: "ThresholdViolation";
+  readonly expected: number;
+  readonly metric: "statements" | "branches" | "functions" | "lines";
+  readonly actual: number;
+} | {
+  readonly _tag: "FailureClassified";
+  readonly modulePath: string;
+  readonly testName: string;
+  readonly classification: "stable" | "new-failure" | "persistent" | "flaky" | "recovered";
+} | {
+  readonly _tag: "SuggestedAction";
+  readonly severity: "info" | "warn" | "blocker";
+  readonly title: string;
+  readonly detail: string;
+  readonly targetTool?: string | undefined;
+} | {
+  readonly _tag: "RunFinished";
+  readonly runId: string;
+  readonly durationMs: number;
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly skipCount: number;
+  readonly timeoutCount?: number | undefined;
+  readonly finishedAt: string;
+}>>;
+/**
+ * Service tag for the run-event channel. Consumers depend on this tag;
+ * the {@link RunEventChannelLive} layer is the single point at which
+ * the underlying Effect `PubSub` is constructed.
+ *
+ * @public
+ */
+declare class RunEventChannel extends RunEventChannel_base {}
+/**
+ * Default live layer providing an unbounded Effect `PubSub` for
+ * the run-event channel. The PubSub is scoped — when the surrounding
+ * scope closes, the channel shuts down and any pending subscribers
+ * receive their dequeue closure.
+ *
+ * Unbounded is the right default for the plugin and CLI: events arrive
+ * faster than a slow renderer can drain (e.g., several `TestFinished`
+ * per millisecond during a large suite), and dropping events would
+ * leave the rendered state inconsistent with the runner's truth.
+ * If memory pressure becomes a concern, swap in `PubSub.sliding`
+ * with a tuned capacity at the call site.
+ *
+ * @public
+ */
+declare const RunEventChannelLive: Layer.Layer<RunEventChannel>;
+//#endregion
+//#region src/pubsub/Publisher.d.ts
+/**
+ * Emit one event onto the channel.
+ *
+ * Resolves when the event is enqueued. Returns the success boolean
+ * from `PubSub.publish` so callers can detect a shutdown
+ * channel if needed; in normal operation the result is always `true`.
+ *
+ * @param event - the run event to publish
+ * @returns an Effect that resolves to the publish success boolean
+ * @public
+ */
+declare const publish: (event: RunEvent) => Effect.Effect<boolean, never, RunEventChannel>;
+/**
+ * Emit a batch of events onto the channel in order.
+ *
+ * Useful for the CLI replay path where the entire event sequence is
+ * materialized synchronously from a database query before any
+ * subscriber needs to read it.
+ *
+ * @param events - iterable of run events to publish in order
+ * @returns an Effect that resolves when all events are enqueued
+ * @public
+ */
+declare const publishAll: (events: Iterable<RunEvent>) => Effect.Effect<void, never, RunEventChannel>;
+//#endregion
+//#region src/pubsub/Subscriber.d.ts
+/**
+ * Subscribe, fold the run-event stream into a terminal
+ * `RenderState`, and return when `RunFinished` arrives.
+ *
+ * The subscription is scoped — when this effect completes (or is
+ * interrupted), the underlying PubSub releases its slot.
+ *
+ * @param initial - the initial render state to fold from
+ * @returns an Effect that resolves to the terminal render state
+ * @public
+ */
+declare const accumulateUntilFinished: (initial?: RenderState) => Effect.Effect<RenderState, never, RunEventChannel>;
+/**
+ * Run a callback for every projected `RenderState` as events
+ * arrive. The stream terminates when the PubSub shuts down (typically
+ * when the surrounding scope closes).
+ *
+ * The host runs this in a forked fiber so the publisher and the
+ * renderer can make progress concurrently. Returning an Effect from
+ * the callback lets the host suspend further rendering on backpressure
+ * (e.g. throttling redraws to the next animation frame).
+ *
+ * @param onState - callback invoked with each projected render state
+ * @param initial - the initial render state to fold from
+ * @returns an Effect that completes when the PubSub shuts down
+ * @public
+ */
+declare const forEachRenderState: <R, E>(onState: (state: RenderState) => Effect.Effect<void, E, R>, initial?: RenderState) => Effect.Effect<void, E, R | RunEventChannel>;
+/**
+ * Build an Effect `Stream` of accumulated states over the channel.
+ *
+ * Lower-level than {@link forEachRenderState} — useful when the host
+ * wants to compose with other stream operators (debouncing, throttling,
+ * tee-to-file) before running the terminal sink.
+ *
+ * @param initial - the initial render state to fold from
+ * @returns an Effect that resolves to a Stream of render states
+ * @public
+ */
+declare const renderStateStream: (initial?: RenderState) => Effect.Effect<Stream.Stream<RenderState>, never, RunEventChannel | Scope.Scope>;
+/**
+ * Convenience: subscribe and produce a low-level dequeue of raw
+ * `RunEvent` values. Mostly for tests and ad-hoc consumers; most
+ * application code should prefer {@link forEachRenderState} or
+ * {@link renderStateStream}.
+ *
+ * @returns an Effect that resolves to a dequeue of raw run events
+ * @public
+ */
+declare const subscribeRaw: () => Effect.Effect<Queue.Dequeue<RunEvent>, never, RunEventChannel | Scope.Scope>;
+//#endregion
+//#region src/reducer.d.ts
+/**
+ * Apply a single event to the previous state and return the next.
+ *
+ * The function is pure: no I/O, no time, no randomness. Folding it
+ * over an event sequence yields the same state regardless of when the
+ * fold runs.
+ *
+ * @param state - the current render state
+ * @param event - the run event to apply
+ * @returns the next render state
+ * @public
+ */
+declare const reduceRenderState: (state: RenderState, event: RunEvent) => RenderState;
+/**
+ * Fold a sequence of events into a final `RenderState`.
+ *
+ * Convenience for tests, replays, and the agent renderer's
+ * accumulate-then-render-once path.
+ *
+ * @param events - the ordered event sequence to fold
+ * @param seed - the initial render state (defaults to `initialRenderState`)
+ * @returns the terminal render state after all events are applied
+ * @public
+ */
+declare const reduceRenderStateAll: (events: ReadonlyArray<RunEvent>, seed?: RenderState) => RenderState;
+//#endregion
+//#region src/render-agent.d.ts
+/**
+ * Options controlling agent-mode output. All fields optional; defaults
+ * match the spec's "80-column, top-3 gaps, no error stack" target.
+ *
+ * @public
+ */
+interface RenderAgentOptions {
+  /**
+   * Target column width for soft-wrapping the longer detail lines.
+   * The renderer does not enforce a hard wrap — short lines never
+   * pad — but uses this when truncating diff or stack output.
+   *
+   * @defaultValue 80
+   */
+  readonly width?: number;
+  /**
+   * How many coverage gaps to list (top by missing lines). Set to 0
+   * to omit the gap block entirely; the violations block is
+   * independent and always rendered when present.
+   *
+   * @defaultValue 3
+   */
+  readonly maxCoverageGaps?: number;
+  /**
+   * Whether to include the full stack trace for each failure. The
+   * agent path defaults to false because the structured failure data
+   * is already available via MCP tools.
+   *
+   * @defaultValue false
+   */
+  readonly includeStack?: boolean;
+}
+/**
+ * Project the reduced `RenderState` into a single string suitable
+ * for emission once at the end of a run.
+ *
+ * The output is deterministic given a stable input — folding the same
+ * event sequence twice and rendering produces byte-identical strings.
+ *
+ * @param state - the fully-reduced render state
+ * @param options - optional output-shaping options
+ * @returns the agent-format string
+ * @public
+ */
+declare const renderAgent: (state: RenderState, options?: RenderAgentOptions) => string;
+//#endregion
+//#region src/render-ink/CountColumns.d.ts
+/**
+ * Props for the `CountColumns` component.
+ *
+ * @public
+ */
+interface CountColumnsProps {
+  /** Number of passing tests. */
+  readonly passCount: number;
+  /** Number of failing tests. */
+  readonly failCount: number;
+  /** Number of skipped tests. */
+  readonly skipCount: number;
+  /** Number of timed-out tests. */
+  readonly timeoutCount: number;
+}
+/**
+ * Renders four colored count columns (pass ✓, fail ✗, skip ↷, timeout ⧖)
+ * for an aggregate row. Zeros are dimmed; all four columns always appear.
+ *
+ * @public
+ */
+declare const CountColumns: FC<CountColumnsProps>;
+//#endregion
+//#region src/render-ink/CoverageBlock.d.ts
+/**
+ * Props for the `CoverageBlock` component.
+ *
+ * @public
+ */
+interface CoverageBlockProps {
+  /** The coverage render state to display. */
+  readonly coverage: CoverageRenderState;
+  /** Maximum number of gap entries to list; defaults to 3. */
+  readonly maxGaps?: number;
+}
+/**
+ * Renders the coverage section: per-metric percentages, threshold
+ * violations, and top-N gap entries sorted by missing line count.
+ *
+ * @public
+ */
+declare const CoverageBlock: FC<CoverageBlockProps>;
+//#endregion
+//#region src/render-ink/FailureSection.d.ts
+/**
+ * Props for the `FailureSection` component.
+ *
+ * @public
+ */
+interface FailureSectionProps {
+  /** The list of failure records to display. */
+  readonly failures: ReadonlyArray<FailureRecord>;
+  /** When `true`, renders the full stack trace under each failure. */
+  readonly includeStack?: boolean;
+}
+/**
+ * Renders one block per failed test: glyph, path, classification tag,
+ * error message, diff lines, and optionally the stack trace.
+ *
+ * @public
+ */
+declare const FailureSection: FC<FailureSectionProps>;
+//#endregion
+//#region src/render-ink/FailuresSection.d.ts
+/**
+ * Props for the `FailuresSection` component.
+ *
+ * @public
+ */
+interface FailuresSectionProps {
+  /** The list of failure records to display. */
+  readonly failures: ReadonlyArray<FailureRecord>;
+  /** Maximum entries to list before collapsing the rest into an overflow line. */
+  readonly limit: number;
+}
+/**
+ * Renders the capped failures block for aggregate-row shapes.
+ * Entries beyond `limit` collapse into an overflow line.
+ *
+ * @public
+ */
+declare const FailuresSection: FC<FailuresSectionProps>;
+//#endregion
+//#region src/render-ink/ModuleHeader.d.ts
+/**
+ * Props for the `ModuleHeader` component.
+ *
+ * @public
+ */
+interface ModuleHeaderProps {
+  /** The module record to display. */
+  readonly module: ModuleRecord;
+}
+/**
+ * Renders the per-module title line: a status glyph, the module path,
+ * and a dimmed inline summary of pass/fail/skip counts and duration.
+ *
+ * @public
+ */
+declare const ModuleHeader: FC<ModuleHeaderProps>;
+//#endregion
+//#region src/render-ink/ProjectRow.d.ts
+/**
+ * Props for the `ProjectRow` component.
+ *
+ * @public
+ */
+interface ProjectRowProps {
+  /** The per-project rollup. */
+  readonly project: ProjectSummary;
+  /** Pass/fail/skip/timeout counts for the project. */
+  readonly counts: {
+    passCount: number;
+    failCount: number;
+    skipCount: number;
+    timeoutCount: number;
+  };
+  /** True while the project still has a running or queued module. */
+  readonly running: boolean;
+  /**
+   * True when the run has been timed out — running rows resolve to the
+   * `⧖` glyph instead of continuing to animate the spinner.
+   */
+  readonly timedOut?: boolean;
+  /** Elapsed milliseconds — wall-clock while running, summed duration once finished. */
+  readonly elapsedMs: number;
+  /** Current spinner glyph; rendered in place of the status icon while running. */
+  readonly frame: string;
+  /** Name-column width so the count columns align across rows. */
+  readonly nameWidth: number;
+  /** Per-tag test counts for the project, merged across its modules. */
+  readonly tagCounts?: Record<string, number>;
+}
+/**
+ * Renders one per-project row in the `workspace`-shape live view: status
+ * glyph (animated spinner while running), project name, count columns,
+ * elapsed duration, and optional tag counts.
+ *
+ * @public
+ */
+declare const ProjectRow: FC<ProjectRowProps>;
+//#endregion
+//#region src/render-ink/StatusIcon.d.ts
+/**
+ * The set of named statuses a `StatusIcon` can render.
+ *
+ * @public
+ */
+type StatusIconKind = "passed" | "failed" | "skipped" | "pending" | "running" | "queued" | "finished" | "threshold" | "timed-out";
+/**
+ * Props for the `StatusIcon` component.
+ *
+ * @public
+ */
+interface StatusIconProps {
+  /** The status to render as a colored glyph. */
+  readonly status: StatusIconKind;
+}
+/**
+ * Renders a single colored status glyph for a test, module, or run.
+ *
+ * @public
+ */
+declare const StatusIcon: FC<StatusIconProps>;
+//#endregion
+//#region src/render-ink/StreamApp.d.ts
+/**
+ * Props for the `StreamApp` component.
+ *
+ * @public
+ */
+interface StreamAppProps {
+  /** The current reduced render state to display. */
+  readonly state: RenderState;
+  /** Current spinner frame index, derived from wall-clock time. */
+  readonly frameIndex: number;
+  /** Current wall-clock time in milliseconds; defaults to `Date.now()`. */
+  readonly nowMs?: number;
+}
+/**
+ * Root Ink component for the `stream` live renderer. Classifies the run
+ * shape and renders the appropriate per-shape live region.
+ *
+ * @public
+ */
+declare const StreamApp: FC<StreamAppProps>;
+//#endregion
+//#region src/render-ink/SuggestedActions.d.ts
+/**
+ * Props for the `SuggestedActions` component.
+ *
+ * @public
+ */
+interface SuggestedActionsProps {
+  /** The list of suggested actions to display. */
+  readonly actions: ReadonlyArray<SuggestedActionRecord>;
+}
+/**
+ * Renders the suggested-actions queue as severity-prefixed rows with
+ * optional tool hints. Returns `null` when the actions list is empty.
+ *
+ * @public
+ */
+declare const SuggestedActions: FC<SuggestedActionsProps>;
+//#endregion
+//#region src/render-ink/spinner.d.ts
+/**
+ * Hand-rolled Braille spinner for the `stream` live renderer.
+ *
+ * No `ink-spinner` dependency — that package is a thin wrapper over the
+ * same ten Braille characters plus a timer. The `stream` renderer
+ * already needs a frame clock for the ticking elapsed column, so the
+ * timer is shared and only the frame array lives here.
+ *
+ * The frame index is presentation state: it is derived from wall-clock
+ * time by `createLiveInk` and passed to `StreamApp` as a prop. It never
+ * enters the event-sourced `RenderState`.
+ */
+/**
+ * The ten Braille spinner frames, in animation order.
+ *
+ * @public
+ */
+declare const SPINNER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * How long each spinner frame is held, in milliseconds.
+ *
+ * @public
+ */
+declare const SPINNER_FRAME_MS = 80;
+/**
+ * Resolve the spinner glyph for a frame index. The index wraps modulo
+ * the frame count and tolerates negative values, so a wall-clock-derived
+ * index is always valid.
+ *
+ * @param index - the frame index (wraps modulo frame count)
+ * @returns the Braille glyph for the given frame
+ * @public
+ */
+declare const spinnerFrame: (index: number) => string;
+/**
+ * Derive the spinner frame index from a wall-clock timestamp. Using the
+ * clock — rather than a monotonic counter — keeps the animation correct
+ * across watch-mode remounts with no extra closure state to reset.
+ *
+ * @param nowMs - current wall-clock time in milliseconds
+ * @returns the frame index for the given timestamp
+ * @public
+ */
+declare const spinnerFrameForTime: (nowMs: number) => number;
+//#endregion
+//#region src/render-ink/TestRow.d.ts
+/**
+ * Props for the `TestRow` component.
+ *
+ * @public
+ */
+interface TestRowProps {
+  /** The test record to display. */
+  readonly test: TestRecord;
+  /** Leading indentation in spaces; defaults to 2. */
+  readonly indent?: number;
+}
+/**
+ * Renders one test row: status glyph, optional suite prefix, test name, and duration.
+ *
+ * @public
+ */
+declare const TestRow: FC<TestRowProps>;
+//#endregion
+//#region src/render-ink/TrendLine.d.ts
+/**
+ * Props for the `TrendLine` component.
+ *
+ * @public
+ */
+interface TrendLineProps {
+  /** The trend summary to display. */
+  readonly trend: {
+    readonly direction: "improving" | "regressing" | "stable";
+    readonly runCount: number;
+  };
+}
+/**
+ * Renders the one-line trend signal: direction (colored) and run count.
+ *
+ * @public
+ */
+declare const TrendLine: FC<TrendLineProps>;
+//#endregion
+//#region src/synthesize.d.ts
+/**
+ * Optional metadata threaded through the synthesized event stream.
+ *
+ * @public
+ */
+interface SynthesizeOptions {
+  readonly runId?: string;
+  readonly configHash?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly classifications?: ReadonlyMap<string, TestClassification>;
+  readonly coverage?: SynthesizedCoverage;
+  readonly suggestedActions?: ReadonlyArray<{
+    readonly severity: ActionSeverity;
+    readonly title: string;
+    readonly detail: string;
+    readonly targetTool?: string;
+  }>;
+}
+/**
+ * Coverage data to thread into the synthesized event stream.
+ *
+ * @public
+ */
+interface SynthesizedCoverage {
+  /** Aggregated coverage totals for each metric. */
+  readonly metrics: CoverageTotals;
+  /** The configured threshold values for each metric. */
+  readonly thresholds: MetricThresholds;
+  /** Per-file coverage gaps (files below threshold). */
+  readonly gaps: ReadonlyArray<CoverageGap>;
+  /** Threshold violations to emit as `ThresholdViolation` events. */
+  readonly violations?: ReadonlyArray<{
+    readonly metric: CoverageMetric;
+    readonly expected: number;
+    readonly actual: number;
+  }>;
+}
+/**
+ * Project a fully-completed Vitest run into the canonical
+ * `RunEvent` stream. The output is deterministic given a
+ * stable input.
+ *
+ * @param modules - the array of completed Vitest test modules
+ * @param options - optional metadata to thread into the event stream
+ * @returns an ordered array of run events
+ * @public
+ */
+declare const synthesizeRunEvents: (modules: ReadonlyArray<VitestTestModule>, options?: SynthesizeOptions) => RunEvent[];
+/**
+ * Options for {@link synthesizeFromAgentReport}.
+ *
+ * @public
+ */
+interface SynthesizeFromAgentReportOptions {
+  /** Override runId; defaults to `report.timestamp`. */
+  readonly runId?: string;
+  /** Override startedAt; defaults to `report.timestamp`. */
+  readonly startedAt?: string;
+  /** Override finishedAt; defaults to `report.timestamp`. */
+  readonly finishedAt?: string;
+  /** configHash placeholder; AgentReport does not carry one. */
+  readonly configHash?: string;
+  /** Optional suggested actions appended before RunFinished. */
+  readonly suggestedActions?: SynthesizeOptions["suggestedActions"];
+}
+/**
+ * Bridge a persisted `AgentReport` into a `RunEvent` stream.
+ *
+ * `AgentReport` stores only failed modules in detail; passed-only modules
+ * are summarized via `summary.passed` without per-module breakdown. The
+ * synthesized stream reflects this — it emits per-test events for the
+ * failed modules and lets `RunFinished` carry the authoritative totals.
+ * Renderers see "N passed, M failed" in the header while the Modules
+ * section enumerates only the failing modules.
+ *
+ * @param report - the persisted agent report to synthesize from
+ * @param options - optional overrides for run metadata
+ * @returns an ordered array of run events
+ * @public
+ */
+declare const synthesizeFromAgentReport: (report: AgentReport, options?: SynthesizeFromAgentReportOptions) => RunEvent[];
+//#endregion
+//#region src/index.d.ts
+/**
+ * The version of this package, inlined at build time from
+ * `package.json#version` via rslib-builder's `__PACKAGE_VERSION__`
+ * substitution. The UI package is consumed through the plugin so it does not
+ * run its own init-time drift check, but the constant is exported so the
+ * plugin can compare against it.
+ *
+ * @public
+ */
+declare const CURRENT_UI_VERSION: string;
+//#endregion
+export { ActionSeverity, type AgentCellFn, type AgentReport, CURRENT_UI_VERSION, type Cell, type CellOptions, CountColumns, type CountColumnsProps, CoverageBlock, type CoverageBlockProps, FileCoverageReport as CoverageFile, CoverageGap, CoverageMetric, CoverageRenderState, type CoverageTotals, type DispatchInputs, FailureRecord, FailureSection, type FailureSectionProps, FailuresSection, type FailuresSectionProps, type InkCellFn, type MetricThresholds, ModuleHeader, type ModuleHeaderProps, ModuleRecord, ProjectRow, type ProjectRowProps, type ProjectSummary, type RenderAgentOptions, RenderState, RenderTotals, RunEvent, type RunEventByTag, RunEventChannel, RunEventChannelLive, type RunOutcome, type RunShape, SPINNER_FRAMES, SPINNER_FRAME_MS, StatusIcon, type StatusIconKind, type StatusIconProps, StreamApp, type StreamAppProps, SuggestedActionRecord, SuggestedActions, type SuggestedActionsProps, type SynthesizeFromAgentReportOptions, type SynthesizeOptions, type SynthesizedCoverage, type TestClassification, TestRecord, TestRow, type TestRowProps, TrendLine, type TrendLineProps, type TrendSummary, type VitestModuleDiagnostic, type VitestModuleError, type VitestParsedStack, type VitestTestCase, type VitestTestDiagnostic, type VitestTestError, type VitestTestModule, type VitestTestResult, type VitestTestSuite, accumulateUntilFinished, buildFooter, classifyOutcome, classifyRunShape, dispatch, dispatchInk, dispatcherTable, dominantClassification, forEachRenderState, formatDisplayDuration, initialRenderState, publish, publishAll, reduceRenderState, reduceRenderStateAll, renderAgent, renderStateStream, spinnerFrame, spinnerFrameForTime, subscribeRaw, synthesizeFromAgentReport, synthesizeRunEvents };
+//# sourceMappingURL=index.d.ts.map