import { Context, Effect, Layer, PubSub, Schema, Scope, Stream } from "effect";
import { FC, ReactElement } from "react";
//#region ../sdk/dist/dev/pkg/index.d.ts
//#region src/schemas/Coverage.d.ts
/**
 * Aggregate coverage percentages across four istanbul metrics.
 * @public
 */
declare const CoverageTotals: Schema.Struct<{
  readonly statements: Schema.Number;
  readonly branches: Schema.Number;
  readonly functions: Schema.Number;
  readonly lines: Schema.Number;
}>;
/** @public */
type CoverageTotals = typeof CoverageTotals.Type;
/**
 * 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
 */
export 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 */
export 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
 */
export 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 */
export 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
 */
export 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 */
export type FailureRecord = typeof FailureRecord.Type;
/**
 * Coverage block, populated only after `CoverageReady`. Threshold
 * violations are accumulated separately as they arrive.
 * @public
 */
export 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>;
}>;
/** @public */
export type CoverageRenderState = typeof CoverageRenderState.Type;
/**
 * A `SuggestedAction` event, denormalized into the queue the renderer reads.
 * @public
 */
export 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 */
export type SuggestedActionRecord = typeof SuggestedActionRecord.Type;
/**
 * Per-run totals, recomputed on every `ModuleFinished` and reconciled
 * against `RunFinished` (which carries the runner's own count).
 * @public
 */
export declare const RenderTotals: Schema.Struct<{
  readonly passCount: Schema.Number;
  readonly failCount: Schema.Number;
  readonly skipCount: Schema.Number;
  readonly timeoutCount: Schema.Number;
  readonly durationMs: Schema.Number;
}>;
/** @public */
export 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
 */
export 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 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>;
  }>>;
}>;
/** @public */
export 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
 */
export 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 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;
}
/**
 * Complete per-project test report written to disk as JSON.
 * @public
 */
declare const AgentReport: Schema.Struct<{
  readonly timestamp: Schema.String;
  readonly project: Schema.optional<Schema.String>;
  readonly reason: Schema.Literals<readonly ["passed", "failed", "interrupted"]>;
  readonly summary: Schema.Struct<{
    readonly total: Schema.Number;
    readonly passed: Schema.Number;
    readonly failed: Schema.Number;
    readonly skipped: Schema.Number;
    readonly duration: Schema.Number;
    /**
     * Count of every collected module, passing modules included.
     * `AgentReport.failed` only carries failing modules, so a green run
     * has no other way to know how many files actually ran — without
     * this a fully-passing replay reads as "0 modules all-passed"
     * (issue #204). Optional to keep existing fixtures/reports valid.
     */
    readonly modules: Schema.optional<Schema.Number>;
  }>;
  readonly failed: Schema.$Array<Schema.Struct<{
    readonly file: Schema.String;
    readonly state: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
    readonly duration: Schema.optional<Schema.Number>;
    readonly errors: Schema.optional<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>;
    }>>>;
    readonly tests: Schema.$Array<Schema.Struct<{
      readonly name: Schema.String;
      readonly fullName: Schema.String;
      readonly state: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
      readonly duration: Schema.optional<Schema.Number>;
      readonly flaky: Schema.optional<Schema.Boolean>;
      readonly slow: Schema.optional<Schema.Boolean>;
      readonly errors: Schema.optional<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>;
      }>>>;
      readonly classification: Schema.optional<Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
    }>>;
  }>>;
  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>;
  }>>;
  readonly failedFiles: Schema.$Array<Schema.String>;
  readonly coverage: Schema.optional<Schema.Struct<{
    readonly totals: Schema.Struct<{
      readonly statements: Schema.Number;
      readonly branches: Schema.Number;
      readonly functions: Schema.Number;
      readonly lines: Schema.Number;
    }>;
    readonly thresholds: Schema.Struct<{
      readonly global: 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 patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, 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 perFile: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, 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>;
        }>]>>;
      }>]>>, never>;
    }>;
    readonly targets: Schema.optional<Schema.Struct<{
      readonly global: 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 patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, 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 perFile: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, 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>;
        }>]>>;
      }>]>>, never>;
    }>>;
    readonly baselines: Schema.optional<Schema.Struct<{
      readonly global: 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 patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, 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 perFile: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, 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>;
        }>]>>;
      }>]>>, never>;
    }>>;
    readonly scoped: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
    readonly scopedFiles: Schema.optional<Schema.$Array<Schema.String>>;
    readonly totalFiles: Schema.optional<Schema.Number>;
    readonly lowCoverage: Schema.$Array<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;
    }>>;
    readonly lowCoverageFiles: Schema.$Array<Schema.String>;
    readonly belowTarget: Schema.optional<Schema.$Array<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;
    }>>>;
    readonly belowTargetFiles: Schema.optional<Schema.$Array<Schema.String>>;
  }>>;
  readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
    readonly passed: Schema.optional<Schema.Number>;
    readonly failed: Schema.optional<Schema.Number>;
    readonly skipped: Schema.optional<Schema.Number>;
  }>>>;
  readonly consoleLeaks: Schema.optional<Schema.Struct<{
    readonly total: Schema.Number;
    readonly byFile: Schema.$Array<Schema.Struct<{
      readonly file: Schema.String;
      readonly stdout: Schema.Number;
      readonly stderr: Schema.Number;
      readonly tests: Schema.optional<Schema.$Array<Schema.String>>;
      readonly sample: Schema.optional<Schema.String>;
    }>>;
    readonly truncated: Schema.optional<Schema.Boolean>;
    readonly fromFailingTests: Schema.optional<Schema.Struct<{
      readonly total: Schema.Number;
      readonly files: Schema.Number;
    }>>;
  }>>;
}>;
/** @public */
type AgentReport = typeof AgentReport.Type;
/**
 * Classification of a test's failure history across runs.
 * @public
 */
