@shivaedev/vitest-rerun 0.2.0 → 0.3.0

package/src/{internal/junit.ts → adapters/RerunJunitReporter.ts}

@@ -1,11 +1,9 @@
 import { relative } from "node:path";
 import { JUnitReporter, type Vitest } from "vitest/node";
-
-export function junitClassname(file: string, project: string): string {
-	return project === "" ? file : `|${project}| ${file}`;
-}
+import { junitClassname } from "#internal/junitClassname.ts";
 
 export class RerunJunitReporter extends JUnitReporter {
+	unhandledErrors: NonNullable<Parameters<JUnitReporter["onTestRunEnd"]>[1]> = [];
 	readonly #root: { path: string };
 
 	constructor(outputFile: string) {
@@ -18,6 +16,11 @@ export class RerunJunitReporter extends JUnitReporter {
 		this.#root = root;
 	}
 
+	override onTestRunEnd(...args: Parameters<JUnitReporter["onTestRunEnd"]>) {
+		this.unhandledErrors = args[1] ?? [];
+		return super.onTestRunEnd(...args);
+	}
+
 	override onInit(vitest: Vitest) {
 		this.#root.path = vitest.config.root;
 		return super.onInit(vitest);

package/src/{internal/adapters → adapters}/TimedJsonReporter.ts

@@ -1,4 +1,4 @@
-import { NodeServices } from "@effect/platform-node";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Effect } from "effect";
 import { experimental_getRunnerTask, JsonReporter, type TestModule } from "vitest/node";
 import { VitestRerunError } from "#error.ts";

package/src/adapters/VitestRunner.ts

@@ -0,0 +1,97 @@
+import { Effect } from "effect";
+import * as VitestNode from "vitest/node";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { failWith } from "#error.ts";
+import type { Snapshot } from "#internal/snapshot.ts";
+import { deferCoverageThresholds } from "./deferCoverageThresholds.ts";
+import { mergeSnapshotSummary } from "./mergeSnapshotSummary.ts";
+import { RerunJunitReporter } from "./RerunJunitReporter.ts";
+import { TimedJsonReporter } from "./TimedJsonReporter.ts";
+import type { Files } from "./tasks.ts";
+import { writeMergedReports } from "./writeMergedReports.ts";
+
+interface RunOptions {
+	readonly cacheDir?: string;
+	readonly reports: { readonly json: string; readonly junit: string };
+	readonly rerun: boolean;
+	readonly vitestArgs: readonly string[];
+}
+
+export interface Selection {
+	readonly fileId: string;
+	readonly testIds?: string[];
+}
+
+function promise<A>(message: string, run: () => Promise<A>) {
+	return Effect.tryPromise({ catch: failWith(message), try: run });
+}
+
+const open = Effect.fn("VitestRerun.open")(function* (input: RunOptions) {
+	const { filter, options } = yield* Effect.try({
+		catch: (cause) => failWith(`Could not parse Vitest arguments: ${cause instanceof Error ? cause.message : String(cause)}`)(cause),
+		try: () => VitestNode.parseCLI(["vitest", "run", ...input.vitestArgs]),
+	});
+	const { shard: _shard, ...unsharded } = options;
+	const junit = new RerunJunitReporter(input.reports.junit);
+	const vitest = yield* Effect.acquireRelease(
+		promise("Vitest could not start", () =>
+			VitestNode.createVitest(
+				{
+					...(input.rerun ? unsharded : options),
+					reporters: ["default", new TimedJsonReporter({ outputFile: input.reports.json }), junit],
+					retry: 0,
+					watch: false,
+				},
+				input.cacheDir === undefined ? {} : { cacheDir: input.cacheDir },
+			),
+		),
+		(instance) => Effect.promise(() => instance.close()),
+	);
+	const finishCoverage = yield* deferCoverageThresholds(vitest);
+	return {
+		collect: (files: Files, summary: Snapshot["summary"]) =>
+			Effect.sync(() => {
+				for (const file of files) {
+					vitest.state.collectFiles(vitest.getProjectByName(file.projectName ?? ""), [file]);
+				}
+				vitest.snapshot.summary = mergeSnapshotSummary(summary, vitest.snapshot.summary);
+			}),
+		finish: (outputDir: string, attempt: number, reports: RunOptions["reports"]) =>
+			Effect.gen(function* () {
+				const coverage = yield* finishCoverage(outputDir, attempt, input.reports.json);
+				yield* writeMergedReports(vitest, reports, coverage, junit.unhandledErrors);
+			}),
+		read: () =>
+			Effect.sync(() => ({
+				errors: vitest.state.getUnhandledErrors(),
+				files: vitest.state.getFiles(),
+				root: vitest.config.root,
+				summary: vitest.snapshot.summary,
+			})),
+		rerun: (selected: readonly Selection[]) =>
+			Effect.gen(function* () {
+				yield* promise("Vitest could not prepare the rerun", () => vitest.standalone());
+				const specifications = yield* promise("Vitest could not list test files", () => vitest.globTestSpecifications());
+				const failed = specifications.flatMap((spec) => {
+					const selection = selected.find((item) => item.fileId === spec.taskId);
+					return selection === undefined
+						? []
+						: [spec.project.createSpecification(spec.moduleId, selection.testIds === undefined ? {} : { testIds: selection.testIds }, spec.pool)];
+				});
+				if (failed.length === 0) {
+					return yield* Effect.fail(failWith("No failed specifications found for the fresh rerun")(undefined));
+				}
+				yield* promise("Vitest could not rerun the failed tests", () => vitest.runTestSpecifications(failed));
+			}),
+		start: () => promise("Vitest could not run the tests", () => vitest.start(filter)).pipe(Effect.asVoid),
+	};
+});
+
+export const VitestRunner = defineService({
+	id: "@shivaedev/vitest-rerun/VitestRunner",
+	initialize: Effect.void,
+	methods: () => ({ open }),
+	requires: [],
+});
+
+export type AttemptRunner = Effect.Success<ReturnType<typeof open>>;

package/src/adapters/deferCoverageThresholds.ts

@@ -0,0 +1,48 @@
+import { Effect, FileSystem, Schema } from "effect";
+import { BaseCoverageProvider, type CoverageProvider, type Vitest } from "vitest/node";
+import { failWith } from "#error.ts";
+import { attemptPaths } from "#internal/reportPaths.ts";
+
+const CoverageReport = Schema.Struct({ coverageMap: Schema.optional(Schema.Unknown) });
+const decodeCoverage = Schema.decodeUnknownEffect(Schema.fromJsonString(CoverageReport));
+
+export const deferCoverageThresholds = Effect.fn("VitestRerun.deferCoverageThresholds")(function* (vitest: Vitest) {
+	const provider = yield* Effect.tryPromise({
+		catch: failWith("Vitest could not load its coverage provider"),
+		try: () => vitest.createCoverageProvider(),
+	});
+	const options = provider?.resolveOptions();
+	const thresholds = options?.thresholds;
+	if (options !== undefined) {
+		options.thresholds = {};
+	}
+	return Effect.fn("VitestRerun.finishCoverage")(function* (outputDir: string, attempt: number, json: string) {
+		if (provider === null || options === undefined) {
+			return undefined;
+		}
+		const fs = yield* FileSystem.FileSystem;
+		const maps: unknown[] = [];
+		for (let earlier = 1; earlier <= attempt; earlier += 1) {
+			const path = earlier === attempt ? json : attemptPaths(outputDir, earlier).json;
+			const { coverageMap } = yield* decodeCoverage(yield* fs.readFileString(path));
+			if (coverageMap !== undefined) {
+				maps.push(coverageMap);
+			}
+		}
+		options.thresholds = thresholds ?? {};
+		return yield* Effect.tryPromise({ catch: failWith("Vitest could not merge coverage"), try: () => reportMergedCoverage(provider, maps) });
+	});
+});
+
+async function reportMergedCoverage(provider: CoverageProvider, maps: unknown[]): Promise<unknown> {
+	let merged: unknown;
+	if (provider instanceof BaseCoverageProvider) {
+		const generate = provider.generateReports.bind(provider);
+		provider.generateReports = async (map, allTestsRun) => {
+			merged = map;
+			await generate(map, allTestsRun);
+		};
+	}
+	await provider.mergeReports?.(maps);
+	return merged;
+}

package/src/adapters/mergeSnapshotSummary.ts

@@ -0,0 +1,21 @@
+import type { SnapshotSummary } from "vitest";
+import type { Snapshot } from "#internal/snapshot.ts";
+
+export function mergeSnapshotSummary(previous: Snapshot["summary"], current: SnapshotSummary): SnapshotSummary {
+	return {
+		added: previous.added + current.added,
+		didUpdate: previous.didUpdate || current.didUpdate,
+		failure: previous.failure || current.failure,
+		filesAdded: previous.filesAdded + current.filesAdded,
+		filesRemoved: previous.filesRemoved + current.filesRemoved,
+		filesRemovedList: [...previous.filesRemovedList, ...current.filesRemovedList],
+		filesUnmatched: previous.filesUnmatched + current.filesUnmatched,
+		filesUpdated: previous.filesUpdated + current.filesUpdated,
+		matched: previous.matched + current.matched,
+		total: previous.total + current.total,
+		unchecked: previous.unchecked + current.unchecked,
+		uncheckedKeysByFile: [...previous.uncheckedKeysByFile.map((file) => ({ ...file, keys: [...file.keys] })), ...current.uncheckedKeysByFile],
+		unmatched: previous.unmatched + current.unmatched,
+		updated: previous.updated + current.updated,
+	};
+}

package/src/adapters/tasks.ts

@@ -0,0 +1,4 @@
+import type { Vitest } from "vitest/node";
+
+export type Files = ReturnType<Vitest["state"]["getFiles"]>;
+export type Task = Files[number]["tasks"][number];

package/src/adapters/writeMergedReports.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect";
+import type { Vitest } from "vitest/node";
+import { failWith } from "#error.ts";
+import { RerunJunitReporter } from "./RerunJunitReporter.ts";
+import { TimedJsonReporter } from "./TimedJsonReporter.ts";
+
+export function writeMergedReports(
+	vitest: Vitest,
+	reports: { json: string; junit: string },
+	coverage: unknown,
+	errors: RerunJunitReporter["unhandledErrors"],
+) {
+	return Effect.tryPromise({
+		catch: failWith("Vitest could not write the merged reports"),
+		try: async () => {
+			const json = new TimedJsonReporter({ outputFile: reports.json });
+			const junit = new RerunJunitReporter(reports.junit);
+			await json.onInit(vitest);
+			if (coverage !== undefined) {
+				json.onCoverage(coverage);
+			}
+			await json.onTestRunEnd(vitest.state.getTestModules());
+			await junit.onInit(vitest);
+			await junit.onTestRunEnd(vitest.state.getTestModules(), errors);
+		},
+	});
+}

package/src/cli.ts

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import process from "node:process";
-import { NodeServices } from "@effect/platform-node";
-import { Effect } from "effect";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect, Exit, Runtime } from "effect";
 import { main } from "#internal/main.ts";
 
-process.exitCode = await Effect.runPromise(main(process.argv.slice(2), process.cwd()).pipe(Effect.provide(NodeServices.layer)));
+NodeRuntime.runMain(main(process.argv.slice(2), process.cwd()).pipe(Effect.provide(NodeServices.layer)), {
+	teardown: (exit, onExit) => (Exit.isSuccess(exit) ? onExit(Number(exit.value)) : Runtime.defaultTeardown(exit, onExit)),
+});

package/src/flakyTests.ts

@@ -1,5 +1,5 @@
 import { Effect, FileSystem, Schema } from "effect";
-import type { Task } from "#internal/snapshot.ts";
+import type { Task } from "#adapters/tasks.ts";
 
 export const FlakyTest = Schema.Struct({
 	attempts: Schema.Number,

package/src/internal/SnapshotFiles.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import type { Files } from "./snapshot.ts";
+import type { Files } from "#adapters/tasks.ts";
 
 const Result = Schema.Struct({
 	duration: Schema.optional(Schema.Number),

package/src/internal/attempt.ts

@@ -1,20 +1,21 @@
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { NodeServices } from "@effect/platform-node";
-import { Console, Effect } from "effect";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Console, Effect, Exit, Runtime } from "effect";
+import { VitestRunner } from "#adapters/VitestRunner.ts";
 import { runAttempt } from "#internal/runAttempt.ts";
 
 if (fileURLToPath(import.meta.url) === process.argv[1]) {
 	const [attempt = "1", outputDir = ".", ...vitestArgs] = process.argv.slice(2);
-	const failed = await Effect.runPromise(
+	NodeRuntime.runMain(
 		runAttempt({ attempt: Number(attempt), outputDir, vitestArgs }).pipe(
 			Effect.catchTag("VitestRerunError", (error) =>
 				Effect.as(Console.error(`vitest-rerun: ${error.message}`, ...(error.cause === undefined ? [] : [error.cause])), true),
 			),
+			Effect.provide(VitestRunner.layer),
 			Effect.provide(NodeServices.layer),
 		),
+		{ teardown: (exit, onExit) => (Exit.isSuccess(exit) ? onExit(Number(exit.value)) : Runtime.defaultTeardown(exit, onExit)) },
 	);
-	if (failed) {
-		process.exitCode = 1;
-	}
 }

package/src/internal/junitClassname.ts

@@ -0,0 +1,3 @@
+export function junitClassname(file: string, project: string): string {
+	return project === "" ? file : `|${project}| ${file}`;
+}

package/src/internal/mergeAttempt.ts

@@ -1,9 +1,10 @@
 import { relative } from "node:path";
 import { Effect } from "effect";
+import type { Files, Task } from "#adapters/tasks.ts";
 import { VitestRerunError } from "#error.ts";
 import { type FlakyTest, failureMessage, testcases } from "#flakyTests.ts";
-import { junitClassname } from "#internal/junit.ts";
-import { type FailureHistory, type Files, type Snapshot, type Task, tests } from "#internal/snapshot.ts";
+import { junitClassname } from "#internal/junitClassname.ts";
+import { type FailureHistory, type Snapshot, tests } from "#internal/snapshot.ts";
 
 type File = Files[number];
 
@@ -14,9 +15,9 @@ interface Outcome {
 	readonly summary: (line: string) => void;
 }
 
-function mergeTest(first: Task, task: Task) {
-	const unresolved = first.result?.state === "fail" && !["pass", "fail"].includes(task.result?.state ?? "");
-	if (first.result !== undefined && (first.result.state === "pass" || unresolved)) {
+function mergeResult(first: Task, task: Task) {
+	const completed = ["pass", "fail"].includes(task.result?.state ?? "");
+	if (first.result !== undefined && ["pass", "fail"].includes(first.result.state) && !completed) {
 		task.mode = first.mode;
 		task.result = first.result;
 		task.logs = first.logs ?? [];
@@ -25,31 +26,29 @@ function mergeTest(first: Task, task: Task) {
 	}
 }
 
-function restorePassed(original: Task[], rerun: Task[]) {
+function mergeTasks(original: Task[], rerun: Task[]) {
 	for (const task of rerun) {
 		const first = original.find((item) => item.id === task.id);
 		if (first === undefined) {
 			continue;
 		}
 		if (task.type === "suite" && first.type === "suite") {
-			restorePassed(first.tasks, task.tasks);
-		} else {
-			mergeTest(first, task);
+			mergeTasks(first.tasks, task.tasks);
+		}
+		mergeResult(first, task);
+		if (task.type === "suite" && task.tasks.some((child) => child.result?.state === "fail") && task.result !== undefined) {
+			task.result.state = "fail";
 		}
 	}
 }
 
-function finishFile(file: File, next: File, ranTests: boolean) {
-	const duration = (file.result?.duration ?? 0) + (next.result?.duration ?? 0);
-	if (!ranTests && file.tasks.length > 0 && file.result !== undefined) {
-		next.result = { ...file.result };
-	}
+function finishFile(file: File, next: File) {
+	mergeResult(file, next);
 	if (next.result !== undefined) {
-		if (tests(next.tasks).some((test) => test.result?.state === "fail")) {
+		if (next.tasks.some((task) => task.result?.state === "fail")) {
 			next.result.state = "fail";
 		}
 		next.result.startTime = file.result?.startTime ?? next.result.startTime ?? 0;
-		next.result.duration = duration;
 	}
 }
 
@@ -72,16 +71,13 @@ function recordAttempts(file: File, retried: Task[], outcome: Outcome) {
 function mergeFile(file: File, next: File, outcome: Outcome) {
 	const original = tests(file.tasks);
 	const retried = tests(next.tasks);
-	const ranTests = retried.some(
-		(test) => ["pass", "fail"].includes(test.result?.state ?? "") && original.some((item) => item.id === test.id && item.result?.state !== "pass"),
-	);
 	recordAttempts(file, retried, outcome);
 	if (original.length === 0 && next.result?.state === "pass") {
 		outcome.summary(`- Flaky: ${junitClassname(relative(outcome.root, file.filepath), file.projectName ?? "")} — collection failure`);
 	} else if (original.length > 0) {
-		restorePassed(file.tasks, next.tasks);
+		mergeTasks(file.tasks, next.tasks);
 	}
-	finishFile(file, next, ranTests);
+	finishFile(file, next);
 }
 
 interface Merged {
@@ -93,7 +89,7 @@ interface Merged {
 function unexpectedTask(original: readonly Task[], rerun: readonly Task[]): Task | undefined {
 	for (const task of rerun) {
 		const first = original.find((item) => item.id === task.id);
-		if (first === undefined) {
+		if (first === undefined || first.name !== task.name || first.type !== task.type) {
 			return task;
 		}
 		const unexpected = first.type === "suite" && task.type === "suite" ? unexpectedTask(first.tasks, task.tasks) : undefined;

package/src/internal/refuseDeclaredRetries.ts

@@ -0,0 +1,22 @@
+import { relative } from "node:path";
+import { Effect } from "effect";
+import type { Files } from "#adapters/tasks.ts";
+import { VitestRerunError } from "#error.ts";
+import { testcases } from "#flakyTests.ts";
+import { junitClassname } from "#internal/junitClassname.ts";
+
+export const refuseDeclaredRetries = Effect.fn("VitestRerun.refuseDeclaredRetries")(function* (files: Files, root: string) {
+	const offenders = files.flatMap((file) =>
+		testcases(file.tasks).flatMap(({ name, task }) => {
+			const count = typeof task.retry === "number" ? task.retry : (task.retry?.count ?? 0);
+			return count > 0 ? [`${junitClassname(relative(root, file.filepath), file.projectName ?? "")} > ${name}`] : [];
+		}),
+	);
+	if (offenders.length > 0) {
+		return yield* Effect.fail(
+			new VitestRerunError({
+				message: `Retries are global only and recoveries are recorded in flaky-tests.json. Remove per-test and per-suite retry options: ${offenders.sort().join("; ")}`,
+			}),
+		);
+	}
+});

package/src/internal/runAttempt.ts

@@ -1,13 +1,11 @@
-import { Config, Console, Effect, FileSystem, Schema } from "effect";
-import type { CliOptions, Vitest } from "vitest/node";
-import * as VitestNode from "vitest/node";
-import { failWith } from "#error.ts";
+import { Effect } from "effect";
+import { type AttemptRunner, type Selection, VitestRunner } from "#adapters/VitestRunner.ts";
 import { writeFlakyTests } from "#flakyTests.ts";
-import { TimedJsonReporter } from "#internal/adapters/TimedJsonReporter.ts";
-import { RerunJunitReporter } from "#internal/junit.ts";
 import { mergeAttempt } from "#internal/mergeAttempt.ts";
+import { refuseDeclaredRetries } from "#internal/refuseDeclaredRetries.ts";
 import { attemptPaths, reportPaths } from "#internal/reportPaths.ts";
-import { failedFiles, readSnapshot, type Snapshot, saveSnapshot, tests } from "#internal/snapshot.ts";
+import { failedFiles, hasSuiteErrors, readSnapshot, type Snapshot, saveSnapshot, tests } from "#internal/snapshot.ts";
+import { summaryLine } from "#internal/summaryLine.ts";
 
 export interface Attempt {
 	readonly attempt: number;
@@ -15,112 +13,61 @@ export interface Attempt {
 	readonly vitestArgs: readonly string[];
 }
 
-const CoverageReport = Schema.Struct({ coverageMap: Schema.optional(Schema.Unknown) });
-const decodeCoverage = Schema.decodeUnknownEffect(Schema.fromJsonString(CoverageReport));
-
-function promise<A>(message: string, run: () => Promise<A>) {
-	return Effect.tryPromise({ catch: failWith(message), try: run });
-}
-
-function start(options: CliOptions, reports: { json: string; junit: string }, cacheDir: string | undefined) {
-	return Effect.acquireRelease(
-		promise("Vitest could not start", () =>
-			VitestNode.createVitest(
-				{
-					...options,
-					reporters: ["default", new TimedJsonReporter({ outputFile: reports.json }), new RerunJunitReporter(reports.junit)],
-					retry: 0,
-					watch: false,
-				},
-				cacheDir === undefined ? {} : { cacheDir },
-			),
-		),
-		(vitest) => Effect.promise(() => vitest.close()),
-	);
-}
-
-const failedSpecifications = Effect.fn("VitestRerun.failedSpecifications")(function* (vitest: Vitest, previous: Snapshot, json: string) {
+const failedSelections = Effect.fn("VitestRerun.failedSelections")(function* (previous: Snapshot, json: string) {
 	const failed = new Set(yield* failedFiles(json));
-	yield* promise("Vitest could not prepare the rerun", () => vitest.standalone());
-	const specifications = yield* promise("Vitest could not list test files", () => vitest.globTestSpecifications());
-	return specifications.flatMap((spec) => {
-		const file = previous.files.find((item) => item.id === spec.taskId && failed.has(spec.moduleId) && item.result?.state === "fail");
-		if (file === undefined) {
+	return previous.files.flatMap((file): Selection[] => {
+		if (!failed.has(file.filepath) || file.result?.state !== "fail") {
 			return [];
 		}
 		const runnable = tests(file.tasks).filter((test) => !["pass", "skip", "todo"].includes(test.result?.state ?? test.mode));
-		return [spec.project.createSpecification(spec.moduleId, file.tasks.length === 0 ? {} : { testIds: runnable.map((test) => test.id) }, spec.pool)];
+		return [{ fileId: file.id, ...(file.tasks.length === 0 || hasSuiteErrors(file) ? {} : { testIds: runnable.map((test) => test.id) }) }];
 	});
 });
 
-const mergeCoverage = Effect.fn("VitestRerun.mergeCoverage")(function* (vitest: Vitest, outputDir: string, attempt: number) {
-	const fs = yield* FileSystem.FileSystem;
-	const maps: unknown[] = [];
-	for (let earlier = 1; earlier <= attempt; earlier += 1) {
-		const { coverageMap } = yield* decodeCoverage(yield* fs.readFileString(attemptPaths(outputDir, earlier).json));
-		if (coverageMap !== undefined) {
-			maps.push(coverageMap);
-		}
-	}
-	const provider = yield* promise("Vitest could not load its coverage provider", () => vitest.createCoverageProvider());
-	yield* promise("Vitest could not merge coverage", async () => provider?.mergeReports?.(maps));
-});
-
-const summaryLine = Effect.fn("VitestRerun.summaryLine")(function* (line: string) {
-	const fs = yield* FileSystem.FileSystem;
-	const summary = yield* Config.String("GITHUB_STEP_SUMMARY").pipe(Config.withDefault(""));
-	yield* Console.log(line);
-	if (summary !== "") {
-		yield* fs.writeFileString(summary, `${line}\n`, { flag: "a" });
-	}
-});
-
-const rerunFailed = Effect.fn("VitestRerun.rerunFailed")(function* (vitest: Vitest, { attempt, outputDir }: Attempt) {
+const rerunFailed = Effect.fn("VitestRerun.rerunFailed")(function* (runner: AttemptRunner, { attempt, outputDir }: Attempt) {
 	const previous = yield* readSnapshot(attemptPaths(outputDir, attempt - 1).snapshot);
 	const final = reportPaths(outputDir);
-	const specifications = yield* failedSpecifications(vitest, previous, final.json);
-	if (specifications.length === 0) {
-		return yield* Effect.fail(failWith("No failed specifications found for the fresh rerun")(undefined));
-	}
-	yield* promise("Vitest could not rerun the failed tests", () => vitest.runTestSpecifications(specifications));
+	yield* runner.rerun(yield* failedSelections(previous, final.json));
+	const current = yield* runner.read();
+	yield* refuseDeclaredRetries(current.files, current.root);
 	const lines: string[] = [];
-	const merged = yield* mergeAttempt(previous, vitest.state.getFiles(), vitest.config.root, (line) => lines.push(line));
-	for (const file of merged.files) {
-		vitest.state.collectFiles(vitest.getProjectByName(file.projectName ?? ""), [file]);
-	}
+	const merged = yield* mergeAttempt(previous, current.files, current.root, (line) => lines.push(line));
+	yield* runner.collect(merged.files, previous.summary);
 	yield* Effect.forEach(lines, summaryLine);
-	for (const reporter of [new TimedJsonReporter({ outputFile: final.json }), new RerunJunitReporter(final.junit)]) {
-		yield* promise("Vitest could not write the merged reports", async () => {
-			await reporter.onInit(vitest);
-			await reporter.onTestRunEnd(vitest.state.getTestModules());
-		});
-	}
 	if (merged.flaky.length > 0) {
 		yield* writeFlakyTests(final.flaky, merged.flaky);
 	}
-	if (vitest.config.coverage.enabled) {
-		yield* mergeCoverage(vitest, outputDir, attempt);
-	}
+	const state = yield* runner.read();
 	const snapshot: Snapshot = {
-		errors: vitest.state.getUnhandledErrors(),
+		errors: state.errors,
 		failures: merged.failures,
-		files: vitest.state.getFiles(),
+		files: state.files,
 		flaky: merged.flaky,
+		summary: state.summary,
 	};
 	return snapshot;
 });
 
 export const runAttempt = Effect.fn("VitestRerun.runAttempt")(function* (input: Attempt) {
-	const { filter, options } = VitestNode.parseCLI(["vitest", "run", ...input.vitestArgs]);
+	const vitest = yield* VitestRunner;
 	const rerun = input.attempt > 1;
-	const { shard: _shard, ...unsharded } = options;
 	const reports = rerun ? attemptPaths(input.outputDir, input.attempt) : reportPaths(input.outputDir);
-	const vitest = yield* start(rerun ? unsharded : options, reports, rerun ? reportPaths(input.outputDir).rerunCache : undefined);
-	const snapshot: Snapshot = rerun
-		? yield* rerunFailed(vitest, input)
-		: yield* promise("Vitest could not run the tests", () => vitest.start(filter)).pipe(
-				Effect.map(() => ({ errors: vitest.state.getUnhandledErrors(), failures: {}, files: vitest.state.getFiles(), flaky: [] })),
-			);
+	const runner = yield* vitest.open({
+		...(rerun ? { cacheDir: reportPaths(input.outputDir).rerunCache } : {}),
+		reports,
+		rerun,
+		vitestArgs: input.vitestArgs,
+	});
+	let snapshot: Snapshot;
+	if (rerun) {
+		snapshot = yield* rerunFailed(runner, input);
+	} else {
+		yield* runner.start();
+		const state = yield* runner.read();
+		yield* refuseDeclaredRetries(state.files, state.root);
+		snapshot = { errors: state.errors, failures: {}, files: state.files, flaky: [], summary: state.summary };
+	}
+	yield* runner.finish(input.outputDir, input.attempt, reportPaths(input.outputDir));
 	yield* saveSnapshot(attemptPaths(input.outputDir, input.attempt).snapshot, snapshot);
 	return snapshot.files.some((file) => file.result?.state === "fail") || snapshot.errors.length > 0;
 }, Effect.scoped);

package/src/internal/snapshot.ts

@@ -1,13 +1,10 @@
 import { deserialize, serialize } from "node:v8";
 import { Effect, FileSystem, Schema } from "effect";
-import type { Vitest } from "vitest/node";
+import type { Task } from "#adapters/tasks.ts";
 import { failWith } from "#error.ts";
 import { FlakyTest } from "#flakyTests.ts";
 import { SnapshotFiles } from "./SnapshotFiles.ts";
 
-export type Files = ReturnType<Vitest["state"]["getFiles"]>;
-export type Task = Files[number]["tasks"][number];
-
 export interface FailureHistory {
 	readonly attempts: number;
 	readonly messages: readonly string[];
@@ -18,6 +15,22 @@ const SnapshotSchema = Schema.Struct({
 	failures: Schema.Record(Schema.String, Schema.Struct({ attempts: Schema.Number, messages: Schema.Array(Schema.String) })),
 	files: SnapshotFiles,
 	flaky: Schema.Array(FlakyTest),
+	summary: Schema.Struct({
+		added: Schema.Number,
+		didUpdate: Schema.Boolean,
+		failure: Schema.Boolean,
+		filesAdded: Schema.Number,
+		filesRemoved: Schema.Number,
+		filesRemovedList: Schema.Array(Schema.String),
+		filesUnmatched: Schema.Number,
+		filesUpdated: Schema.Number,
+		matched: Schema.Number,
+		total: Schema.Number,
+		unchecked: Schema.Number,
+		uncheckedKeysByFile: Schema.Array(Schema.Struct({ filePath: Schema.String, keys: Schema.Array(Schema.String) })),
+		unmatched: Schema.Number,
+		updated: Schema.Number,
+	}),
 });
 export type Snapshot = typeof SnapshotSchema.Type;
 
@@ -37,6 +50,10 @@ export function tests(tasks: readonly Task[]): Task[] {
 	return tasks.flatMap((task) => (task.type === "suite" ? tests(task.tasks) : [task]));
 }
 
+export function hasSuiteErrors(task: Task): boolean {
+	return task.type === "suite" && ((task.result?.errors?.length ?? 0) > 0 || task.tasks.some(hasSuiteErrors));
+}
+
 export const saveSnapshot = Effect.fn("VitestRerun.saveSnapshot")(function* (path: string, snapshot: Snapshot) {
 	const fs = yield* FileSystem.FileSystem;
 	yield* fs.writeFile(path, serialize(snapshot));

package/src/internal/summaryLine.ts

@@ -0,0 +1,10 @@
+import { Config, Console, Effect, FileSystem } from "effect";
+
+export const summaryLine = Effect.fn("VitestRerun.summaryLine")(function* (line: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const summary = yield* Config.String("GITHUB_STEP_SUMMARY").pipe(Config.withDefault(""));
+	yield* Console.log(line);
+	if (summary !== "") {
+		yield* fs.writeFileString(summary, `${line}\n`, { flag: "a" });
+	}
+});