@vitest-agent/ui 4.1.0 → 5.0.0

package/ink.d.ts

@@ -0,0 +1,789 @@
+import { Schema } from "effect";
+import { FC, ReactElement } from "react";
+//#region ../sdk/dist/dev/pkg/index.d.ts
+/**
+ * Per-file coverage data including uncovered line ranges.
+ * @public
+ */
+declare const FileCoverageReport: Schema.Struct<{
+  readonly file: Schema.String;
+  readonly summary: Schema.Struct<{
+    readonly statements: Schema.Number;
+    readonly branches: Schema.Number;
+    readonly functions: Schema.Number;
+    readonly lines: Schema.Number;
+  }>;
+  readonly uncoveredLines: Schema.String;
+}>;
+/** @public */
+type FileCoverageReport = typeof FileCoverageReport.Type;
+//#endregion
+//#region src/schemas/RenderState.d.ts
+/**
+ * Per-test record accumulated as `TestStarted` / `TestFinished` events arrive.
+ * @public
+ */
+declare const TestRecord: Schema.Struct<{
+  readonly testName: Schema.String;
+  readonly suitePath: Schema.$Array<Schema.String>;
+  readonly status: Schema.Union<readonly [Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>, Schema.Literals<readonly ["running", "timed-out"]>]>;
+  readonly durationMs: Schema.NullOr<Schema.Number>;
+  readonly error: Schema.optional<Schema.Struct<{
+    readonly message: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+    readonly diff: Schema.optional<Schema.String>;
+    readonly expected: Schema.optional<Schema.String>;
+    readonly received: Schema.optional<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<{
+  readonly modulePath: Schema.String;
+  readonly status: Schema.Literals<readonly ["queued", "running", "finished"]>;
+  readonly passCount: Schema.Number;
+  readonly failCount: Schema.Number;
+  readonly skipCount: Schema.Number;
+  readonly timeoutCount: Schema.Number;
+  readonly durationMs: Schema.Number;
+  readonly tests: Schema.$Array<Schema.Struct<{
+    readonly testName: Schema.String;
+    readonly suitePath: Schema.$Array<Schema.String>;
+    readonly status: Schema.Union<readonly [Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>, Schema.Literals<readonly ["running", "timed-out"]>]>;
+    readonly durationMs: Schema.NullOr<Schema.Number>;
+    readonly error: Schema.optional<Schema.Struct<{
+      readonly message: Schema.String;
+      readonly stack: Schema.optional<Schema.String>;
+      readonly diff: Schema.optional<Schema.String>;
+      readonly expected: Schema.optional<Schema.String>;
+      readonly received: Schema.optional<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.
+   */
+  readonly projectName: Schema.optional<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.
+   */
+  readonly startedAt: Schema.optional<Schema.String>;
+  readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, 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<{
+  readonly modulePath: Schema.String;
+  readonly testName: Schema.String;
+  readonly suitePath: Schema.$Array<Schema.String>;
+  readonly error: Schema.optional<Schema.Struct<{
+    readonly message: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+    readonly diff: Schema.optional<Schema.String>;
+    readonly expected: Schema.optional<Schema.String>;
+    readonly received: Schema.optional<Schema.String>;
+  }>>;
+  readonly timedOut: Schema.optional<Schema.Boolean>;
+  readonly classification: Schema.NullOr<Schema.Literals<readonly ["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<{
+  readonly metrics: Schema.Struct<{
+    readonly statements: Schema.Number;
+    readonly branches: Schema.Number;
+    readonly functions: Schema.Number;
+    readonly lines: Schema.Number;
+  }>;
+  readonly thresholds: Schema.Struct<{
+    readonly lines: Schema.optional<Schema.Number>;
+    readonly functions: Schema.optional<Schema.Number>;
+    readonly branches: Schema.optional<Schema.Number>;
+    readonly statements: Schema.optional<Schema.Number>;
+  }>;
+  readonly gaps: Schema.$Array<Schema.Struct<{
+    readonly file: Schema.String;
+    readonly missing: Schema.Struct<{
+      readonly statements: Schema.Number;
+      readonly branches: Schema.Number;
+      readonly functions: Schema.Number;
+      readonly lines: Schema.Number;
+    }>;
+    readonly uncoveredLines: Schema.optional<Schema.String>;
+  }>>;
+  readonly violations: Schema.$Array<Schema.Struct<{
+    readonly metric: Schema.Literals<readonly ["lines", "branches", "functions", "statements"]>;
+    readonly expected: Schema.Number;
+    readonly actual: Schema.Number;
+  }>>;
+  readonly scoped: Schema.optional<Schema.Boolean>;
+  readonly scopedFiles: Schema.optional<Schema.Number>;
+  readonly totalFiles: Schema.optional<Schema.Number>;
+  readonly globShortfalls: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly pattern: Schema.String;
+    readonly summary: Schema.Struct<{
+      readonly statements: Schema.Number;
+      readonly branches: Schema.Number;
+      readonly functions: Schema.Number;
+      readonly lines: Schema.Number;
+    }>;
+    readonly thresholds: Schema.Struct<{
+      readonly lines: Schema.optional<Schema.Number>;
+      readonly functions: Schema.optional<Schema.Number>;
+      readonly branches: Schema.optional<Schema.Number>;
+      readonly statements: Schema.optional<Schema.Number>;
+    }>;
+  }>>>;
+}>;
+/** @public */
+type CoverageRenderState = typeof CoverageRenderState.Type;
+/**
+ * A `SuggestedAction` event, denormalized into the queue the renderer reads.
+ * @public
+ */
+declare const SuggestedActionRecord: Schema.Struct<{
+  readonly severity: Schema.Literals<readonly ["info", "warn", "blocker"]>;
+  readonly title: Schema.String;
+  readonly detail: Schema.String;
+  readonly targetTool: Schema.optional<Schema.String>;
+}>;
+/** @public */
+type SuggestedActionRecord = typeof SuggestedActionRecord.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<{
+  readonly phase: Schema.Literals<readonly ["idle", "running", "finished", "timed-out"]>;
+  readonly runId: Schema.NullOr<Schema.String>;
+  readonly configHash: Schema.NullOr<Schema.String>;
+  readonly startedAt: Schema.NullOr<Schema.String>;
+  readonly finishedAt: Schema.NullOr<Schema.String>;
+  readonly modules: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly modulePath: Schema.String;
+    readonly status: Schema.Literals<readonly ["queued", "running", "finished"]>;
+    readonly passCount: Schema.Number;
+    readonly failCount: Schema.Number;
+    readonly skipCount: Schema.Number;
+    readonly timeoutCount: Schema.Number;
+    readonly durationMs: Schema.Number;
+    readonly tests: Schema.$Array<Schema.Struct<{
+      readonly testName: Schema.String;
+      readonly suitePath: Schema.$Array<Schema.String>;
+      readonly status: Schema.Union<readonly [Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>, Schema.Literals<readonly ["running", "timed-out"]>]>;
+      readonly durationMs: Schema.NullOr<Schema.Number>;
+      readonly error: Schema.optional<Schema.Struct<{
+        readonly message: Schema.String;
+        readonly stack: Schema.optional<Schema.String>;
+        readonly diff: Schema.optional<Schema.String>;
+        readonly expected: Schema.optional<Schema.String>;
+        readonly received: Schema.optional<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.
+     */
+    readonly projectName: Schema.optional<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.
+     */
+    readonly startedAt: Schema.optional<Schema.String>;
+    readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+  }>>;
+  readonly moduleOrder: Schema.$Array<Schema.String>;
+  readonly totals: Schema.Struct<{
+    readonly passCount: Schema.Number;
+    readonly failCount: Schema.Number;
+    readonly skipCount: Schema.Number;
+    readonly timeoutCount: Schema.Number;
+    readonly durationMs: Schema.Number;
+  }>;
+  readonly coverage: Schema.NullOr<Schema.Struct<{
+    readonly metrics: Schema.Struct<{
+      readonly statements: Schema.Number;
+      readonly branches: Schema.Number;
+      readonly functions: Schema.Number;
+      readonly lines: Schema.Number;
+    }>;
+    readonly thresholds: Schema.Struct<{
+      readonly lines: Schema.optional<Schema.Number>;
+      readonly functions: Schema.optional<Schema.Number>;
+      readonly branches: Schema.optional<Schema.Number>;
+      readonly statements: Schema.optional<Schema.Number>;
+    }>;
+    readonly gaps: Schema.$Array<Schema.Struct<{
+      readonly file: Schema.String;
+      readonly missing: Schema.Struct<{
+        readonly statements: Schema.Number;
+        readonly branches: Schema.Number;
+        readonly functions: Schema.Number;
+        readonly lines: Schema.Number;
+      }>;
+      readonly uncoveredLines: Schema.optional<Schema.String>;
+    }>>;
+    readonly violations: Schema.$Array<Schema.Struct<{
+      readonly metric: Schema.Literals<readonly ["lines", "branches", "functions", "statements"]>;
+      readonly expected: Schema.Number;
+      readonly actual: Schema.Number;
+    }>>;
+    readonly scoped: Schema.optional<Schema.Boolean>;
+    readonly scopedFiles: Schema.optional<Schema.Number>;
+    readonly totalFiles: Schema.optional<Schema.Number>;
+    readonly globShortfalls: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly pattern: Schema.String;
+      readonly summary: Schema.Struct<{
+        readonly statements: Schema.Number;
+        readonly branches: Schema.Number;
+        readonly functions: Schema.Number;
+        readonly lines: Schema.Number;
+      }>;
+      readonly thresholds: Schema.Struct<{
+        readonly lines: Schema.optional<Schema.Number>;
+        readonly functions: Schema.optional<Schema.Number>;
+        readonly branches: Schema.optional<Schema.Number>;
+        readonly statements: Schema.optional<Schema.Number>;
+      }>;
+    }>>>;
+  }>>;
+  readonly trend: Schema.NullOr<Schema.Struct<{
+    readonly direction: Schema.Literals<readonly ["improving", "regressing", "stable"]>;
+    readonly runCount: Schema.Number;
+  }>>;
+  readonly failures: Schema.$Array<Schema.Struct<{
+    readonly modulePath: Schema.String;
+    readonly testName: Schema.String;
+    readonly suitePath: Schema.$Array<Schema.String>;
+    readonly error: Schema.optional<Schema.Struct<{
+      readonly message: Schema.String;
+      readonly stack: Schema.optional<Schema.String>;
+      readonly diff: Schema.optional<Schema.String>;
+      readonly expected: Schema.optional<Schema.String>;
+      readonly received: Schema.optional<Schema.String>;
+    }>>;
+    readonly timedOut: Schema.optional<Schema.Boolean>;
+    readonly classification: Schema.NullOr<Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+  }>>;
+  readonly suggestedActions: Schema.$Array<Schema.Struct<{
+    readonly severity: Schema.Literals<readonly ["info", "warn", "blocker"]>;
+    readonly title: Schema.String;
+    readonly detail: Schema.String;
+    readonly targetTool: Schema.optional<Schema.String>;
+  }>>;
+  /**
+   * Count of every collected module, passing modules included. Folded
+   * from `RunFinished.collectedModules`. Renderers prefer this over
+   * `moduleOrder.length` for "N modules all-passed" copy — a report
+   * replay only queues failing modules, so `moduleOrder` alone
+   * undercounts a green run to zero (issue #204). Optional — a run
+   * that never carried the field (older replay data, hand-built
+   * fixtures) falls back to `moduleOrder.length`.
+   */
+  readonly collectedModules: Schema.optional<Schema.Number>;
+  /**
+   * Process-level errors with no owning module, folded from
+   * `RunFinished.unhandledErrors`. A run that never carried the field
+   * (older replay data, hand-built fixtures) defaults to `[]`. See
+   * issue #240.
+   */
+  readonly unhandledErrors: Schema.$Array<Schema.Struct<{
+    readonly message: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+    readonly diff: Schema.optional<Schema.String>;
+    readonly expected: Schema.optional<Schema.String>;
+    readonly received: Schema.optional<Schema.String>;
+  }>>;
+  /**
+   * What the run wrote straight to the terminal, past Vitest's console
+   * capture, folded from `RunFinished.strayOutput`. Absent when the run
+   * wrote nothing stray.
+   */
+  readonly strayOutput: Schema.optional<Schema.Struct<{
+    readonly total: Schema.Number;
+    readonly stdout: Schema.Number;
+    readonly stderr: Schema.Number;
+    readonly bytes: Schema.Number;
+    readonly samples: Schema.$Array<Schema.Struct<{
+      readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+      readonly text: Schema.String;
+    }>>;
+  }>>;
+}>;
+/** @public */
+type RenderState = typeof RenderState.Type;
+//#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 timeoutCount?: 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/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;
+}
+/**
+ * Fixed width of the duration cell that follows the count columns on an
+ * aggregate row — sized for the formatter's widest common output
+ * (`59m 59s`). Longer values overflow their row rather than truncate.
+ *
+ * @public
+ */
+export declare const DURATION_CELL_WIDTH = 7;
+/**
+ * Renders four colored count columns (pass ✓, fail ✗, skip ↷, timeout ⧖)
+ * for an aggregate row. Counts render right-aligned in fixed 4-digit cells so
+ * columns align across rows; counts of 10,000+ overflow their row without
+ * truncation. Zeros are greyed; all four columns always appear. Glyphs and
+ * colours come from `VitestAgentStatus` (skip is `muted`).
+ *
+ * @public
+ */
+export declare const CountColumns: FC<CountColumnsProps>;
+//#endregion
+//#region src/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
+ */
+export declare const CoverageBlock: FC<CoverageBlockProps>;
+//#endregion
+//#region src/ink/dispatch-ink.d.ts
+/**
+ * A cell's Ink half: pure function from dispatch inputs to a React
+ * element rendered to the terminal.
+ *
+ * @public
+ */
+type InkCellFn = (inputs: DispatchInputs, opts: CellOptions) => ReactElement;
+/**
+ * The 4×3 Ink cell table, keyed by the same `(RunShape, RunOutcome)`
+ * matrix as the root entry's `dispatcherTable`. An `undefined` entry is a
+ * cell with no Ink half (`single-test × threshold-violation`).
+ *
+ * @public
+ */
+export declare const inkDispatcherTable: Readonly<Record<RunShape, Readonly<Record<RunOutcome, InkCellFn | undefined>>>>;
+/**
+ * Dispatch to the cell that matches `(inputs.shape, inputs.outcome)`
+ * and return its Ink-half React tree, followed by the scoped-coverage
+ * note on a partial run. Returns `null` when the matched cell has no Ink
+ * half — callers fall back to the root entry's `dispatch` string then.
+ *
+ * @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
+ */
+export declare const dispatchInk: (inputs: DispatchInputs, opts: CellOptions) => ReactElement | null;
+//#endregion
+//#region src/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
+ */
+export declare const FailureSection: FC<FailureSectionProps>;
+//#endregion
+//#region src/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
+ */
+export declare const FailuresSection: FC<FailuresSectionProps>;
+//#endregion
+//#region src/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
+ */
+export declare const ModuleHeader: FC<ModuleHeaderProps>;
+//#endregion
+//#region src/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; feeds the TagColumns cells. */
+  readonly tagCounts?: Record<string, number> | undefined;
+  /**
+   * The view-level tag union. Every row renders every tag in it so the
+   * tag columns align; empty (the default) renders no tag cells.
+   */
+  readonly tagUnion?: ReadonlyArray<string>;
+}
+/**
+ * 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
+ */
+export declare const ProjectRow: FC<ProjectRowProps>;
+//#endregion
+//#region src/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
+ */
+export declare const StatusIcon: FC<StatusIconProps>;
+//#endregion
+//#region src/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 (the live view's `frame`: wall-clock ticks of `SPINNER_FRAME_MS`). */
+  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
+ */
+export declare const StreamApp: FC<StreamAppProps>;
+//#endregion
+//#region src/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
+ */
+export declare const SuggestedActions: FC<SuggestedActionsProps>;
+//#endregion
+//#region src/ink/TagColumns.d.ts
+/**
+ * Compute the view-level tag union: the alphabetically sorted set of tag
+ * names across every row's tag counts. A union of a single tag carries no
+ * signal (the whole view is one kind), so it collapses to empty and the
+ * view renders no tag columns at all.
+ *
+ * @public
+ */
+export declare const tagUnion: (rows: ReadonlyArray<Record<string, number> | undefined>) => ReadonlyArray<string>;
+/**
+ * Props for the `TagColumns` component.
+ *
+ * @public
+ */
+interface TagColumnsProps {
+  /** The view-level tag union — every row renders every tag in it. */
+  readonly tags: ReadonlyArray<string>;
+  /** This row's per-tag test counts; tags absent here render a dimmed 0. */
+  readonly counts?: Record<string, number> | undefined;
+}
+/**
+ * Renders one row's fixed-width tag cells for the given tag union.
+ * Renders nothing when the union is empty.
+ *
+ * @public
+ */
+export declare const TagColumns: FC<TagColumnsProps>;
+//#endregion
+//#region src/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
+ */
+export declare const TestRow: FC<TestRowProps>;
+//#endregion
+//#region src/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
+ */
+export declare const TrendLine: FC<TrendLineProps>;
+//#endregion
+export type { CellOptions, CountColumnsProps, CoverageBlockProps, CoverageRenderState, DispatchInputs, FailureRecord, FailureSectionProps, FailuresSectionProps, FileCoverageReport, InkCellFn, ModuleHeaderProps, ModuleRecord, ProjectRowProps, ProjectSummary, RenderState, RunOutcome, RunShape, StatusIconKind, StatusIconProps, StreamAppProps, SuggestedActionRecord, SuggestedActionsProps, TagColumnsProps, TestRecord, TestRowProps, TrendLineProps, TrendSummary };
+//# sourceMappingURL=ink.d.ts.map