declare const TestClassification: Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>;
/** @public */
type TestClassification = typeof TestClassification.Type;
//#endregion
//#region src/schemas/RunEvent.d.ts
/**
 * Coverage metric whose threshold can be violated independently.
 * @public
 */
export declare const CoverageMetric: Schema.Literals<readonly ["lines", "branches", "functions", "statements"]>;
/** @public */
export type CoverageMetric = typeof CoverageMetric.Type;
/**
 * Severity tier for a suggested action emitted during a run.
 * @public
 */
export declare const ActionSeverity: Schema.Literals<readonly ["info", "warn", "blocker"]>;
/** @public */
export type ActionSeverity = typeof ActionSeverity.Type;
/**
 * A coverage gap surfaced to the renderer — a per-file shortfall that
 * a renderer may want to call out individually.
 * @public
 */
export declare const CoverageGap: 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>;
}>;
/** @public */
export 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
 */
export declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted", {
  readonly runId: Schema.String;
  readonly startedAt: Schema.String;
  readonly configHash: Schema.String;
}>, Schema.TaggedStruct<"ModuleQueued", {
  readonly modulePath: Schema.String;
  readonly projectName: Schema.optional<Schema.String>;
}>, Schema.TaggedStruct<"ModuleStarted", {
  readonly modulePath: Schema.String;
  readonly startedAt: Schema.String;
  readonly projectName: Schema.optional<Schema.String>;
}>, Schema.TaggedStruct<"TestStarted", {
  readonly modulePath: Schema.String;
  readonly testName: Schema.String;
  readonly suitePath: Schema.$Array<Schema.String>;
}>, Schema.TaggedStruct<"TestFinished", {
  readonly modulePath: Schema.String;
  readonly testName: Schema.String;
  readonly suitePath: Schema.$Array<Schema.String>;
  readonly status: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
  readonly durationMs: 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>;
  }>>;
  readonly timedOut: Schema.optional<Schema.Boolean>;
}>, Schema.TaggedStruct<"ModuleFinished", {
  readonly modulePath: Schema.String;
  readonly passCount: Schema.Number;
  readonly failCount: Schema.Number;
  readonly skipCount: Schema.Number;
  readonly durationMs: Schema.Number;
  readonly projectName: Schema.optional<Schema.String>;
  readonly timeoutCount: Schema.optional<Schema.Number>;
  readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
}>, Schema.TaggedStruct<"ModuleCollected", {
  readonly modulePath: Schema.String;
  readonly testCount: Schema.Number;
  readonly suiteCount: Schema.Number;
}>, Schema.TaggedStruct<"SuiteStarted", {
  readonly modulePath: Schema.String;
  readonly suitePath: Schema.$Array<Schema.String>;
  readonly suiteName: Schema.String;
}>, Schema.TaggedStruct<"SuiteFinished", {
  readonly modulePath: Schema.String;
  readonly suitePath: Schema.$Array<Schema.String>;
  readonly suiteName: Schema.String;
  readonly passCount: Schema.Number;
  readonly failCount: Schema.Number;
  readonly skipCount: Schema.Number;
}>, Schema.TaggedStruct<"HookStarted", {
  readonly modulePath: Schema.String;
  readonly hookType: Schema.Literals<readonly ["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
  readonly scopeName: Schema.String;
}>, Schema.TaggedStruct<"HookFinished", {
  readonly modulePath: Schema.String;
  readonly hookType: Schema.Literals<readonly ["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
  readonly scopeName: Schema.String;
  readonly durationMs: Schema.Number;
  readonly status: Schema.Literals<readonly ["passed", "failed"]>;
  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>;
  }>>;
}>, Schema.TaggedStruct<"ConsoleLog", {
  readonly modulePath: Schema.optional<Schema.String>;
  readonly testName: Schema.optional<Schema.String>;
  readonly level: Schema.Literals<readonly ["stdout", "stderr"]>;
  readonly content: Schema.String;
  readonly time: Schema.Number;
}>, Schema.TaggedStruct<"RunTimedOut", {
  readonly message: Schema.String;
}>, Schema.TaggedStruct<"TestAnnotated", {
  readonly modulePath: Schema.String;
  readonly testName: Schema.String;
  readonly suitePath: Schema.$Array<Schema.String>;
  readonly annotation: Schema.String;
  readonly annotationType: Schema.String;
  readonly location: Schema.optional<Schema.Struct<{
    readonly file: Schema.String;
    readonly line: Schema.Number;
    readonly column: Schema.Number;
  }>>;
  readonly attachments: Schema.$Array<Schema.Struct<{
    readonly contentType: Schema.optional<Schema.String>;
    readonly path: Schema.optional<Schema.String>;
    readonly body: Schema.optional<Schema.String>;
    readonly bodyEncoding: Schema.optional<Schema.Literals<readonly ["base64", "utf-8"]>>;
    readonly byteSize: Schema.Number;
  }>>;
}>, Schema.TaggedStruct<"TestArtifactRecorded", {
  readonly modulePath: Schema.String;
  readonly testName: Schema.String;
  readonly suitePath: Schema.$Array<Schema.String>;
  readonly artifact: Schema.String;
  readonly location: Schema.optional<Schema.Struct<{
    readonly file: Schema.String;
    readonly line: Schema.Number;
    readonly column: Schema.Number;
  }>>;
  readonly attachments: Schema.$Array<Schema.Struct<{
    readonly contentType: Schema.optional<Schema.String>;
    readonly path: Schema.optional<Schema.String>;
    readonly body: Schema.optional<Schema.String>;
    readonly bodyEncoding: Schema.optional<Schema.Literals<readonly ["base64", "utf-8"]>>;
    readonly byteSize: Schema.Number;
  }>>;
}>, Schema.TaggedStruct<"WatcherReady", {}>, Schema.TaggedStruct<"WatcherRerun", {
  readonly triggerFiles: Schema.$Array<Schema.String>;
  readonly reason: Schema.optional<Schema.String>;
}>, Schema.TaggedStruct<"TrendComputed", {
  readonly direction: Schema.Literals<readonly ["improving", "regressing", "stable"]>;
  readonly runCount: Schema.Number;
}>, Schema.TaggedStruct<"CoverageReady", {
  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 scoped: Schema.optional<Schema.Boolean>;
  readonly scopedFiles: Schema.optional<Schema.Number>;
  readonly totalFiles: Schema.optional<Schema.Number>;
}>, Schema.TaggedStruct<"ThresholdViolation", {
  readonly metric: Schema.Literals<readonly ["lines", "branches", "functions", "statements"]>;
  readonly expected: Schema.Number;
  readonly actual: Schema.Number;
}>, Schema.TaggedStruct<"FailureClassified", {
  readonly modulePath: Schema.String;
  readonly testName: Schema.String;
  readonly classification: Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>;
}>, Schema.TaggedStruct<"SuggestedAction", {
  readonly severity: Schema.Literals<readonly ["info", "warn", "blocker"]>;
  readonly title: Schema.String;
  readonly detail: Schema.String;
  readonly targetTool: Schema.optional<Schema.String>;
}>, Schema.TaggedStruct<"RunFinished", {
  readonly runId: Schema.String;
  readonly finishedAt: Schema.String;
  readonly passCount: Schema.Number;
  readonly failCount: Schema.Number;
  readonly skipCount: Schema.Number;
  readonly durationMs: Schema.Number;
  readonly timeoutCount: Schema.optional<Schema.Number>;
  /**
   * Count of every collected module, passing modules included.
   * Carries `AgentReport.summary.modules` (or the live module
   * count) into the event stream so the reducer can fold the
   * true count into `RenderState` even when `moduleOrder` only
   * tracks failing modules (report replay). See issue #204.
   */
  readonly collectedModules: Schema.optional<Schema.Number>;
  /**
   * Process-level errors with no owning module (an unhandled
   * rejection, a worker crash) — Vitest's `unhandledErrors`
   * argument to `onTestRunEnd`. Optional so hand-built fixtures
   * and older replay data keep decoding. See issue #240.
   */
  readonly unhandledErrors: Schema.optional<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>;
  }>>>;
}>]>;
/** @public */
export 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<{
  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 MetricThresholds = typeof MetricThresholds.Type;
//#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;
  };
  /**
   * Errors attached to the suite entity itself — a `beforeAll`/`afterAll`
   * hook throw lands here, not on any individual `TestCase`. Optional
   * because older duck-typed callers may not supply it.
   */
  errors?(): Array<VitestModuleError>;
}
/**
 * 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>;
}
//#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
 */
