@vitest-agent/reporter 3.1.3 → 4.0.0

package/defaultReporter.js

@@ -1,8 +1,11 @@
 import { renderGithubLog, toDisplayPath } from "./githubLog.js";
-import { createLiveInk } from "./LiveInkRenderer.js";
+import { LiveViewEnv, startLiveView } from "./liveView.js";
+import { Doc, Render, Status } from "@effected/cli";
+import { CliUi, UiProvider } from "@effected/cli/ui";
 import { RUN_REPORT_FILE_SCHEMA_URL, countSuiteFailures, isTimeoutError } from "@vitest-agent/sdk";
 import { classifyOutcome, classifyRunShape, dispatch, dispatcherTable, reduceRenderStateAll, synthesizeFromAgentReport } from "@vitest-agent/ui";
-import { Effect, PubSub } from "effect";
+import { Effect } from "effect";
+import { createElement } from "react";
 
 //#region src/defaultReporter.ts
 const countTimeouts = (report) => {
@@ -118,8 +121,10 @@ const renderAgentStringForReport = (report) => {
 };
 /**
 * 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.
+* rendered to a string via Ink's `renderToString`, inside the kit's
+* `UiProvider` (the components draw the terminal's glyph set, ASCII under
+* `TERM=dumb`). 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.
 *
@@ -145,7 +150,9 @@ const renderHumanStringForReport = async (report, options = {}) => {
 	};
 	const cell = dispatcherTable[inputs.shape][inputs.outcome];
 	if (cell.ink === void 0) return dispatch(inputs, opts);
-	return renderToString(cell.ink(inputs, opts), { columns: options.width ?? 80 });
+	const columns = options.width ?? 80;
+	const context = await Effect.runPromise(CliUi.context.pipe(Effect.provide(LiveViewEnv)));
+	return renderToString(createElement(UiProvider, { value: context }, cell.ink(inputs, opts)), { columns });
 };
 const NON_STABLE_SUMMARY_CLASSIFICATIONS = [
 	"new-failure",
@@ -154,52 +161,51 @@ const NON_STABLE_SUMMARY_CLASSIFICATIONS = [
 	"recovered"
 ];
 const MAX_SUMMARY_COVERAGE_ROWS = 10;
+/**
+* The step summary and `summary.md` are files, not log lines, so their
+* markdown context opts out of the `ci` default that neutralizes workflow
+* commands.
+*/
+const summaryRenderContext = Render.contextOf({
+	audience: "ci",
+	displayPath: toDisplayPath,
+	neutralizeWorkflowCommands: false
+});
 const renderClassificationsSection = (classifications) => {
 	const counts = /* @__PURE__ */ new Map();
 	for (const classification of classifications.values()) counts.set(classification, (counts.get(classification) ?? 0) + 1);
-	const rows = NON_STABLE_SUMMARY_CLASSIFICATIONS.filter((kind) => (counts.get(kind) ?? 0) > 0).map((kind) => `| ${kind} | ${counts.get(kind)} |`);
+	const rows = NON_STABLE_SUMMARY_CLASSIFICATIONS.filter((kind) => (counts.get(kind) ?? 0) > 0).map((kind) => [kind, String(counts.get(kind))]);
 	if (rows.length === 0) return null;
-	return [
-		"### Classifications",
-		"",
-		"| Classification | Count |",
-		"| --- | --- |",
-		...rows
-	].join("\n");
+	return Render.markdown([Doc.heading(3, "Classifications"), Doc.table([{ header: "Classification" }, { header: "Count" }], rows)], summaryRenderContext);
 };
 const formatCoveragePercent = (totals) => `stmts ${totals.statements}%, branches ${totals.branches}%, funcs ${totals.functions}%, lines ${totals.lines}%`;
 const renderCoverageSection = (reports) => {
 	const belowTarget = reports.flatMap((r) => r.coverage?.belowTarget ?? []);
 	if (belowTarget.length === 0) return null;
-	const rows = belowTarget.slice(0, MAX_SUMMARY_COVERAGE_ROWS).map((f) => `| ${toDisplayPath(f.file)} | ${formatCoveragePercent(f.summary)} |`);
-	const lines = [
-		"### Coverage",
-		"",
-		`${belowTarget.length} file(s) below target.`,
-		"",
-		"| File | Coverage |",
-		"| --- | --- |",
-		...rows
-	];
-	if (belowTarget.length > MAX_SUMMARY_COVERAGE_ROWS) lines.push("", `(+${belowTarget.length - MAX_SUMMARY_COVERAGE_ROWS} more not shown)`);
-	return lines.join("\n");
+	const rows = belowTarget.map((f) => [Doc.file(f.file), formatCoveragePercent(f.summary)]);
+	return Render.markdown([
+		Doc.heading(3, "Coverage"),
+		Doc.paragraph(`${belowTarget.length} file(s) below target.`),
+		Doc.table([{ header: "File" }, { header: "Coverage" }], rows, {
+			cap: MAX_SUMMARY_COVERAGE_ROWS,
+			overflow: (hidden) => `(+${hidden} more not shown)`
+		})
+	], summaryRenderContext);
 };
+/**
+* The trend as one line per fact. `Doc.lines` joins them with GFM hard breaks
+* (a trailing `\\`), so a GFM reader cannot collapse them into one paragraph.
+*/
 const renderTrendSection = (trendSummary) => {
 	if (trendSummary === void 0) return null;
-	const lines = [
-		"### Trend",
-		"",
-		`Direction: ${trendSummary.direction}`,
-		`Run count: ${trendSummary.runCount}`
-	];
+	const lines = [`Direction: ${trendSummary.direction}`, `Run count: ${trendSummary.runCount}`];
 	const firstMetric = trendSummary.firstMetric;
 	if (firstMetric !== void 0) {
 		const targetSuffix = firstMetric.target !== void 0 ? ` (target: ${firstMetric.target})` : "";
 		lines.push(`${firstMetric.name}: ${firstMetric.from} → ${firstMetric.to}${targetSuffix}`);
 	}
-	return lines.join("\n");
+	return Render.markdown([Doc.heading(3, "Trend"), Doc.lines(lines)], summaryRenderContext);
 };
-const formatSummaryDuration = (ms) => ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${Math.round(ms)}ms`;
 /**
 * Per-project pass/fail/timeout/skip/duration table — the unconditional
 * half of the summary body.
@@ -219,35 +225,36 @@ const formatSummaryDuration = (ms) => ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` :
 * would show a timed-out test as `Failed: 1` while every console surface
 * says `0 failed, 1 timed out`.
 *
+* A plain `Doc.table`, not `Doc.countsTable`: the counts table heads its
+* label column with nothing (this one reads `Project`) and has no column for
+* a formatted, non-count cell like the duration.
+*
 * @internal
 */
 const renderTotalsSection = (reports) => {
 	const rows = reports.map((report) => summarizeProject(report));
-	const cells = (name, passed, failed, timedOut, skipped, duration) => `| ${name} | ${passed} | ${failed} | ${timedOut} | ${skipped} | ${formatSummaryDuration(duration)} |`;
-	const lines = [
-		"### Totals",
-		"",
-		"| Project | Passed | Failed | Timed out | Skipped | Duration |",
-		"| --- | --- | --- | --- | --- | --- |",
-		...rows.map((r) => cells(r.name, r.passCount, r.failCount, r.timeoutCount ?? 0, r.skipCount, r.durationMs))
-	];
-	if (rows.length > 1) {
-		const total = rows.reduce((acc, r) => ({
-			passed: acc.passed + r.passCount,
-			failed: acc.failed + r.failCount,
-			timedOut: acc.timedOut + (r.timeoutCount ?? 0),
-			skipped: acc.skipped + r.skipCount,
-			duration: acc.duration + r.durationMs
-		}), {
-			passed: 0,
-			failed: 0,
-			timedOut: 0,
-			skipped: 0,
-			duration: 0
-		});
-		lines.push(cells("**Total**", total.passed, total.failed, total.timedOut, total.skipped, total.duration));
-	}
-	return lines.join("\n");
+	const counter = (status, key, label, n) => Doc.counter(Status.core, status, {
+		key,
+		label,
+		n,
+		showZero: true
+	});
+	const tableRows = rows.map((r) => ({
+		label: r.name,
+		counters: [
+			counter("success", "passed", "Passed", r.passCount),
+			counter("failure", "failed", "Failed", r.failCount),
+			counter("warning", "timedOut", "Timed out", r.timeoutCount ?? 0),
+			counter("skip", "skipped", "Skipped", r.skipCount)
+		],
+		durationMs: r.durationMs
+	}));
+	const table = Doc.countsTable(tableRows, {
+		labelHeader: "Project",
+		durationHeader: "Duration",
+		...rows.length > 1 ? { totalRow: Doc.strong("Total") } : {}
+	});
+	return Render.markdown([Doc.heading(3, "Totals"), table], summaryRenderContext);
 };
 /**
 * Assemble the vitest-agent markdown body shared by the GitHub step
@@ -296,29 +303,6 @@ const renderGithubSummary = (input) => {
 	}];
 };
 /**
-* Subscribe a live Ink mount to the kit's run-event channel.
-*
-* Called from the factory when `consoleMode` is `stream`. The factory runs
-* at run start — before the plugin publishes the first `RunStarted`
-* event — so the subscription is registered in time. `Effect.runFork`
-* advances the forked fiber up to its first suspension (the
-* `PubSub.take` below); that suspension point is past `PubSub.subscribe`,
-* so the subscription is live before this function returns. The drain
-* loop runs forever: `createLiveInk` handles `RunFinished` (schedules
-* unmount) and a subsequent `RunStarted` (remounts) itself, so the loop
-* stays open across watch-mode reruns and ends only when the process
-* exits.
-*
-* @internal
-*/
-const subscribeLiveInk = (channel) => {
-	const live = createLiveInk();
-	Effect.runFork(Effect.scoped(Effect.gen(function* () {
-		const subscription = yield* PubSub.subscribe(channel);
-		yield* Effect.forever(PubSub.take(subscription).pipe(Effect.flatMap((event) => Effect.sync(() => live.event(event)))));
-	})));
-};
-/**
 * The default reporter factory.
 *
 * The plugin uses this as its built-in when no user `reporter` option
@@ -326,8 +310,12 @@ const subscribeLiveInk = (channel) => {
 * 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.
+* `consoleMode: "stream"` it starts a live view on the kit's run-event
+* channel (subscribed before the factory returns, so the first
+* `RunStarted` is seen) and owns it for the reporter's life: the
+* reporter's `close`, which the plugin calls at Vitest's close before
+* shutting the channel down, drains the queued events, waits for the last
+* frame and closes it.
 *
 * The `render` call (invoked once at run end with the health-aware kit)
 * assembles the reduced state, classifies the shape and outcome, and
@@ -339,44 +327,47 @@ const subscribeLiveInk = (channel) => {
 * @public
 */
 const DefaultVitestAgentReporter = (kit) => {
-	if (kit.config.consoleMode === "stream" && kit.runEvents !== void 0) subscribeLiveInk(kit.runEvents);
-	return { render(input, renderKit) {
-		const out = [];
-		if (shouldRenderForMode(renderKit.config.consoleMode)) {
-			const events = input.reports.flatMap((r) => synthesizeFromAgentReport(r));
-			const state = reduceRenderStateAll(events);
-			const inputs = buildDispatchInputs(state, input, { runCommand: renderKit.config.runCommand ?? null });
-			const opts = resolveCellOptions(renderKit);
-			const content = dispatch(inputs, opts);
-			if (content.length > 0) out.push({
-				target: "stdout",
-				content,
-				contentType: "text/plain"
+	const live = kit.config.consoleMode === "stream" && kit.runEvents !== void 0 ? startLiveView(kit.runEvents) : void 0;
+	return {
+		...live !== void 0 ? { close: live.close } : {},
+		render(input, renderKit) {
+			const out = [];
+			if (shouldRenderForMode(renderKit.config.consoleMode)) {
+				const events = input.reports.flatMap((r) => synthesizeFromAgentReport(r));
+				const state = reduceRenderStateAll(events);
+				const inputs = buildDispatchInputs(state, input, { runCommand: renderKit.config.runCommand ?? null });
+				const opts = resolveCellOptions(renderKit);
+				const content = dispatch(inputs, opts);
+				if (content.length > 0) out.push({
+					target: "stdout",
+					content,
+					contentType: "text/plain"
+				});
+			}
+			if (renderKit.config.githubActions === true) {
+				out.push(...renderGithubSummary(input));
+				out.push(renderGithubLog(input, renderKit));
+			}
+			out.push({
+				target: "report",
+				filename: "run.json",
+				contentType: "application/json",
+				content: `${JSON.stringify({
+					$schema: RUN_REPORT_FILE_SCHEMA_URL,
+					schemaVersion: 1,
+					generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					reports: input.reports
+				}, null, 2)}\n`
 			});
+			out.push({
+				target: "report",
+				filename: "summary.md",
+				contentType: "text/markdown",
+				content: `${buildSummaryMarkdown(input)}\n`
+			});
+			return out;
 		}
-		if (renderKit.config.githubActions === true) {
-			out.push(...renderGithubSummary(input));
-			out.push(renderGithubLog(input, renderKit));
-		}
-		out.push({
-			target: "report",
-			filename: "run.json",
-			contentType: "application/json",
-			content: `${JSON.stringify({
-				$schema: RUN_REPORT_FILE_SCHEMA_URL,
-				schemaVersion: 1,
-				generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				reports: input.reports
-			}, null, 2)}\n`
-		});
-		out.push({
-			target: "report",
-			filename: "summary.md",
-			contentType: "text/markdown",
-			content: `${buildSummaryMarkdown(input)}\n`
-		});
-		return out;
-	} };
+	};
 };
 
 //#endregion

package/githubLog.js

@@ -1,3 +1,4 @@
+import { Doc, Render, Status } from "@effected/cli";
 import { relative } from "node:path";
 
 //#region src/githubLog.ts
@@ -12,6 +13,14 @@ import { relative } from "node:path";
 * fields already on `ReporterRenderInput` / `ReporterKit` — no new
 * plumbing. No ANSI escapes: GitHub renders raw log text.
 *
+* Built as an `@effected/cli` `Doc` (a top-level collapsible is a
+* `::group::`) and rendered with `Render.githubLog`, which also neutralizes
+* any workflow command a project name or path could otherwise inject.
+*
+* Known inconsistency, kept deliberately for now: the per-project line counts
+* a timed-out test as `failed` (it reads `report.summary.failed`), while the
+* step-summary totals table splits timeouts into their own column.
+*
 * @internal
 */
 const MAX_NAMED_FILES = 3;
@@ -32,27 +41,55 @@ const NON_STABLE_CLASSIFICATIONS = [
 	"flaky",
 	"recovered"
 ];
+/** `<project>: <passed>/<total> passed, <failed> failed, <skipped> skipped` — every counter shown, zeros included. */
+const projectCounts = (report) => {
+	const { passed, failed, skipped, total } = report.summary;
+	return Doc.counts({
+		label: report.project ?? "default",
+		layout: "inline",
+		total: () => total,
+		counters: [
+			Doc.counter(Status.core, "success", {
+				key: "passed",
+				label: "passed",
+				n: passed,
+				showZero: true
+			}),
+			Doc.counter(Status.core, "failure", {
+				key: "failed",
+				label: "failed",
+				n: failed,
+				showZero: true
+			}),
+			Doc.counter(Status.core, "skip", {
+				key: "skipped",
+				label: "skipped",
+				n: skipped,
+				showZero: true
+			})
+		]
+	});
+};
 function renderGithubLog(input, kit) {
-	const lines = ["::group::vitest-agent"];
-	for (const report of input.reports) {
-		const name = report.project ?? "default";
-		lines.push(`${name}: ${report.summary.passed}/${report.summary.total} passed, ${report.summary.failed} failed, ${report.summary.skipped} skipped`);
-	}
+	const body = input.reports.map(projectCounts);
 	const belowTarget = input.reports.flatMap((r) => r.coverage?.belowTarget ?? []);
 	if (belowTarget.length > 0) {
 		const names = belowTarget.slice(0, MAX_NAMED_FILES).map((f) => toDisplayPath(f.file));
 		const suffix = belowTarget.length > MAX_NAMED_FILES ? `, +${belowTarget.length - MAX_NAMED_FILES} more` : "";
-		lines.push(`coverage: ${belowTarget.length} file(s) below target (${names.join(", ")}${suffix})`);
+		body.push(Doc.paragraph(`coverage: ${belowTarget.length} file(s) below target (${names.join(", ")}${suffix})`));
 	}
 	const classificationCounts = /* @__PURE__ */ new Map();
 	for (const classification of input.classifications.values()) classificationCounts.set(classification, (classificationCounts.get(classification) ?? 0) + 1);
 	const classificationParts = NON_STABLE_CLASSIFICATIONS.filter((kind) => (classificationCounts.get(kind) ?? 0) > 0).map((kind) => `${kind}: ${classificationCounts.get(kind)}`);
-	if (classificationParts.length > 0) lines.push(`classifications: ${classificationParts.join(", ")}`);
-	if (kit.config.dbPath !== void 0) lines.push(`db: ${kit.config.dbPath}`);
-	lines.push("::endgroup::");
+	if (classificationParts.length > 0) body.push(Doc.paragraph(`classifications: ${classificationParts.join(", ")}`));
+	if (kit.config.dbPath !== void 0) body.push(Doc.paragraph(`db: ${kit.config.dbPath}`));
+	const ctx = Render.contextOf({
+		audience: "ci",
+		displayPath: toDisplayPath
+	});
 	return {
 		target: "stdout",
-		content: lines.join("\n"),
+		content: Render.githubLog([Doc.collapsible("vitest-agent", body)], ctx),
 		contentType: "text/plain"
 	};
 }

package/index.d.ts

@@ -938,6 +938,16 @@ interface ReporterRenderInput {
  */
 interface VitestAgentReporter {
   readonly render: (input: ReporterRenderInput, kit: ReporterKit) => ReadonlyArray<RenderedOutput>;
+  /**
+   * Release what the factory acquired, once, when Vitest closes (never per
+   * run: watch mode reruns `render` many times on one reporter). The plugin
+   * calls it before it shuts the {@link ReporterKit.runEvents | run-event
+   * channel} down, so a subscriber can still drain what was published (a
+   * shutdown drops what a subscriber has not pulled) and end its own stream;
+   * a live view waits here for its last frame to commit. Optional; the plugin
+   * awaits it and treats a rejection as a logged warning.
+   */
+  readonly close?: () => Promise<void>;
 }
 /**
  * Factory that the plugin's `reporter` option accepts. The plugin calls
@@ -994,8 +1004,10 @@ export declare const resolveCellOptions: (kit: ReporterKit) => CellOptions;
 export 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.
+ * rendered to a string via Ink's `renderToString`, inside the kit's
+ * `UiProvider` (the components draw the terminal's glyph set, ASCII under
+ * `TERM=dumb`). 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.
  *
@@ -1012,8 +1024,12 @@ export declare const renderHumanStringForReport: (report: AgentReport, options?:
  * 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.
+ * `consoleMode: "stream"` it starts a live view on the kit's run-event
+ * channel (subscribed before the factory returns, so the first
+ * `RunStarted` is seen) and owns it for the reporter's life: the
+ * reporter's `close`, which the plugin calls at Vitest's close before
+ * shutting the channel down, drains the queued events, waits for the last
+ * frame and closes it.
  *
  * The `render` call (invoked once at run end with the health-aware kit)
  * assembles the reduced state, classifies the shape and outcome, and
@@ -1026,56 +1042,6 @@ export declare const renderHumanStringForReport: (report: AgentReport, options?:
  */
 export 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
@@ -1086,5 +1052,5 @@ declare const createLiveInk: (options?: CreateLiveInkOptions) => LiveInkRenderer
  */
 export declare const CURRENT_REPORTER_VERSION: string;
 //#endregion
-export { type AgentReport, type CellOptions, type ConsoleMode, type CreateLiveInkOptions, 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 };
+export type { AgentReport, CellOptions, ConsoleMode, DetailLevel, DispatchInputs, Environment, Executor, FileCoverageReport, OutputFormat, ProjectSummary, RenderState, RenderedOutput, ReporterKit, ReporterRenderInput, ResolvedReporterConfig, ResolvedThresholds, RunEvent, RunOutcome, RunShape, TestClassification, Transport, TrendSummary, VitestAgentReporter, VitestAgentReporterFactory };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,4 +1,3 @@
-import { createLiveInk } from "./LiveInkRenderer.js";
 import { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions } from "./defaultReporter.js";
 
 //#region src/index.ts
@@ -9,7 +8,7 @@ import { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForRe
 *
 * @public
 */
-const CURRENT_REPORTER_VERSION = "3.1.3";
+const CURRENT_REPORTER_VERSION = "4.0.0";
 
 //#endregion
-export { CURRENT_REPORTER_VERSION, DefaultVitestAgentReporter, createLiveInk as _createLiveInk, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions };
+export { CURRENT_REPORTER_VERSION, DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions };

package/liveView.js

@@ -0,0 +1,96 @@
+import { CliEnv } from "@effected/cli";
+import { CliUi } from "@effected/cli/ui";
+import { initialRenderState } from "@vitest-agent/sdk";
+import { SPINNER_FRAME_MS, StreamApp, reduceRenderState } from "@vitest-agent/ui";
+import { Cause, Deferred, Effect, Exit, Layer, PubSub, Scope } from "effect";
+import { createElement } from "react";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+
+//#region src/liveView.ts
+/**
+* The `stream` console mode's live view: the plugin's run-event channel
+* folded through `reduceRenderState` and drawn as {@link StreamApp} by the
+* kit's `CliUi.live`.
+*
+* The kit owns the mount: a run mounts at `RunStarted` (or where `begins`
+* says), redraws on every event and on an 80 ms tick, and commits its final
+* frame to scrollback at the terminal event (`RunFinished` /
+* `RunTimedOut`), never clearing the screen. The next run in watch mode
+* mounts afresh below it. When the run is not interactive (piped, an agent
+* audience, CI) nothing is mounted and, in the `owned` mode, each run's final
+* frame is written once to stdout as a string, so a `vitest run | cat` still
+* receives the result.
+*
+* Lifetime: one scope per live view, held for the reporter's whole life. The
+* subscription is made in it synchronously, before the factory returns, so
+* the first `RunStarted` is never lost, and the view takes from it directly
+* (`events: subscription`). At Vitest's close the plugin calls
+* {@link LiveRunView.close} before it shuts the channel down: close runs the
+* kit's `LiveHandle.close` (it folds every message still queued in the
+* subscription and commits the last run, so a tail published just before the
+* close is kept), then closes the scope. The view never relies on
+* `PubSub.shutdown` to end it: shutdown drops whatever a subscriber has not
+* taken yet. It is never closed at `onTestRunEnd`, which fires on every
+* watch rerun.
+*/
+/**
+* The live view's options, everything but `events`: what the reporter hands
+* `CliUi.live`, and what the tests hand `CliUiTest.live`, so both run the
+* same fold, drawing and run predicates.
+*
+* @internal
+*/
+const liveViewOptions = {
+	initial: initialRenderState,
+	reduce: reduceRenderState,
+	render: (state, frame) => createElement(StreamApp, {
+		state,
+		frameIndex: frame,
+		nowMs: frame * SPINNER_FRAME_MS
+	}),
+	isStart: (event) => event._tag === "RunStarted",
+	isTerminal: (event) => event._tag === "RunFinished" || event._tag === "RunTimedOut",
+	begins: (event, before, after) => event._tag === "RunStarted" || before.phase === "idle" && after.phase !== "idle",
+	mode: "owned",
+	tickMillis: SPINNER_FRAME_MS
+};
+/**
+* The environment a Vitest-hosted live view reads: the kit's `CliEnv` over
+* Node's stdio and terminal. It builds `CliTheme` (colour from the terminal,
+* glyphs `auto`, so `TERM=dumb` draws ASCII) and sets `CliInteractive` (a
+* human audience with a TTY on stdin and stdout).
+*
+* @internal
+*/
+const LiveViewEnv = CliEnv.layer().pipe(Layer.provide(NodeServices.layer));
+/**
+* Start a live view over `channel`. The subscription is taken before this
+* returns, so an event published right after is seen.
+*
+* @param channel - the plugin's run-event channel
+* @param env - the environment the view reads; {@link LiveViewEnv} by default (a test
+*   merges `UiStreams` / `CliInteractive` into a fixed theme instead)
+*
+* @internal
+*/
+const startLiveView = (channel, env = LiveViewEnv) => {
+	const scope = Effect.runSync(Scope.make());
+	const subscription = Effect.runSync(PubSub.subscribe(channel).pipe(Scope.provide(scope)));
+	const mounted = Effect.runSync(Deferred.make());
+	const program = CliUi.live({
+		...liveViewOptions,
+		events: subscription
+	}).pipe(Effect.onExit((exit) => Deferred.done(mounted, exit)), Effect.flatMap((handle) => handle.done), Scope.provide(scope), Effect.provide(env));
+	Effect.runFork(program);
+	let closing;
+	return {
+		handle: Effect.runPromise(Deferred.await(mounted)),
+		close: () => {
+			closing ??= Effect.runPromise(Deferred.await(mounted).pipe(Effect.flatMap((handle) => handle.close), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logWarning("vitest-agent: the live view ended with an error", cause)), Effect.ensuring(Scope.close(scope, Exit.void))));
+			return closing;
+		}
+	};
+};
+
+//#endregion
+export { LiveViewEnv, liveViewOptions, startLiveView };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/reporter",
-	"version": "3.1.3",
+	"version": "4.0.0",
 	"private": false,
 	"description": "Named VitestAgentReporterFactory implementations for the vitest-agent ecosystem.",
 	"keywords": [
@@ -39,14 +39,18 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-rc.118",
-		"@vitest-agent/sdk": "5.1.3",
-		"@vitest-agent/ui": "2.5.3",
-		"effect": "4.0.0-rc.118",
+		"@effect/platform-node": "^4.0.0",
+		"@vitest-agent/sdk": "5.2.0",
+		"@vitest-agent/ui": "3.0.0",
+		"effect": "^4.0.0",
 		"ink": "^7.1.1",
 		"react": "^19.3.0"
 	},
 	"peerDependencies": {
+		"@effected/cli": "^0.11.0",
+		"@effected/env": "^0.1.0",
+		"@effected/glob": "^0.10.0",
+		"@effected/walker": "^0.15.0",
 		"@vitest/coverage-istanbul": "^5.0.0",
 		"@vitest/coverage-v8": "^5.0.0",
 		"vitest": "^5.0.0"

package/LiveInkRenderer.js

@@ -1,146 +0,0 @@
-import { initialRenderState } from "@vitest-agent/sdk";
-import { SPINNER_FRAME_MS, StreamApp, reduceRenderState, spinnerFrameForTime } from "@vitest-agent/ui";
-import { Box, render, renderToString } from "ink";
-import { createElement } from "react";
-
-//#region src/LiveInkRenderer.tsx
-/**
-* Drain the global user-timing buffer after a render.
-*
-* React 19's *development* reconciler — the build Ink loads whenever
-* `NODE_ENV !== "production"`, which is the norm under Vitest — emits a
-* `performance.measure()` into the global user-timing buffer on every
-* component render for its "Component Performance Track" DevTools feature.
-* Nothing in a Node process consumes that buffer, so across a long run the
-* live mount's per-event and per-spinner-tick rerenders pile up millions of
-* `measure` entries until Node prints `MaxPerformanceEntryBufferExceededWarning`
-* (issue #97). The renderer owns every render call, so it drains the buffer
-* right after each one, bounding it to a single render's worth of entries.
-*
-* Clearing the whole measure/mark buffer is safe here: this runs in the
-* Vitest main process, where test code executes in forked workers (separate
-* perf buffers) and nothing downstream reads these entries. Guarded against
-* runtimes that lack the user-timing API and never allowed to throw — buffer
-* hygiene must not derail a run.
-*/
-const drainRenderPerfEntries = () => {
-	try {
-		performance.clearMeasures?.();
-		performance.clearMarks?.();
-	} catch {}
-};
-/**
-* 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
-*/
-const createLiveInk = (options = {}) => {
-	let state = initialRenderState;
-	let instance = null;
-	let clock = null;
-	let firstRunStarted = false;
-	const targetStream = options.stream ?? process.stdout;
-	const frameWidth = () => {
-		const cols = targetStream.columns;
-		return typeof cols === "number" && cols > 1 ? cols - 1 : void 0;
-	};
-	const frameElement = () => {
-		const now = Date.now();
-		return createElement(Box, {
-			flexDirection: "column",
-			width: frameWidth()
-		}, createElement(StreamApp, {
-			state,
-			frameIndex: spinnerFrameForTime(now),
-			nowMs: now
-		}));
-	};
-	const mount = () => {
-		if (instance !== null) return;
-		instance = render(frameElement(), { stdout: targetStream });
-	};
-	const stopClock = () => {
-		if (clock === null) return;
-		clearInterval(clock);
-		clock = null;
-	};
-	const startClock = () => {
-		if (clock !== null) return;
-		clock = setInterval(() => {
-			if (instance === null) return;
-			try {
-				instance.rerender(frameElement());
-				drainRenderPerfEntries();
-			} catch {
-				instance = null;
-				stopClock();
-			}
-		}, SPINNER_FRAME_MS);
-		clock.unref?.();
-	};
-	const tearDown = () => {
-		stopClock();
-		if (instance === null) return;
-		instance.unmount();
-		instance = null;
-		firstRunStarted = false;
-	};
-	return {
-		event(event) {
-			const previousPhase = state.phase;
-			state = reduceRenderState(state, event);
-			if (event._tag === "RunStarted" || previousPhase === "idle" && state.phase !== "idle") {
-				if (firstRunStarted) {
-					if (instance !== null) try {
-						instance.clear();
-					} catch {}
-				} else try {
-					mount();
-				} catch (err) {
-					process.stderr.write(`@vitest-agent/reporter: live ink renderer failed; falling back silently (${err.message})\n`);
-					instance = null;
-				}
-				firstRunStarted = true;
-				startClock();
-			} else if (instance !== null) try {
-				instance.rerender(frameElement());
-			} catch (err) {
-				process.stderr.write(`@vitest-agent/reporter: live ink renderer failed; falling back silently (${err.message})\n`);
-				instance = null;
-				stopClock();
-			}
-			if (event._tag === "RunFinished" || event._tag === "RunTimedOut") {
-				stopClock();
-				if (instance !== null) {
-					try {
-						instance.unmount();
-					} catch {}
-					instance = null;
-				} else {
-					const now = Date.now();
-					const finalFrameText = renderToString(createElement(StreamApp, {
-						state,
-						frameIndex: spinnerFrameForTime(now),
-						nowMs: now
-					}));
-					targetStream.write(`${finalFrameText}\n`);
-				}
-				firstRunStarted = false;
-			}
-			drainRenderPerfEntries();
-		},
-		unmount() {
-			tearDown();
-		},
-		snapshot() {
-			return state;
-		}
-	};
-};
-
-//#endregion
-export { createLiveInk };