@vitest-agent/reporter 1.0.0

package/index.d.ts

@@ -0,0 +1,1010 @@
+import { PubSub, Schema } from "effect";
+//#region ../sdk/dist/dev/pkg/DataReader-2kJ9I9Hh.d.ts
+/**
+ * Per-file coverage data including uncovered line ranges.
+ * @public
+ */
+declare const FileCoverageReport: Schema.Struct<{
+  file: typeof Schema.String;
+  summary: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  uncoveredLines: typeof Schema.String;
+}>;
+/** @public */
+type FileCoverageReport = typeof FileCoverageReport.Type;
+/**
+ * Complete coverage report attached to an AgentReport.
+ * @public
+ */
+/**
+ * Complete per-project test report written to disk as JSON.
+ * @public
+ */
+declare const AgentReport: Schema.Struct<{
+  timestamp: typeof Schema.String;
+  project: Schema.optional<typeof Schema.String>;
+  reason: Schema.Literal<["passed", "failed", "interrupted"]>;
+  summary: Schema.Struct<{
+    total: typeof Schema.Number;
+    passed: typeof Schema.Number;
+    failed: typeof Schema.Number;
+    skipped: typeof Schema.Number;
+    duration: typeof Schema.Number;
+  }>;
+  failed: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+    duration: Schema.optional<typeof Schema.Number>;
+    errors: Schema.optional<Schema.Array$<Schema.Struct<{
+      message: typeof Schema.String;
+      stack: Schema.optional<typeof Schema.String>;
+      diff: Schema.optional<typeof Schema.String>;
+      expected: Schema.optional<typeof Schema.String>;
+      received: Schema.optional<typeof Schema.String>;
+    }>>>;
+    tests: Schema.Array$<Schema.Struct<{
+      name: typeof Schema.String;
+      fullName: typeof Schema.String;
+      state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+      duration: Schema.optional<typeof Schema.Number>;
+      flaky: Schema.optional<typeof Schema.Boolean>;
+      slow: Schema.optional<typeof Schema.Boolean>;
+      errors: Schema.optional<Schema.Array$<Schema.Struct<{
+        message: typeof Schema.String;
+        stack: Schema.optional<typeof Schema.String>;
+        diff: Schema.optional<typeof Schema.String>;
+        expected: Schema.optional<typeof Schema.String>;
+        received: Schema.optional<typeof Schema.String>;
+      }>>>;
+      classification: Schema.optional<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+    }>>;
+  }>>;
+  unhandledErrors: Schema.Array$<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+  failedFiles: Schema.Array$<typeof Schema.String>;
+  coverage: Schema.optional<Schema.Struct<{
+    totals: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    thresholds: Schema.Struct<{
+      global: Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>;
+      patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>>>, {
+        default: () => never[];
+      }>;
+    }>;
+    targets: Schema.optional<Schema.Struct<{
+      global: Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>;
+      patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>>>, {
+        default: () => never[];
+      }>;
+    }>>;
+    baselines: Schema.optional<Schema.Struct<{
+      global: Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>;
+      patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+        lines: Schema.optional<typeof Schema.Number>;
+        functions: Schema.optional<typeof Schema.Number>;
+        branches: Schema.optional<typeof Schema.Number>;
+        statements: Schema.optional<typeof Schema.Number>;
+      }>>>, {
+        default: () => never[];
+      }>;
+    }>>;
+    scoped: Schema.optionalWith<typeof Schema.Boolean, {
+      default: () => false;
+    }>;
+    scopedFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    lowCoverage: Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      summary: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: typeof Schema.String;
+    }>>;
+    lowCoverageFiles: Schema.Array$<typeof Schema.String>;
+    belowTarget: Schema.optional<Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      summary: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: typeof Schema.String;
+    }>>>;
+    belowTargetFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
+  }>>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{
+    passed: Schema.optional<typeof Schema.Number>;
+    failed: Schema.optional<typeof Schema.Number>;
+    skipped: Schema.optional<typeof Schema.Number>;
+  }>>>;
+}>;
+/** @public */
+type AgentReport = typeof AgentReport.Type; //#endregion
+//#region src/schemas/Identity.d.ts
+/**
+ * Canonical UUID for an LLM agent invocation. Generated server-side at
+ * `register_agent` time. Stable across transport reconnects within an
+ * agent's lifetime.
+ * @public
+ */
+//#endregion
+//#region ../sdk/dist/dev/pkg/index.d.ts
+/**
+ * The renderer state. Both the human (Ink) and agent (string)
+ * renderers read this shape; the reducer is the only producer.
+ *
+ * `phase` is the layout discriminator — agent mode emits one final
+ * frame when `phase === "finished"`; human mode redraws at every
+ * state change. `"timed-out"` is a terminal phase like `"finished"`
+ * — the run is over, but it ended because `onProcessTimeout` fired
+ * rather than the suite completing.
+ * @public
+ */
+declare const RenderState: Schema.Struct<{
+  phase: Schema.Literal<["idle", "running", "finished", "timed-out"]>;
+  runId: Schema.NullOr<typeof Schema.String>;
+  configHash: Schema.NullOr<typeof Schema.String>;
+  startedAt: Schema.NullOr<typeof Schema.String>;
+  finishedAt: Schema.NullOr<typeof Schema.String>;
+  modules: Schema.Record$<typeof Schema.String, Schema.Struct<{
+    modulePath: typeof Schema.String;
+    status: Schema.Literal<["queued", "running", "finished"]>;
+    passCount: typeof Schema.Number;
+    failCount: typeof Schema.Number;
+    skipCount: typeof Schema.Number;
+    timeoutCount: typeof Schema.Number;
+    durationMs: typeof Schema.Number;
+    tests: Schema.Array$<Schema.Struct<{
+      testName: typeof Schema.String;
+      suitePath: Schema.Array$<typeof Schema.String>;
+      status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
+      durationMs: Schema.NullOr<typeof Schema.Number>;
+      error: Schema.optional<Schema.Struct<{
+        message: typeof Schema.String;
+        stack: Schema.optional<typeof Schema.String>;
+        diff: Schema.optional<typeof Schema.String>;
+        expected: Schema.optional<typeof Schema.String>;
+        received: Schema.optional<typeof Schema.String>;
+      }>>;
+    }>>;
+    /**
+     * Owning Vitest project name. Optional — events from project-less
+     * configs or older replays leave it `undefined`, which the renderer
+     * treats as a single anonymous project.
+     */
+    projectName: Schema.optional<typeof Schema.String>;
+    /**
+     * ISO wall-clock stamp captured at `onTestModuleStart`. The live
+     * renderer derives a ticking elapsed column from it while the module
+     * runs; once finished it shows `durationMs` instead. Optional — a
+     * module seeded by `ModuleQueued` (or replayed) has no start stamp.
+     */
+    startedAt: Schema.optional<typeof Schema.String>;
+    tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+  }>>;
+  moduleOrder: Schema.Array$<typeof Schema.String>;
+  totals: Schema.Struct<{
+    passCount: typeof Schema.Number;
+    failCount: typeof Schema.Number;
+    skipCount: typeof Schema.Number;
+    timeoutCount: typeof Schema.Number;
+    durationMs: typeof Schema.Number;
+  }>;
+  coverage: Schema.NullOr<Schema.Struct<{
+    metrics: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    thresholds: Schema.Struct<{
+      lines: Schema.optional<typeof Schema.Number>;
+      functions: Schema.optional<typeof Schema.Number>;
+      branches: Schema.optional<typeof Schema.Number>;
+      statements: Schema.optional<typeof Schema.Number>;
+    }>;
+    gaps: Schema.Array$<Schema.Struct<{
+      file: typeof Schema.String;
+      missing: Schema.Struct<{
+        statements: typeof Schema.Number;
+        branches: typeof Schema.Number;
+        functions: typeof Schema.Number;
+        lines: typeof Schema.Number;
+      }>;
+      uncoveredLines: Schema.optional<typeof Schema.String>;
+    }>>;
+    violations: Schema.Array$<Schema.Struct<{
+      metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+      expected: typeof Schema.Number;
+      actual: typeof Schema.Number;
+    }>>;
+  }>>;
+  trend: Schema.NullOr<Schema.Struct<{
+    direction: Schema.Literal<["improving", "regressing", "stable"]>;
+    runCount: typeof Schema.Number;
+  }>>;
+  failures: Schema.Array$<Schema.Struct<{
+    modulePath: typeof Schema.String;
+    testName: typeof Schema.String;
+    suitePath: Schema.Array$<typeof Schema.String>;
+    error: Schema.optional<Schema.Struct<{
+      message: typeof Schema.String;
+      stack: Schema.optional<typeof Schema.String>;
+      diff: Schema.optional<typeof Schema.String>;
+      expected: Schema.optional<typeof Schema.String>;
+      received: Schema.optional<typeof Schema.String>;
+    }>>;
+    timedOut: Schema.optional<typeof Schema.Boolean>;
+    classification: Schema.NullOr<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
+  }>>;
+  suggestedActions: Schema.Array$<Schema.Struct<{
+    severity: Schema.Literal<["info", "warn", "blocker"]>;
+    title: typeof Schema.String;
+    detail: typeof Schema.String;
+    targetTool: Schema.optional<typeof Schema.String>;
+  }>>;
+}>;
+/** @public */
+type RenderState = typeof RenderState.Type;
+/**
+ * Initial state — what the reducer returns when no events have been
+ * applied yet. Exported so tests and the renderers' bootstrapping
+ * code share one definition.
+ * @public
+ */
+//#endregion
+//#region src/contracts/dispatcher.d.ts
+/**
+ * The four run shapes the dispatcher distinguishes.
+ *
+ * Computed once per run from the reduced state's module count, the
+ * distinct-project count (carried via {@link DispatchInputs.projects}),
+ * and the test count inside each module.
+ *
+ * - `single-test`    — exactly one test by name across the run.
+ * - `single-file`    — exactly one module, more than one test.
+ * - `single-project` — one project, more than one module.
+ * - `workspace`      — more than one project.
+ * @public
+ */
+type RunShape = "single-test" | "single-file" | "single-project" | "workspace";
+/**
+ * The three outcome classes the dispatcher distinguishes.
+ *
+ * - `all-pass`             — `totals.failed === 0` and no coverage threshold violations.
+ * - `some-fail`            — `totals.failed > 0`.
+ * - `threshold-violation`  — `totals.failed === 0` and at least one coverage violation.
+ * @public
+ */
+type RunOutcome = "all-pass" | "some-fail" | "threshold-violation";
+/**
+ * Compact per-project aggregate carried into workspace cells.
+ *
+ * Populated by the plugin from `ReporterRenderInput.reports`. Empty for
+ * non-workspace shapes. `tagCounts`, `belowTarget`, and `violations` are
+ * optional — workspace cells render the columns only when present.
+ * @public
+ */
+interface ProjectSummary {
+  readonly name: string;
+  readonly passCount: number;
+  readonly failCount: number;
+  readonly skipCount: number;
+  readonly durationMs: number;
+  readonly tagCounts?: Record<string, number>;
+  readonly belowTarget?: number;
+  readonly violations?: number;
+}
+/**
+ * Per-run trend direction handed to cells that surface a `Trend: …` line.
+ *
+ * Mirrors the inline `ReporterRenderInput.trendSummary` shape — promoted
+ * to a named type here so the dispatcher and its cells can pass it around
+ * without re-declaring it. The plugin populates this from
+ * `ReporterRenderInput.trendSummary` before invoking `dispatch`.
+ * @public
+ */
+interface TrendSummary {
+  readonly direction: "improving" | "regressing" | "stable";
+  readonly runCount: number;
+  readonly firstMetric?: {
+    readonly name: string;
+    readonly from: number;
+    readonly to: number;
+    readonly target?: number;
+  };
+}
+/**
+ * Inputs each cell renderer reads to produce its output.
+ *
+ * `state` carries the post-reduce projection of the `RunEvent`
+ * stream. `shape` and `outcome` are the classified axes the dispatcher
+ * keyed on to reach this cell. The remaining fields are non-state
+ * helpers the plugin computes once before dispatch so cells stay pure.
+ * @public
+ */
+interface DispatchInputs {
+  readonly state: RenderState;
+  readonly shape: RunShape;
+  readonly outcome: RunOutcome;
+  /**
+   * Per-project aggregates carried into workspace cells. Populated by
+   * the plugin from `ReporterRenderInput.reports`; empty for non-workspace
+   * shapes.
+   */
+  readonly projects: ReadonlyArray<ProjectSummary>;
+  /**
+   * Trend direction for cells that surface a `Trend: …` line. `null`
+   * for scoped runs and any run where trend history is unavailable.
+   */
+  readonly trend: TrendSummary | null;
+  /**
+   * Files below the aspirational `coverageTargets` tier. Workspace and
+   * project cells surface a truncated listing of these; single-file and
+   * single-test cells ignore them.
+   */
+  readonly belowTarget: ReadonlyArray<FileCoverageReport>;
+  /**
+   * Configured run command (e.g. `pnpm test`). Cell footers reference
+   * this so copy-pasted commands stay accurate. `null` when no command
+   * was configured.
+   */
+  readonly runCommand: string | null;
+}
+/**
+ * Render-time options threaded into each cell from the resolved
+ * `ReporterKit`. These are concerns the cell needs to format its
+ * output but that do not belong on the state-derived
+ * {@link DispatchInputs} struct.
+ *
+ * The plugin builds this once per run from the kit and passes it into
+ * `dispatch(inputs, opts)`. Cells destructure only what they consume.
+ * @public
+ */
+interface CellOptions {
+  /**
+   * Resolved value of the `NO_COLOR` env var. Cells gate ANSI escape
+   * sequences and OSC-8 hyperlinks on this.
+   */
+  readonly noColor: boolean;
+  /**
+   * Pre-bound OSC-8 hyperlink helper. The plugin has already decided
+   * whether OSC-8 should be enabled (`target=stdout`, `!noColor`) so
+   * cells can call this directly without re-consulting the environment.
+   */
+  readonly osc8: (url: string, label: string) => string;
+} //#endregion
+//#region src/schemas/Common.d.ts
+/**
+ * Possible states for an individual test case.
+ * @public
+ */
+/**
+ * Classification of a test's failure history across runs.
+ * @public
+ */
+declare const TestClassification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
+/** @public */
+type TestClassification = typeof TestClassification.Type;
+/**
+ * Console output verbosity mode for AgentReporter.
+ * @public
+ */
+/**
+ * Union of every legal console-output value across the three executor slots.
+ * Useful for type-narrowing in renderers that take the resolved value.
+ * @public
+ */
+declare const ConsoleMode: Schema.Union<[Schema.Literal<["passthrough", "silent", "stream", "agent"]>, Schema.Literal<["passthrough", "silent", "agent"]>, Schema.Literal<["passthrough", "silent", "ci-annotations"]>]>;
+/** @public */
+type ConsoleMode = typeof ConsoleMode.Type;
+/**
+ * Supported package managers for run command generation.
+ * @public
+ */
+/**
+ * Runtime environment where tests are being executed.
+ * @public
+ */
+declare const Environment: Schema.Literal<["agent-shell", "terminal", "ci-github", "ci-generic"]>;
+/** @public */
+type Environment = typeof Environment.Type;
+/**
+ * Who or what is executing the test run.
+ * @public
+ */
+declare const Executor: Schema.Literal<["human", "agent", "ci"]>;
+/** @public */
+type Executor = typeof Executor.Type;
+/**
+ * Output format for the reporter pipeline.
+ * @public
+ */
+declare const OutputFormat: Schema.Literal<["terminal", "markdown", "json", "vitest-bypass", "silent", "ci-annotations"]>;
+/** @public */
+type OutputFormat = typeof OutputFormat.Type;
+/**
+ * Level of detail in reporter output.
+ * @public
+ */
+declare const DetailLevel: Schema.Literal<["minimal", "neutral", "standard", "verbose"]>;
+/** @public */
+type DetailLevel = typeof DetailLevel.Type;
+/**
+ * A single test or module error with optional stack trace, diff, and
+ * structured assertion values.
+ *
+ * `expected` / `received` are pre-stringified, one-line representations
+ * of the assertion's expected and received JS values. They are populated
+ * only when the underlying test runner error carries structured `.expected`
+ * / `.actual` properties (assertion errors). The raw JS values stay in
+ * Vitest's internal error object; only the string representation crosses
+ * the schema boundary.
+ * @public
+ */
+//#endregion
+//#region src/formatters/types.d.ts
+/** @public */
+interface RenderedOutput {
+  readonly target: "stdout" | "file" | "github-summary";
+  readonly content: string;
+  readonly contentType: string;
+}
+/** @public */
+/**
+ * The reducer projects this union into `RenderState`. Renderers
+ * never read the raw event stream — they read the projected state.
+ *
+ * @remarks
+ * Adding a variant here is one change in one place; the reducer's
+ * exhaustive `Match.exhaustive` will surface any renderer that hasn't
+ * been updated to consume the new state shape.
+ * @public
+ */
+declare const RunEvent: Schema.Union<[Schema.TaggedStruct<"RunStarted", {
+  runId: typeof Schema.String;
+  startedAt: typeof Schema.String;
+  configHash: typeof Schema.String;
+}>, Schema.TaggedStruct<"ModuleQueued", {
+  modulePath: typeof Schema.String;
+  projectName: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"ModuleStarted", {
+  modulePath: typeof Schema.String;
+  startedAt: typeof Schema.String;
+  projectName: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TestStarted", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TestFinished", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  status: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
+  durationMs: typeof Schema.Number;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+  timedOut: Schema.optional<typeof Schema.Boolean>;
+}>, Schema.TaggedStruct<"ModuleFinished", {
+  modulePath: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  projectName: Schema.optional<typeof Schema.String>;
+  timeoutCount: Schema.optional<typeof Schema.Number>;
+  tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+}>, Schema.TaggedStruct<"ModuleCollected", {
+  modulePath: typeof Schema.String;
+  testCount: typeof Schema.Number;
+  suiteCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"SuiteStarted", {
+  modulePath: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  suiteName: typeof Schema.String;
+}>, Schema.TaggedStruct<"SuiteFinished", {
+  modulePath: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  suiteName: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"HookStarted", {
+  modulePath: typeof Schema.String;
+  hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
+  scopeName: typeof Schema.String;
+}>, Schema.TaggedStruct<"HookFinished", {
+  modulePath: typeof Schema.String;
+  hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
+  scopeName: typeof Schema.String;
+  durationMs: typeof Schema.Number;
+  status: Schema.Literal<["passed", "failed"]>;
+  error: Schema.optional<Schema.Struct<{
+    message: typeof Schema.String;
+    stack: Schema.optional<typeof Schema.String>;
+    diff: Schema.optional<typeof Schema.String>;
+    expected: Schema.optional<typeof Schema.String>;
+    received: Schema.optional<typeof Schema.String>;
+  }>>;
+}>, Schema.TaggedStruct<"ConsoleLog", {
+  modulePath: Schema.optional<typeof Schema.String>;
+  testName: Schema.optional<typeof Schema.String>;
+  level: Schema.Literal<["stdout", "stderr"]>;
+  content: typeof Schema.String;
+  time: typeof Schema.Number;
+}>, Schema.TaggedStruct<"RunTimedOut", {
+  message: typeof Schema.String;
+}>, Schema.TaggedStruct<"TestAnnotated", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  annotation: typeof Schema.String;
+}>, Schema.TaggedStruct<"TestArtifactRecorded", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  suitePath: Schema.Array$<typeof Schema.String>;
+  artifact: typeof Schema.String;
+}>, Schema.TaggedStruct<"WatcherReady", {}>, Schema.TaggedStruct<"WatcherRerun", {
+  triggerFiles: Schema.Array$<typeof Schema.String>;
+  reason: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"TrendComputed", {
+  direction: Schema.Literal<["improving", "regressing", "stable"]>;
+  runCount: typeof Schema.Number;
+}>, Schema.TaggedStruct<"CoverageReady", {
+  metrics: Schema.Struct<{
+    statements: typeof Schema.Number;
+    branches: typeof Schema.Number;
+    functions: typeof Schema.Number;
+    lines: typeof Schema.Number;
+  }>;
+  thresholds: Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>;
+  gaps: Schema.Array$<Schema.Struct<{
+    file: typeof Schema.String;
+    missing: Schema.Struct<{
+      statements: typeof Schema.Number;
+      branches: typeof Schema.Number;
+      functions: typeof Schema.Number;
+      lines: typeof Schema.Number;
+    }>;
+    uncoveredLines: Schema.optional<typeof Schema.String>;
+  }>>;
+}>, Schema.TaggedStruct<"ThresholdViolation", {
+  metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
+  expected: typeof Schema.Number;
+  actual: typeof Schema.Number;
+}>, Schema.TaggedStruct<"FailureClassified", {
+  modulePath: typeof Schema.String;
+  testName: typeof Schema.String;
+  classification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
+}>, Schema.TaggedStruct<"SuggestedAction", {
+  severity: Schema.Literal<["info", "warn", "blocker"]>;
+  title: typeof Schema.String;
+  detail: typeof Schema.String;
+  targetTool: Schema.optional<typeof Schema.String>;
+}>, Schema.TaggedStruct<"RunFinished", {
+  runId: typeof Schema.String;
+  finishedAt: typeof Schema.String;
+  passCount: typeof Schema.Number;
+  failCount: typeof Schema.Number;
+  skipCount: typeof Schema.Number;
+  durationMs: typeof Schema.Number;
+  timeoutCount: Schema.optional<typeof Schema.Number>;
+}>]>;
+/** @public */
+type RunEvent = typeof RunEvent.Type;
+/**
+ * Convenience: discriminator-keyed map of the individual variants.
+ *
+ * Useful for callers that want to construct an event by tag without
+ * pulling the whole union shape into scope.
+ * @public
+ */
+/**
+ * Fully resolved thresholds ready for evaluation.
+ * @public
+ */
+declare const ResolvedThresholds: Schema.Struct<{
+  global: Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>;
+  perFile: Schema.optionalWith<typeof Schema.Boolean, {
+    default: () => false;
+  }>;
+  patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
+    lines: Schema.optional<typeof Schema.Number>;
+    functions: Schema.optional<typeof Schema.Number>;
+    branches: Schema.optional<typeof Schema.Number>;
+    statements: Schema.optional<typeof Schema.Number>;
+  }>>>, {
+    default: () => never[];
+  }>;
+}>;
+/** @public */
+type ResolvedThresholds = typeof ResolvedThresholds.Type; //#endregion
+//#region src/schemas/Transport.d.ts
+/**
+ * Transport binding for the persistence layer.
+ *
+ * 2.x ships only `{ kind: "local" }`. Modeled as a single-member
+ * discriminated union so the 3.0 cloud-backend swap (D1, Turso, etc.)
+ * lands as a pure addition of new union members — no schema-shape
+ * diff and no breaking API change at the call site.
+ * @public
+ */
+declare const Transport: Schema.Struct<{
+  kind: Schema.Literal<["local"]>;
+}>;
+/** @public */
+type Transport = typeof Transport.Type; //#endregion
+//#region src/contracts/reporter.d.ts
+/**
+ * Config the plugin computes from its own options + Vitest's resolved config,
+ * then hands to the reporter factory inside {@link ReporterKit}.
+ *
+ * `dbPath` is optional at the type level so renderers that don't care about
+ * the persistence layer (e.g. a stdout-only renderer) can ignore it. The
+ * plugin always populates it in practice — the option exists for clarity
+ * and to leave room for future "no-persistence" experiments.
+ *
+ * `format` and `detail` are pre-resolved by the plugin (via
+ * `FormatSelector` / `DetailResolver`) but reporters that want to override
+ * can ignore them. `noColor` is the resolved value of the `NO_COLOR` env
+ * var; reporters use it to gate ANSI escapes and OSC-8 hyperlinks.
+ * @public
+ */
+interface ResolvedReporterConfig {
+  readonly dbPath?: string;
+  readonly projectFilter?: string;
+  /**
+   * The executor the plugin detected at run time (`human`, `agent`, `ci`).
+   * Renderers branch on this when their per-mode behavior depends on the
+   * observer (e.g. honoring `NO_COLOR` only when a human is watching).
+   */
+  readonly executor: Executor;
+  /**
+   * The `ConsoleMode` value the plugin selected for the active
+   * executor — the result of looking up `console.{executor}` and falling
+   * back to the per-slot default. Renderers that need to know "what am I
+   * supposed to produce right now?" read this single field.
+   */
+  readonly consoleMode: ConsoleMode;
+  readonly mcp: boolean;
+  readonly consoleOutput: "failures" | "full" | "silent";
+  readonly omitPassingTests: boolean;
+  readonly coverageConsoleLimit: number;
+  readonly includeBareZero: boolean;
+  readonly githubActions: boolean;
+  readonly githubSummary: boolean;
+  readonly githubSummaryFile?: string;
+  readonly coverageThresholds?: ResolvedThresholds;
+  readonly coverageTargets?: ResolvedThresholds;
+  /**
+   * Operating mode resolved from Vitest's native `coverage.enabled` config.
+   * - `"full"` — coverage is enabled; all analytics and persistence run.
+   * - `"ui-only"` — coverage is disabled (`coverage.enabled: false`); reporter
+   *   renders output but the persistence pipeline is skipped (Phase 5).
+   *
+   * The plugin always resolves this field in `configureVitest`.
+   * @internal
+   */
+  readonly coverageMode: "full" | "ui-only";
+  readonly format: OutputFormat;
+  readonly detail: DetailLevel;
+  readonly noColor: boolean;
+  readonly runCommand?: string;
+  /**
+   * Transport binding for the persistence layer. Custom reporters
+   * read this when they want to branch on backend kind (e.g. behave
+   * differently against a cloud DB). 2.x ships only `{ kind: "local" }`.
+   */
+  readonly transport?: Transport;
+  /**
+   * Snapshot of Vitest's `test.passWithNoTests` policy captured from
+   * the resolved config at `configureVitest` time.
+   *
+   * Informational for consumer reporters that want to render the
+   * resolved policy alongside other run context. The MCP `run_tests`
+   * tool does not read this field — when its per-call
+   * `passWithNoTests` override is unset the tool forwards nothing to
+   * `createVitest`, and Vitest re-resolves from the project config on
+   * disk. The `no-match` discriminator is filter-driven and is not
+   * affected by this policy.
+   *
+   * Optional because the field is only present when populated by the
+   * plugin; consumers constructing `ResolvedReporterConfig` directly
+   * may omit it.
+   */
+  readonly passWithNoTests?: boolean;
+}
+/**
+ * Plugin-provided primitives passed to the reporter factory at construction
+ * time. The `std*` prefix marks these as "the plugin gives you these — do
+ * not import equivalents yourself"; they are pre-resolved with full context
+ * (environment, executor, NO_COLOR, target=stdout) so the reporter doesn't
+ * have to re-derive that state.
+ *
+ * The shape is open to additions: future fields (e.g. `stdLogger`,
+ * `stdRuntime`) won't break existing reporters because the parameter is a
+ * named-field object. Reporters destructure only what they consume.
+ * @public
+ */
+interface ReporterKit {
+  readonly config: ResolvedReporterConfig;
+  readonly stdEnv: Environment;
+  /**
+   * Pre-bound OSC-8 hyperlink helper. The plugin has already decided
+   * whether OSC-8 should be enabled (target=stdout, !noColor) so the
+   * reporter can call this directly without consulting environment.
+   */
+  readonly stdOsc8: (url: string, label: string) => string;
+  /**
+   * Live run-event channel. The plugin publishes one `RunEvent`
+   * per Vitest streaming callback (`onTestRunStart`, `onTestModuleStart`,
+   * `onTestCaseResult`, `onTestRunEnd`, …) onto this `PubSub` as the run
+   * progresses. A reporter that paints live — the default reporter's Ink
+   * mount in `consoleMode: "stream"` — subscribes here at construction time
+   * (the factory is invoked at run start, before the first event) and
+   * drives its renderer off the stream.
+   *
+   * Optional at the type level so a reporter constructed directly
+   * without the plugin (tests, one-shot replay) can omit it; a reporter
+   * that wants live events must guard for `undefined`. The plugin always
+   * populates it.
+   */
+  readonly runEvents?: PubSub.PubSub<RunEvent>;
+}
+/**
+ * Per-run data handed to {@link VitestAgentReporter.render} after the plugin
+ * has finished persisting and classifying the run.
+ *
+ * `reports` is one entry per project (multi-project Vitest configs produce
+ * multiple). `classifications` is keyed by `TestReport.fullName` and is the
+ * stable / new-failure / persistent / flaky / recovered label assigned by
+ * `HistoryTracker`. `trendSummary` is present only on full (non-scoped) runs
+ * where coverage trends were computed.
+ * @public
+ */
+interface ReporterRenderInput {
+  readonly reports: ReadonlyArray<AgentReport>;
+  readonly classifications: ReadonlyMap<string, TestClassification>;
+  readonly trendSummary?: {
+    readonly direction: "improving" | "regressing" | "stable";
+    readonly runCount: number;
+    readonly firstMetric?: {
+      readonly name: string;
+      readonly from: number;
+      readonly to: number;
+      readonly target?: number;
+    };
+  };
+}
+/**
+ * The reporter contract. Implement this to plug a custom output strategy
+ * into `vitest-agent`.
+ *
+ * `render` is called once per test run after the plugin has persisted all
+ * data. It receives the assembled run plus a second, health-aware
+ * {@link ReporterKit}: the kit handed to the factory is resolved at run
+ * start (before failures are known), while the kit handed to `render` is
+ * resolved at run end and reflects post-run `detail`. A reporter that does
+ * construction-time work reads the factory kit; a reporter that renders
+ * reads the `render` kit. The reporter returns `RenderedOutput[]` — the
+ * plugin routes each entry to its declared `target` (`stdout`, `file`,
+ * `github-summary`), so the reporter does not need to know about file
+ * paths or write streams.
+ *
+ * A "no-op" reporter is one line: `() => ({ render: () => [] })`. Useful
+ * for users who only want persistence (the MCP/CLI tools see the data) and
+ * no console output at all.
+ * @public
+ */
+interface VitestAgentReporter {
+  readonly render: (input: ReporterRenderInput, kit: ReporterKit) => ReadonlyArray<RenderedOutput>;
+}
+/**
+ * Factory that the plugin's `reporter` option accepts. The plugin calls
+ * this once with the resolved kit; the factory returns either a single
+ * reporter or an array of reporters bound to that kit.
+ *
+ * Returning an array models Vitest's own multi-reporter pattern
+ * (`reporters: ['default', 'github-actions']`): each reporter handles
+ * its own concern (e.g. one for stdout markdown, one for SARIF, one
+ * for the GitHub Actions step summary) and the plugin concatenates
+ * their `RenderedOutput[]` before routing. Persistence still runs
+ * exactly once — the plugin owns the Vitest lifecycle and the
+ * reporters never see Vitest events directly.
+ *
+ * Defaulting to a factory (rather than passing a class or pre-made
+ * instance) gives implementations a place to do construction-time work
+ * (e.g. opening a file handle, capturing config) while still letting
+ * the plugin own the kit assembly.
+ * @public
+ */
+type VitestAgentReporterFactory = (kit: ReporterKit) => VitestAgentReporter | ReadonlyArray<VitestAgentReporter>; //#endregion
+//#region src/errors/DiscoveryError.d.ts
+//#endregion
+//#region src/defaultReporter.d.ts
+/**
+ * Build a `DispatchInputs` from a {@link ReporterRenderInput} and
+ * the reduced `RenderState`.
+ *
+ * Exported so a custom reporter built on the same dispatcher can reuse
+ * this assembly step without rebuilding it from scratch.
+ *
+ * @public
+ */
+declare const buildDispatchInputs: (state: RenderState, input: ReporterRenderInput, overrides?: {
+  readonly shape?: RunShape;
+  readonly outcome?: RunOutcome;
+  readonly runCommand?: string | null;
+}) => DispatchInputs;
+/**
+ * Build `CellOptions` from a {@link ReporterKit}. Picks the kit's
+ * resolved `noColor` value and the pre-bound OSC-8 hyperlink helper.
+ *
+ * @public
+ */
+declare const resolveCellOptions: (kit: ReporterKit) => CellOptions;
+/**
+ * Convenience helper for one-shot consumers (e.g. a CLI command
+ * replaying a stored run). Synthesizes a minimal `ReporterRenderInput`
+ * from a single `AgentReport`, classifies the shape and outcome, and
+ * returns the dispatched agent-string for the matching cell. Equivalent
+ * to the pre-2.0 `renderRun(events, "agent")` shortcut.
+ *
+ * @public
+ */
+declare const renderAgentStringForReport: (report: AgentReport) => string;
+/**
+ * Same as {@link renderAgentStringForReport} but returns the Ink-half
+ * rendered to a string via Ink's `renderToString`. ANSI escape
+ * sequences are preserved so a terminal renders the colors live.
+ * Returns the agent-string fallback when the matched cell has no Ink
+ * half.
+ *
+ * @public
+ */
+declare const renderHumanStringForReport: (report: AgentReport, options?: {
+  readonly width?: number;
+}) => Promise<string>;
+/**
+ * The default reporter factory.
+ *
+ * The plugin uses this as its built-in when no user `reporter` option
+ * is supplied, and a custom-reporter author reads it as the canonical
+ * worked example of the `VitestAgentReporterFactory` contract.
+ *
+ * The factory is invoked once at run start with the run-start kit. In
+ * `consoleMode: "stream"` it subscribes a live Ink mount to the kit's
+ * run-event channel and owns that mount's lifecycle end to end.
+ *
+ * The `render` call (invoked once at run end with the health-aware kit)
+ * assembles the reduced state, classifies the shape and outcome, and
+ * dispatches to the matching cell. Output is one stdout entry carrying
+ * the cell's string. When `kit.config.githubActions` is true a GFM
+ * step-summary payload is appended for routing to GITHUB_STEP_SUMMARY.
+ * In `stream` mode `render` emits nothing — the live mount painted the run.
+ *
+ * @public
+ */
+declare const DefaultVitestAgentReporter: VitestAgentReporterFactory;
+//#endregion
+//#region src/LiveInkRenderer.d.ts
+/**
+ * Options for `createLiveInk`.
+ *
+ * @public
+ */
+interface CreateLiveInkOptions {
+  /**
+   * Override the stream Ink writes to. Defaults to `process.stdout`.
+   * Tests pass a captured Writable here to assert on rendered frames.
+   */
+  readonly stream?: NodeJS.WriteStream;
+}
+/**
+ * Imperative handle returned by `createLiveInk`. Drives a live
+ * Ink mount across the lifetime of a test run, including watch-mode reruns.
+ *
+ * @public
+ */
+interface LiveInkRenderer {
+  /**
+   * Process a `RunEvent`. Mounts the Ink tree and starts the
+   * animation clock on `RunStarted`, rerenders on every event that
+   * mutates state, and unmounts on the terminal event so Ink commits
+   * the final frame to scrollback.
+   */
+  readonly event: (event: RunEvent) => void;
+  /**
+   * Force an immediate unmount and stop the animation clock. Safe to
+   * call multiple times. Useful in tests or when the host needs to
+   * tear down out of band (e.g. a cancellation signal).
+   */
+  readonly unmount: () => void;
+  /**
+   * Latest reduced state. Exposed for hosts that want to assert on the
+   * accumulated value at any point during the run.
+   */
+  readonly snapshot: () => RenderState;
+}
+/**
+ * Create a {@link LiveInkRenderer} that drives a live Ink mount for
+ * `consoleMode: "stream"`. Call `event(e)` for each `RunEvent` published
+ * by the plugin; the renderer mounts on `RunStarted`, rerenders on each
+ * subsequent event, and commits the final frame on `RunFinished` /
+ * `RunTimedOut`.
+ *
+ * @public
+ */
+declare const createLiveInk: (options?: CreateLiveInkOptions) => LiveInkRenderer;
+//#endregion
+//#region src/index.d.ts
+/**
+ * The version of this package, inlined at build time from
+ * package.json#version via rslib-builder's __PACKAGE_VERSION__ substitution.
+ * The reporter is consumed through the plugin so it does not run its own
+ * init-time drift check, but the constant is exported so the plugin can
+ * compare against it. See the root CLAUDE.md "Cross-package version drift"
+ * section.
+ *
+ * @public
+ */
+declare const CURRENT_REPORTER_VERSION: string;
+//#endregion
+export { type AgentReport, CURRENT_REPORTER_VERSION, type CellOptions, type ConsoleMode, type CreateLiveInkOptions, DefaultVitestAgentReporter, type DetailLevel, type DispatchInputs, type Environment, type Executor, type FileCoverageReport, type LiveInkRenderer, type OutputFormat, type ProjectSummary, type RenderState, type RenderedOutput, type ReporterKit, type ReporterRenderInput, type ResolvedReporterConfig, type ResolvedThresholds, type RunEvent, type RunOutcome, type RunShape, type TestClassification, type Transport, type TrendSummary, type VitestAgentReporter, type VitestAgentReporterFactory, createLiveInk as _createLiveInk, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions };
+//# sourceMappingURL=index.d.ts.map