export declare const classifyRunShape: (state: RenderState, projects: ReadonlyArray<ProjectSummary>) => RunShape;
/**
 * Compute the outcome class from the reduced state.
 *
 * Precedence: failures win over timeouts, and both 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. A
 * run whose only non-passing signal is one or more timed-out tests
 * (`totals.timeoutCount > 0`, `totals.failCount === 0`) also
 * classifies as `some-fail` — timeouts are not passes, and must not
 * route to a passing cell (issue #224). A run whose only non-passing
 * signal is a process-level unhandled error (a non-empty
 * `unhandledErrors`, all counts otherwise clean) also classifies as `some-fail` —
 * a green-looking count must never hide an unhandled error behind an
 * all-pass cell (issue #240).
 *
 * @param state - the fully-reduced render state
 * @returns the outcome classification
 * @public
 */
export 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
 */
export 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
 */
export 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
 */
export 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
 */
export 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
 */
export 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
 */
export declare const formatDisplayDuration: (ms: number) => string;
//#endregion
//#region src/pubsub/Channel.d.ts
declare const RunEventChannel_base: Context.ServiceClass<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 modulePath: string;
  readonly startedAt: 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: "failed" | "passed" | "pending" | "skipped";
  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 passCount: number;
  readonly failCount: number;
  readonly skipCount: number;
  readonly durationMs: number;
  readonly projectName?: string | undefined;
  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 suiteName: string;
  readonly passCount: number;
  readonly failCount: number;
  readonly skipCount: number;
} | {
  readonly _tag: "HookStarted";
  readonly modulePath: string;
  readonly hookType: "afterAll" | "afterEach" | "beforeAll" | "beforeEach";
  readonly scopeName: string;
} | {
  readonly _tag: "HookFinished";
  readonly modulePath: string;
  readonly hookType: "afterAll" | "afterEach" | "beforeAll" | "beforeEach";
  readonly scopeName: string;
  readonly durationMs: number;
  readonly status: "failed" | "passed";
  readonly error?: {
    readonly message: string;
    readonly stack?: string | undefined;
    readonly diff?: string | undefined;
    readonly expected?: string | undefined;
    readonly received?: string | undefined;
  } | undefined;
} | {
  readonly _tag: "ConsoleLog";
  readonly modulePath?: string | undefined;
  readonly testName?: string | undefined;
  readonly level: "stderr" | "stdout";
  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 annotationType: string;
  readonly location?: {
    readonly file: string;
    readonly line: number;
    readonly column: number;
  } | undefined;
  readonly attachments: readonly {
    readonly contentType?: string | undefined;
    readonly path?: string | undefined;
    readonly body?: string | undefined;
    readonly bodyEncoding?: "base64" | "utf-8" | undefined;
    readonly byteSize: number;
  }[];
} | {
  readonly _tag: "TestArtifactRecorded";
  readonly modulePath: string;
  readonly testName: string;
  readonly suitePath: readonly string[];
  readonly artifact: string;
  readonly location?: {
    readonly file: string;
    readonly line: number;
    readonly column: number;
  } | undefined;
  readonly attachments: readonly {
    readonly contentType?: string | undefined;
    readonly path?: string | undefined;
    readonly body?: string | undefined;
    readonly bodyEncoding?: "base64" | "utf-8" | undefined;
    readonly byteSize: number;
  }[];
} | {
  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 lines?: number | undefined;
    readonly functions?: number | undefined;
    readonly branches?: number | undefined;
    readonly statements?: 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 scoped?: boolean | undefined;
  readonly scopedFiles?: number | undefined;
  readonly totalFiles?: number | undefined;
} | {
  readonly _tag: "ThresholdViolation";
  readonly metric: "branches" | "functions" | "lines" | "statements";
  readonly expected: number;
  readonly actual: number;
} | {
  readonly _tag: "FailureClassified";
  readonly modulePath: string;
  readonly testName: string;
  readonly classification: "flaky" | "new-failure" | "persistent" | "recovered" | "stable";
} | {
  readonly _tag: "SuggestedAction";
  readonly severity: "blocker" | "info" | "warn";
  readonly title: string;
  readonly detail: string;
  readonly targetTool?: string | undefined;
} | {
  readonly _tag: "RunFinished";
  readonly runId: string;
  readonly finishedAt: string;
  readonly passCount: number;
  readonly failCount: number;
  readonly skipCount: number;
  readonly durationMs: number;
  readonly timeoutCount?: number | undefined;
  readonly collectedModules?: number | undefined;
  readonly unhandledErrors?: readonly {
    readonly message: string;
    readonly stack?: string | undefined;
    readonly diff?: string | undefined;
    readonly expected?: string | undefined;
    readonly received?: string | undefined;
  }[] | undefined;
}>>;
/**
 * 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
 */
export 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
 */
export 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
 */
export 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
 */
export 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
 */
export 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
 */
export 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
 */
export declare const renderStateStream: (initial?: RenderState) => Effect.Effect<Stream.Stream<RenderState>, never, RunEventChannel>;
/**
 * 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
 */
export declare const subscribeRaw: () => Effect.Effect<PubSub.Subscription<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
 */
export 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
 */
export 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
 */
export 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;
}
/**
 * Fixed width of the duration cell that follows the count columns on an
 * aggregate row — sized for the formatter's widest common output
 * (`999.9ms`). 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 dimmed; all four columns always appear.
 *
 * @public
 */
export 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
 */
export 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
 */
export 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
 */
export 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
 */
export 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; 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/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
 */
export 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
 */
export 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
 */
export 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
 */
export declare const SPINNER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
/**
 * How long each spinner frame is held, in milliseconds.
 *
 * @public
 */
export 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
 */
export 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
 */
export declare const spinnerFrameForTime: (nowMs: number) => number;
//#endregion
//#region src/render-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/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
 */
export 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
 */
export declare const TrendLine: FC<TrendLineProps>;
//#endregion
//#region src/synthesize.d.ts
/**
 * Synthetic test name used to surface a suite-level (collection/load)
 * failure in the Failures detail. A module that fails to import has no real
 * test case to attach the error to, so the synthesizer emits one failed
 * "test" under this label carrying the module's import error.
 *
 * @public
 */
export declare const SUITE_LOAD_FAILURE_LABEL = "test suite failed to load";
/**
 * 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;
  }>;
  /** Set when this run's coverage was scoped to a subset of test files (issue #160). */
  readonly scoped?: boolean;
  /** Number of test files actually run, when `scoped` is true. */
  readonly scopedFiles?: number;
  /** Total test-file count for the project, when known. */
  readonly totalFiles?: 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
 */
export 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
 */
export 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. Exported for version introspection by downstream tooling.
 *
 * @public
 */
export declare const CURRENT_UI_VERSION: string;
//#endregion
export { type AgentCellFn, type AgentReport, type Cell, type CellOptions, type CountColumnsProps, type CoverageBlockProps, FileCoverageReport as CoverageFile, type CoverageTotals, type DispatchInputs, type FailureSectionProps, type FailuresSectionProps, type InkCellFn, type MetricThresholds, type ModuleHeaderProps, type ProjectRowProps, type ProjectSummary, type RenderAgentOptions, type RunEventByTag, type RunOutcome, type RunShape, type StatusIconKind, type StatusIconProps, type StreamAppProps, type SuggestedActionsProps, type SynthesizeFromAgentReportOptions, type SynthesizeOptions, type SynthesizedCoverage, type TagColumnsProps, type TestClassification, type TestRowProps, type TrendLineProps, type TrendSummary, type VitestModuleDiagnostic, type VitestModuleError, type VitestParsedStack, type VitestTestCase, type VitestTestDiagnostic, type VitestTestError, type VitestTestModule, type VitestTestResult, type VitestTestSuite };
//# sourceMappingURL=index.d.ts.map