@systemfsoftware/stryker-js-vitest-runner 2.0.2 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @systemfsoftware/stryker-js-vitest-runner
 
+## 3.0.0
+
+### Major Changes
+
+- The dry-run decision moved to a plain kernel (dryRunCell removed); the mutant-run decision splits into branded MutantKilled|MutantSurvived|MutantTimeout|MutantDryError variants
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@6.0.0
+  - @systemfsoftware/stryker-js@1.0.0
+
+## 2.1.0
+
+### Minor Changes
+
+- Plugin code can now ask for the module-loader service instead of touching the host module API: it exposes the same `createRequire`/`isBuiltin` surface as the host module module, and the Node engine supplies it automatically. Plugins that declare their environment through the engine's plugin declaration get the service without extra wiring; upgrades should move the engine and its plugins in the same release.
+
+### Patch Changes
+
+- Refreshed builds on the platform-services dependency graph; the packages no longer reach for host builtins directly. No CLI flags or option names change.
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js@0.2.0
+
 ## 2.0.2
 
 ### Patch Changes

package/dist/index.mjs

@@ -2,89 +2,66 @@ import { RunConfiguration, SandboxDirectory, declarePlugin } from "@systemfsoftw
 import * as Effect$1 from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as S from "effect/Schema";
-import { createRequire } from "module";
-import { pathToFileURL } from "node:url";
-import path from "path";
-import { fileURLToPath } from "url";
 import { createVitest } from "vitest/node";
 import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
+import { Module } from "@systemfsoftware/stryker-js/Module";
 import { INSTRUMENTER_CONSTANTS, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js/Mutant";
 import { TestRunner, TestRunnerFailed, testFilesProvided } from "@systemfsoftware/stryker-js/TestRunner";
+import * as Context from "effect/Context";
 import * as FileSystem from "effect/FileSystem";
-import { pipe } from "effect/Function";
+import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Ref from "effect/Ref";
 import * as Result from "effect/Result";
 import { Effect } from "effect";
-import * as Match from "effect/Match";
-//#region src/Runner.schema.ts
-/**
-* Runner schemas — declarations for the vitest runner capability.
-*
-* Houses every Schema/Wire type this capability publishes or decodes
-* internally: option validation, coverage/task metadata, sandbox
-* manifest, and the dynamic vitest module shape.
-*/
-/**
-* The `vitest` option section of the Stryker options document. `related`
-* defaults to `true` at decode, the other members are optional.
-*/
-const VitestRunnerOptionsSchema = S.Struct({
-	dir: S.optional(S.String),
-	related: S.optional(S.Boolean).pipe(S.withDecodingDefault(Effect.succeed(true))),
-	configFile: S.optional(S.String)
-});
-/**
-* The `vitest` section of the Stryker options document: absent from the input
-* document, or present as a partial, and decoded into the section defaults.
-*/
-const VitestSectionSchema = S.optional(VitestRunnerOptionsSchema).pipe(S.withDecodingDefault(Effect.succeed({ related: true })));
-const HitCountMetaSchema = S.Struct({ hitCount: S.optional(S.Finite) });
-const MutantCoverageMetaSchema = S.Struct({ mutantCoverage: S.optional(S.Struct({
-	static: S.Record(S.String, S.Finite),
-	perTest: S.Record(S.String, S.Record(S.String, S.Finite))
-})) });
-const MutantCoverageShapeSchema = S.Struct({
-	static: S.Record(S.String, S.Finite),
-	perTest: S.Record(S.String, S.Record(S.String, S.Finite))
-});
-var CoverageDecodeFailed = class extends S.TaggedError()("CoverageDecodeFailed", { cause: S.Unknown }) {};
-const ExportEntry = S.Union([S.String, S.Record(S.String, S.Unknown)]);
-const PackageManifest = S.StructWithRest(S.Struct({
-	name: S.optional(S.String),
-	exports: S.optional(S.Record(S.String, ExportEntry))
-}), [S.Record(S.String, S.Unknown)]);
-/**
-* The dynamically imported project-local `vitest/node` module. The runtime
-* check only asserts object-likeness: the module namespace is whatever the
-* resolved package exports, and the consumers tolerate a missing
-* `createVitest` via their own fallbacks.
-*/
-const VitestNodeModuleSchema = S.declare((input) => input !== null && typeof input === "object" && !Array.isArray(input), { description: "The project-local vitest/node module" });
-/** The `package.json` document of a resolved vitest package. */
-const VitestPackageSchema = S.Struct({ version: S.String });
-//#endregion
-//#region src/VitestDryRun.workflow.ts
-/**
-* VitestDryRun workflow — pure result-mapping for the dry-run phase.
-*
-* Every function here is pure: it maps raw vitest task payloads to
-* Stryker run results without touching the filesystem or spawning
-* processes. Impure orchestration lives in `Runner.ts`.
-*/
+//#region src/interpret-vitest-run.workflow.ts
+var VitestMutantRunCommand = class extends S.TaggedClass()("VitestMutantRunCommand", {
+	rawTests: S.Array(S.Unknown),
+	projectRoot: S.String,
+	hasExternalError: S.Boolean,
+	externalErrorText: S.String,
+	hitCount: S.optional(S.Finite),
+	hitLimit: S.optional(S.Finite),
+	reportAllKillers: S.Boolean
+}) {};
+const VitestMutantRunTypeId = Symbol.for("@systemfsoftware/stryker-js-vitest-runner/VitestMutantRun");
+var MutantKilled = class extends S.TaggedClass()("Killed", {
+	testsJson: S.String,
+	killerIds: S.optional(S.Array(S.String)),
+	failureMessage: S.optional(S.String)
+}) {
+	[VitestMutantRunTypeId] = VitestMutantRunTypeId;
+};
+var MutantSurvived = class extends S.TaggedClass()("Survived", { testsJson: S.String }) {
+	[VitestMutantRunTypeId] = VitestMutantRunTypeId;
+};
+var MutantTimeout = class extends S.TaggedClass()("Timeout", {
+	testsJson: S.String,
+	reason: S.optional(S.String)
+}) {
+	[VitestMutantRunTypeId] = VitestMutantRunTypeId;
+};
+var MutantDryError = class extends S.TaggedClass()("Error", {
+	testsJson: S.String,
+	errorMessage: S.optional(S.String)
+}) {
+	[VitestMutantRunTypeId] = VitestMutantRunTypeId;
+};
+var VitestMutantRunError = class extends S.TaggedError()("VitestMutantRunError", { message: S.String }) {
+	[VitestMutantRunTypeId] = VitestMutantRunTypeId;
+};
 var VitestDryRunCommand$1 = class extends S.TaggedClass()("VitestDryRunCommand", {
 	rawTests: S.Array(S.Unknown),
 	projectRoot: S.String,
 	hasExternalError: S.Boolean,
 	externalErrorText: S.String
 }) {};
-var VitestDryRunOutput$1 = class extends S.TaggedClass()("VitestDryRunOutput", {
+var VitestDryRunOutput = class extends S.TaggedClass()("VitestDryRunOutput", {
 	status: S.Literals(["Complete", "Error"]),
 	testsJson: S.String,
 	errorMessage: S.optional(S.String)
 }) {};
-S.TaggedError()("VitestDryRunError", { message: S.String });
 const recordOption$1 = (value) => S.decodeUnknownOption(S.Record(S.String, S.Unknown))(value);
 const getStringField$1 = (record, key) => Option.fromNullishOr(record[key]).pipe(Option.filter((v) => typeof v === "string"));
 const getNumberField$1 = (record, key) => Option.fromNullishOr(record[key]).pipe(Option.filter((v) => typeof v === "number"));
@@ -133,12 +110,6 @@ const toRawTestIdRaw$1 = (test) => {
 		onSome: (file) => Option.getOrElse(Option.fromNullishOr(getFilepath$1(file)), () => "unknown.js")
 	})}#${collectTestNameRaw$1(test)}`;
 };
-/**
-* A test id is `<file>#<test name>`, and the file is reported relative to the
-* project root so an id is stable across machines and sandbox directories.
-* Vitest reports an absolute path, so the root prefix is stripped here rather
-* than resolved — a decision body has no path service and needs none.
-*/
 const normalizeTestIdRaw$1 = (id, projectRoot) => {
 	const hash = id.indexOf("#");
 	if (hash === -1) return id;
@@ -223,65 +194,146 @@ const convertTestRaw$1 = (test, projectRoot) => {
 		status
 	})));
 };
-const decideVitestDryRun$1 = (command) => {
-	const tests = command.rawTests.map((t) => convertTestRaw$1(t, command.projectRoot));
-	const hasFailure = tests.some((t) => t.status === "failed");
-	return Match.value({
-		hasFailure,
-		hasExternalError: command.hasExternalError
-	}).pipe(Match.when({
-		hasFailure: false,
-		hasExternalError: true
-	}, () => Result.succeed(VitestDryRunOutput$1.make({
-		status: "Error",
-		testsJson: JSON.stringify(tests),
-		errorMessage: `An error occurred outside of a test run: ${command.externalErrorText}`
-	}))), Match.orElse(() => Result.succeed(VitestDryRunOutput$1.make({
-		status: "Complete",
-		testsJson: JSON.stringify(tests),
-		errorMessage: void 0
-	}))));
+const decideVitestDryRun$1 = (command) => Match.value(command.rawTests.map((t) => convertTestRaw$1(t, command.projectRoot))).pipe(Match.when((tests) => tests.some((t) => t.status === "failed") === false && command.hasExternalError === true, (tests) => Result.succeed(VitestDryRunOutput.make({
+	status: "Error",
+	testsJson: JSON.stringify(tests),
+	errorMessage: `An error occurred outside of a test run: ${command.externalErrorText}`
+}))), Match.orElse((tests) => Result.succeed(VitestDryRunOutput.make({
+	status: "Complete",
+	testsJson: JSON.stringify(tests),
+	errorMessage: void 0
+}))));
+const hitLimitReason = (hitCount, hitLimit) => {
+	if (hitCount === void 0 || hitLimit === void 0) return Option.none();
+	if (hitCount > hitLimit) return Option.some(`Hit limit reached (${hitCount}/${hitLimit})`);
+	return Option.none();
 };
-const vitestDryRunWorkflow = Workflow.make(VitestDryRunCommand$1, decideVitestDryRun$1);
+const decideVitestMutantRun = (command) => Match.value(hitLimitReason(command.hitCount, command.hitLimit)).pipe(Match.when(Option.isSome, (hit) => Result.succeed(MutantTimeout.make({
+	testsJson: "[]",
+	reason: hit.value
+}))), Match.when(Option.isNone, () => {
+	const dryOut = decideVitestDryRun$1(VitestDryRunCommand$1.make({
+		rawTests: command.rawTests,
+		projectRoot: command.projectRoot,
+		hasExternalError: command.hasExternalError,
+		externalErrorText: command.externalErrorText
+	}));
+	return Match.value(Result.isFailure(dryOut)).pipe(Match.when(true, () => Result.fail(new VitestMutantRunError({ message: "dry run mapping failed" }))), Match.when(false, () => {
+		const dry = Result.getOrElse(dryOut, () => VitestDryRunOutput.make({
+			status: "Complete",
+			testsJson: "[]",
+			errorMessage: void 0
+		}));
+		return Match.value(dry.status === "Error").pipe(Match.when(true, () => Result.succeed(MutantDryError.make({
+			testsJson: "[]",
+			errorMessage: dry.errorMessage
+		}))), Match.when(false, () => {
+			const testsOption = Option.liftThrowable((input) => JSON.parse(input))(dry.testsJson).pipe(Option.filter((v) => Array.isArray(v)));
+			const killed = Option.getOrElse(testsOption, () => []).filter((t) => t.status === "failed");
+			return Match.value(killed.length > 0).pipe(Match.when(true, () => Match.value(command.reportAllKillers).pipe(Match.when(true, () => {
+				const firstKiller = Option.fromNullishOr(killed[0]);
+				const failureMessage = Option.match(firstKiller, {
+					onNone: () => void 0,
+					onSome: (k) => k.failureMessage
+				});
+				return Result.succeed(MutantKilled.make({
+					testsJson: dry.testsJson,
+					killerIds: killed.map((t) => t.id),
+					failureMessage
+				}));
+			}), Match.when(false, () => {
+				const first = Option.fromNullishOr(killed[0]);
+				const failureMessage = Option.match(first, {
+					onNone: () => void 0,
+					onSome: (k) => k.failureMessage
+				});
+				return Match.value(Option.isSome(first)).pipe(Match.when(true, () => Result.succeed(MutantKilled.make({
+					testsJson: dry.testsJson,
+					killerIds: Option.match(first, {
+						onNone: () => void 0,
+						onSome: (k) => [k.id]
+					}),
+					failureMessage
+				}))), Match.when(false, () => Result.succeed(MutantKilled.make({
+					testsJson: dry.testsJson,
+					killerIds: Option.getOrUndefined(Option.match(first, {
+						onNone: () => Option.none(),
+						onSome: (k) => Option.some([k.id])
+					})),
+					failureMessage
+				}))), Match.exhaustive);
+			}), Match.exhaustive)), Match.when(false, () => Result.succeed(MutantSurvived.make({ testsJson: dry.testsJson }))), Match.exhaustive);
+		}), Match.exhaustive);
+	}), Match.exhaustive);
+}), Match.exhaustive);
+const interpretVitestRun = Workflow.make(VitestMutantRunCommand, decideVitestMutantRun);
 //#endregion
-//#region src/VitestMutantRun.workflow.ts
-/**
-* VitestMutantRun workflow — pure result-mapping for the mutant-run phase.
-*/
-var VitestMutantRunCommand = class extends S.TaggedClass()("VitestMutantRunCommand", {
-	rawTests: S.Array(S.Unknown),
-	projectRoot: S.String,
-	hasExternalError: S.Boolean,
-	externalErrorText: S.String,
-	hitCount: S.optional(S.Finite),
-	hitLimit: S.optional(S.Finite),
-	reportAllKillers: S.Boolean
-}) {};
-var VitestMutantRunOutput = class extends S.TaggedClass()("VitestMutantRunOutput", {
-	status: S.Literals([
-		"Killed",
-		"Survived",
-		"Timeout",
-		"Error"
-	]),
-	testsJson: S.String,
-	errorMessage: S.optional(S.String),
-	killerIds: S.optional(S.Array(S.String)),
-	failureMessage: S.optional(S.String),
-	reason: S.optional(S.String)
-}) {};
-var VitestMutantRunError = class extends S.TaggedError()("VitestMutantRunError", { message: S.String }) {};
+//#region src/Runner.schema.ts
+const VitestRunnerOptionsSchema = S.Struct({
+	dir: S.optional(S.String),
+	related: S.optional(S.Boolean).pipe(S.withDecodingDefault(Effect.succeed(true))),
+	configFile: S.optional(S.String)
+});
+const VitestSectionSchema = S.optional(VitestRunnerOptionsSchema).pipe(S.withDecodingDefault(Effect.succeed({ related: true })));
+const HitCountMetaSchema = S.Struct({ hitCount: S.optional(S.Finite) });
+const MutantCoverageMetaSchema = S.Struct({ mutantCoverage: S.optional(S.Struct({
+	static: S.Record(S.String, S.Finite),
+	perTest: S.Record(S.String, S.Record(S.String, S.Finite))
+})) });
+const MutantCoverageShapeSchema = S.Struct({
+	static: S.Record(S.String, S.Finite),
+	perTest: S.Record(S.String, S.Record(S.String, S.Finite))
+});
+var CoverageDecodeFailed = class extends S.TaggedError()("CoverageDecodeFailed", { cause: S.Unknown }) {};
+const ExportEntry = S.Union([S.String, S.Record(S.String, S.Unknown)]);
+const PackageManifest = S.StructWithRest(S.Struct({
+	name: S.optional(S.String),
+	exports: S.optional(S.Record(S.String, ExportEntry))
+}), [S.Record(S.String, S.Unknown)]);
+const VitestNodeModuleSchema = S.declare((input) => input !== null && typeof input === "object" && !Array.isArray(input), { description: "The project-local vitest/node module" });
+const VitestPackageSchema = S.Struct({ version: S.String });
 var VitestDryRunCommand = class extends S.TaggedClass()("VitestDryRunCommand", {
 	rawTests: S.Array(S.Unknown),
 	projectRoot: S.String,
 	hasExternalError: S.Boolean,
 	externalErrorText: S.String
 }) {};
-var VitestDryRunOutput = class extends S.TaggedClass()("VitestDryRunOutput", {
-	status: S.Literals(["Complete", "Error"]),
+var DryRunComplete = class extends S.TaggedClass()("Complete", { testsJson: S.String }) {};
+var DryRunExternalError = class extends S.TaggedClass()("Error", {
 	testsJson: S.String,
-	errorMessage: S.optional(S.String)
+	errorMessage: S.String
 }) {};
+//#endregion
+//#region src/Runner.ts
+var VitestHarness = class extends Context.Service()("VitestHarness") {};
+function fromTestId(id) {
+	const [file, ...name] = id.split("#");
+	return {
+		file,
+		test: name.join("#")
+	};
+}
+function normalizeTestId(id, projectRoot, pathService) {
+	const { file, test } = fromTestId(id);
+	return `${normalizeFileName(pathService.relative(projectRoot, file))}#${test}`;
+}
+function normalizeCoverage(rawCoverage, projectRoot, pathService) {
+	return {
+		perTest: Object.fromEntries(Object.entries(rawCoverage.perTest).map(([rawTestId, coverageData]) => [normalizeTestId(rawTestId, projectRoot, pathService), coverageData])),
+		static: rawCoverage.static
+	};
+}
+function collectTestsFromSuite(suite) {
+	return suite.tasks.flatMap((task) => {
+		if (task.type === "suite") return collectTestsFromSuite(task);
+		return task;
+	});
+}
+function isErrorCodeError(error) {
+	if (error instanceof Error && "code" in error) return typeof Reflect.get(error, "code") === "string";
+	return false;
+}
+const VITEST_ERROR_CODES = Object.freeze({ FILES_NOT_FOUND: "VITEST_FILES_NOT_FOUND" });
 const recordOption = (value) => S.decodeUnknownOption(S.Record(S.String, S.Unknown))(value);
 const getStringField = (record, key) => Option.fromNullishOr(record[key]).pipe(Option.filter((v) => typeof v === "string"));
 const getNumberField = (record, key) => Option.fromNullishOr(record[key]).pipe(Option.filter((v) => typeof v === "number"));
@@ -330,12 +382,6 @@ const toRawTestIdRaw = (test) => {
 		onSome: (file) => Option.getOrElse(Option.fromNullishOr(getFilepath(file)), () => "unknown.js")
 	})}#${collectTestNameRaw(test)}`;
 };
-/**
-* A test id is `<file>#<test name>`, and the file is reported relative to the
-* project root so an id is stable across machines and sandbox directories.
-* Vitest reports an absolute path, so the root prefix is stripped here rather
-* than resolved — a decision body has no path service and needs none.
-*/
 const normalizeTestIdRaw = (id, projectRoot) => {
 	const hash = id.indexOf("#");
 	if (hash === -1) return id;
@@ -420,134 +466,14 @@ const convertTestRaw = (test, projectRoot) => {
 		status
 	})));
 };
-const decideVitestDryRun = (command) => Match.value(command.rawTests.map((t) => convertTestRaw(t, command.projectRoot))).pipe(Match.when((tests) => tests.some((t) => t.status === "failed") === false && command.hasExternalError === true, (tests) => Result.succeed(VitestDryRunOutput.make({
-	status: "Error",
-	testsJson: JSON.stringify(tests),
-	errorMessage: `An error occurred outside of a test run: ${command.externalErrorText}`
-}))), Match.orElse((tests) => Result.succeed(VitestDryRunOutput.make({
-	status: "Complete",
-	testsJson: JSON.stringify(tests),
-	errorMessage: void 0
-}))));
-/**
-* The hit-limit cutoff: `Some` iff both numbers are present AND the count
-* strictly exceeds the limit. The boundary is `>` and not `>=` on purpose —
-* `hitCount === hitLimit` is the last permitted hit, not one too many.
-*/
-const hitLimitReason = (hitCount, hitLimit) => {
-	if (hitCount === void 0 || hitLimit === void 0) return Option.none();
-	if (hitCount > hitLimit) return Option.some(`Hit limit reached (${hitCount}/${hitLimit})`);
-	return Option.none();
-};
-const decideVitestMutantRun = (command) => Match.value(hitLimitReason(command.hitCount, command.hitLimit)).pipe(Match.when(Option.isSome, (hit) => Result.succeed(VitestMutantRunOutput.make({
-	status: "Timeout",
-	testsJson: "[]",
-	errorMessage: void 0,
-	killerIds: void 0,
-	failureMessage: void 0,
-	reason: hit.value
-}))), Match.when(Option.isNone, () => {
-	const dryOut = decideVitestDryRun(VitestDryRunCommand.make({
-		rawTests: command.rawTests,
-		projectRoot: command.projectRoot,
-		hasExternalError: command.hasExternalError,
-		externalErrorText: command.externalErrorText
-	}));
-	return Match.value(Result.isFailure(dryOut)).pipe(Match.when(true, () => Result.fail(new VitestMutantRunError({ message: "dry run mapping failed" }))), Match.when(false, () => {
-		const dry = Result.getOrElse(dryOut, () => VitestDryRunOutput.make({
-			status: "Complete",
-			testsJson: "[]",
-			errorMessage: void 0
-		}));
-		return Match.value(dry.status === "Error").pipe(Match.when(true, () => Result.succeed(VitestMutantRunOutput.make({
-			status: "Error",
-			testsJson: "[]",
-			errorMessage: dry.errorMessage,
-			killerIds: void 0,
-			failureMessage: void 0
-		}))), Match.when(false, () => {
-			const testsOption = Option.liftThrowable((input) => JSON.parse(input))(dry.testsJson).pipe(Option.filter((v) => Array.isArray(v)));
-			const killed = Option.getOrElse(testsOption, () => []).filter((t) => t.status === "failed");
-			return Match.value(killed.length > 0).pipe(Match.when(true, () => Match.value(command.reportAllKillers).pipe(Match.when(true, () => {
-				const firstKiller = Option.fromNullishOr(killed[0]);
-				const failureMessage = Option.match(firstKiller, {
-					onNone: () => void 0,
-					onSome: (k) => k.failureMessage
-				});
-				return Result.succeed(VitestMutantRunOutput.make({
-					status: "Killed",
-					testsJson: dry.testsJson,
-					errorMessage: void 0,
-					killerIds: killed.map((t) => t.id),
-					failureMessage
-				}));
-			}), Match.when(false, () => {
-				const first = Option.fromNullishOr(killed[0]);
-				const failureMessage = Option.match(first, {
-					onNone: () => void 0,
-					onSome: (k) => k.failureMessage
-				});
-				return Match.value(Option.isSome(first)).pipe(Match.when(true, () => Result.succeed(VitestMutantRunOutput.make({
-					status: "Killed",
-					testsJson: dry.testsJson,
-					errorMessage: void 0,
-					killerIds: Option.match(first, {
-						onNone: () => void 0,
-						onSome: (k) => [k.id]
-					}),
-					failureMessage
-				}))), Match.when(false, () => Result.succeed(VitestMutantRunOutput.make({
-					status: "Killed",
-					testsJson: dry.testsJson,
-					errorMessage: void 0,
-					killerIds: Option.getOrUndefined(Option.match(first, {
-						onNone: () => Option.none(),
-						onSome: (k) => Option.some([k.id])
-					})),
-					failureMessage
-				}))), Match.exhaustive);
-			}), Match.exhaustive)), Match.when(false, () => Result.succeed(VitestMutantRunOutput.make({
-				status: "Survived",
-				testsJson: dry.testsJson,
-				errorMessage: void 0,
-				killerIds: void 0,
-				failureMessage: void 0
-			}))), Match.exhaustive);
-		}), Match.exhaustive);
-	}), Match.exhaustive);
-}), Match.exhaustive);
-const vitestMutantRunWorkflow = Workflow.make(VitestMutantRunCommand, decideVitestMutantRun);
-//#endregion
-//#region src/Runner.ts
-function fromTestId(id) {
-	const [file, ...name] = id.split("#");
-	return {
-		file,
-		test: name.join("#")
-	};
-}
-function normalizeTestId(id, projectRoot, pathService) {
-	const { file, test } = fromTestId(id);
-	return `${normalizeFileName(pathService.relative(projectRoot, file))}#${test}`;
-}
-function normalizeCoverage(rawCoverage, projectRoot, pathService) {
-	return {
-		perTest: Object.fromEntries(Object.entries(rawCoverage.perTest).map(([rawTestId, coverageData]) => [normalizeTestId(rawTestId, projectRoot, pathService), coverageData])),
-		static: rawCoverage.static
-	};
-}
-function collectTestsFromSuite(suite) {
-	return suite.tasks.flatMap((task) => {
-		if (task.type === "suite") return collectTestsFromSuite(task);
-		return task;
+const decideVitestDryRun = (command) => {
+	const tests = command.rawTests.map((t) => convertTestRaw(t, command.projectRoot));
+	if (tests.some((t) => t.status === "failed") === false && command.hasExternalError) return DryRunExternalError.make({
+		testsJson: JSON.stringify(tests),
+		errorMessage: `An error occurred outside of a test run: ${command.externalErrorText}`
 	});
-}
-function isErrorCodeError(error) {
-	if (error instanceof Error && "code" in error) return typeof Reflect.get(error, "code") === "string";
-	return false;
-}
-/** @see https://github.com/vitest-dev/vitest/blob/main/packages/vitest/src/node/errors.ts */
-const VITEST_ERROR_CODES = Object.freeze({ FILES_NOT_FOUND: "VITEST_FILES_NOT_FOUND" });
+	return DryRunComplete.make({ testsJson: JSON.stringify(tests) });
+};
 const SOURCE_CONDITION = "@systemfsoftware/source";
 const sourceTargetOf = (entry) => {
 	if (typeof entry === "string") return (() => {
@@ -595,12 +521,6 @@ const readSandboxSelfAliases = (projectRoot) => Effect$1.gen(function* () {
 		onSome: (manifest) => sandboxSelfAliases(manifest, projectRoot, pathService)
 	});
 });
-/**
-* Vite records a package specifier as a bare dep. Vitest related-mode then
-* joins that specifier onto the project root, misses the file, and reports
-* zero tests. Returning the sandbox source path from `resolveId` makes the
-* dep a real filesystem path related-mode can walk.
-*/
 const sandboxSelfPlugin = (aliases) => ({
 	name: "stryker-sandbox-self-exports",
 	enforce: "pre",
@@ -608,27 +528,39 @@ const sandboxSelfPlugin = (aliases) => ({
 		for (const alias of aliases) if (alias.find.test(source)) return alias.replacement;
 	}
 });
-const readVitestVersion = (readPackageJson) => S.decodeUnknownSync(VitestPackageSchema)(readPackageJson()).version;
-/** Falls back to the Vitest bundled with this package when `dir` has none. */
-const resolveVitest = async (dir) => {
-	try {
-		const projectRequire = createRequire(path.join(dir, "package.json"));
-		const vitestNodePath = projectRequire.resolve("vitest/node");
-		const vitestNodeUrl = pathToFileURL(vitestNodePath).href;
+const isRunnerTestSuite = (value) => typeof value === "object" && value !== null && "tasks" in value && Array.isArray(Reflect.get(value, "tasks"));
+const STRYKER_SETUP_URL = new URL("./stryker-setup.mjs", import.meta.url);
+const resolveVitest = (_dir) => Effect$1.gen(function* () {
+	const fallback = Effect$1.gen(function* () {
+		const pathService = yield* Path.Path;
+		const fs = yield* FileSystem.FileSystem;
+		const urlString = import.meta.resolve("vitest/package.json");
+		const packageJsonPath = yield* pathService.fromFileUrl(new URL(urlString));
+		const content = yield* fs.readFileString(packageJsonPath);
+		const parsed = JSON.parse(content);
+		const decoded = yield* S.decodeUnknownEffect(VitestPackageSchema)(parsed);
 		return {
-			createVitest: S.decodeUnknownSync(VitestNodeModuleSchema)(await import(vitestNodeUrl)).createVitest,
-			version: readVitestVersion(() => projectRequire(projectRequire.resolve("vitest/package.json")))
+			createVitest,
+			version: decoded.version
 		};
-	} catch {
-		const bundledRequire = createRequire(import.meta.url);
+	}).pipe(Effect$1.orDie);
+	return yield* Effect$1.gen(function* () {
+		const module = yield* Module;
+		const pathService = yield* Path.Path;
+		const fs = yield* FileSystem.FileSystem;
+		const requireFromProject = module.createRequire(pathService.join(_dir, "package.json"));
+		const imported = requireFromProject("vitest/node");
+		const decodedNode = yield* S.decodeUnknownEffect(VitestNodeModuleSchema)(imported);
+		const packageJsonPath = requireFromProject.resolve("vitest/package.json");
+		const content = yield* fs.readFileString(packageJsonPath);
+		const parsed = JSON.parse(content);
+		const decodedPackage = yield* S.decodeUnknownEffect(VitestPackageSchema)(parsed);
 		return {
-			createVitest,
-			version: readVitestVersion(() => bundledRequire(bundledRequire.resolve("vitest/package.json")))
+			createVitest: decodedNode.createVitest,
+			version: decodedPackage.version
 		};
-	}
-};
-const isRunnerTestSuite = (value) => typeof value === "object" && value !== null && "tasks" in value && Array.isArray(Reflect.get(value, "tasks"));
-const STRYKER_SETUP = fileURLToPath(new URL("./stryker-setup.mjs", import.meta.url));
+	}).pipe(Effect$1.catchCause(() => fallback), Effect$1.catchDefect(() => fallback));
+}).pipe(Effect$1.orDie);
 const shouldUseSuiteMetaSecondArg = (version) => {
 	const parts = version.split(".");
 	const major = Number(parts[0] ?? "0");
@@ -704,6 +636,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 	});
 	const fsService = yield* FileSystem.FileSystem;
 	const pathService = yield* Path.Path;
+	const moduleService = yield* Module;
 	const getState = Ref.get(stateRef);
 	const requireCtx = Effect$1.gen(function* () {
 		const state = yield* getState;
@@ -739,20 +672,21 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			...s,
 			localSetupFile
 		}));
-		yield* fsService.copyFile(input.setupFilePath ?? STRYKER_SETUP, localSetupFile).pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
+		const defaultSetupPath = yield* pathService.fromFileUrl(STRYKER_SETUP_URL).pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
 			runnerName: "vitest",
 			phase: "init",
 			cause: errorToString(cause)
 		})));
-		const resolver = input.resolveVitestFor ?? resolveVitest;
-		const { createVitest, version } = yield* Effect$1.tryPromise({
-			try: () => resolver(projectRoot),
-			catch: (cause) => new TestRunnerFailed({
-				runnerName: "vitest",
-				phase: "init",
-				cause: errorToString(cause)
-			})
-		});
+		yield* fsService.copyFile(input.setupFilePath ?? defaultSetupPath, localSetupFile).pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
+			runnerName: "vitest",
+			phase: "init",
+			cause: errorToString(cause)
+		})));
+		const { createVitest, version } = yield* (input.resolveVitestFor ?? resolveVitest)(projectRoot).pipe(Effect$1.provideService(Module, moduleService), Effect$1.provideService(FileSystem.FileSystem, fsService), Effect$1.provideService(Path.Path, pathService), Effect$1.catchDefect((cause) => Effect$1.fail(new TestRunnerFailed({
+			runnerName: "vitest",
+			phase: "init",
+			cause: errorToString(cause)
+		}))));
 		const namespace = input.globalNamespace ?? INSTRUMENTER_CONSTANTS.NAMESPACE;
 		const scanDir = (() => {
 			if (typeof options.vitest.dir === "string") return pathService.resolve(projectRoot, options.vitest.dir);
@@ -803,7 +737,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		return new TestRunnerFailed({
 			runnerName: "vitest",
 			phase: "init",
-			cause
+			cause: errorToString(cause)
 		});
 	})()));
 	const resetContext = Effect$1.gen(function* () {
@@ -913,169 +847,173 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			})()
 		};
 	});
-	const dryRunDescription = pipe(Cell.read((command) => Effect$1.gen(function* () {
-		(yield* requireCtx).provide("mode", "dry-run");
-		const hasTestFiles = testFilesProvided(command);
+	const harnessImpl = {
+		setMode: (mode) => Effect$1.gen(function* () {
+			(yield* requireCtx).provide("mode", mode);
+		}),
+		provide: (key, value) => Effect$1.gen(function* () {
+			const ctx = yield* requireCtx;
+			if (key === "hitLimit") {
+				if (typeof value === "number" || value === void 0) ctx.provide("hitLimit", value);
+				else ctx.provide("hitLimit", void 0);
+			} else if (key === "mutantActivation") {
+				if (value === "runtime" || value === "static") ctx.provide("mutantActivation", value);
+			} else if (typeof value === "string") ctx.provide("activeMutant", value);
+		})
+	};
+	const mutantRunCell = Cell.layer({
+		read: (command) => Effect$1.gen(function* () {
+			const harness = yield* VitestHarness;
+			yield* harness.setMode("mutant");
+			yield* harness.provide("hitLimit", command.hitLimit);
+			yield* harness.provide("mutantActivation", command.mutantActivation);
+			yield* harness.provide("activeMutant", command.activeMutant.id);
+			const { rawTests, hasExternalError, externalErrorText } = yield* collectRaw({
+				testIds: (() => {
+					if (command.testFilter !== void 0) return [...command.testFilter];
+				})(),
+				relatedFiles: [command.sandboxFileName]
+			});
+			const hitCount = yield* readHitCount.pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
+				runnerName: "vitest",
+				phase: "mutantRun",
+				cause: errorToString(cause)
+			})), Effect$1.option, Effect$1.map(Option.getOrUndefined));
+			const reportAllKillers = (() => {
+				if (typeof input.options.disableBail === "boolean") return input.options.disableBail;
+				return false;
+			})();
+			if (hitCount === void 0) return {
+				rawTests,
+				projectRoot: input.sandboxDirectory,
+				hasExternalError,
+				externalErrorText,
+				hitLimit: command.hitLimit,
+				reportAllKillers
+			};
+			return {
+				rawTests,
+				projectRoot: input.sandboxDirectory,
+				hasExternalError,
+				externalErrorText,
+				hitCount,
+				hitLimit: command.hitLimit,
+				reportAllKillers
+			};
+		}),
+		decode: (raw) => {
+			const base = {
+				rawTests: raw.rawTests,
+				projectRoot: raw.projectRoot,
+				hasExternalError: raw.hasExternalError,
+				externalErrorText: raw.externalErrorText,
+				reportAllKillers: raw.reportAllKillers
+			};
+			if (raw.hitCount !== void 0) {
+				if (raw.hitLimit !== void 0) return Result.succeed(new VitestMutantRunCommand({
+					...base,
+					hitCount: raw.hitCount,
+					hitLimit: raw.hitLimit
+				}));
+				return Result.succeed(new VitestMutantRunCommand({
+					...base,
+					hitCount: raw.hitCount
+				}));
+			}
+			if (raw.hitLimit !== void 0) return Result.succeed(new VitestMutantRunCommand({
+				...base,
+				hitLimit: raw.hitLimit
+			}));
+			return Result.succeed(new VitestMutantRunCommand(base));
+		},
+		decide: interpretVitestRun,
+		encode: (outcome) => Result.match(outcome, {
+			onFailure: (e) => ({
+				status: "error",
+				errorMessage: e.message
+			}),
+			onSuccess: (out) => {
+				const nrOfTests = () => {
+					try {
+						const raw = JSON.parse(out.testsJson);
+						if (Array.isArray(raw)) return raw.filter(isIdRecord).length;
+						return 0;
+					} catch {
+						return 0;
+					}
+				};
+				return Match.value(out).pipe(Match.tag("Error", (error) => ({
+					status: "error",
+					errorMessage: error.errorMessage ?? "unknown"
+				})), Match.tag("Timeout", (timeout) => (() => {
+					if (timeout.reason === void 0) return { status: "timeout" };
+					return {
+						status: "timeout",
+						reason: timeout.reason
+					};
+				})()), Match.tag("Killed", (killed) => ({
+					status: "killed",
+					failureMessage: killed.failureMessage ?? "",
+					killedBy: (() => {
+						if (killed.killerIds !== void 0) return [...killed.killerIds];
+						return [];
+					})(),
+					nrOfTests: nrOfTests()
+				})), Match.tag("Survived", () => ({
+					status: "survived",
+					nrOfTests: nrOfTests()
+				})), Match.exhaustive);
+			}
+		}),
+		write: (output, _raw) => Effect$1.succeed(output)
+	});
+	const dryRun = (options) => Effect$1.gen(function* () {
+		yield* (yield* VitestHarness).setMode("dry-run");
+		const hasTestFiles = testFilesProvided(options);
 		const filter = (() => {
 			if (hasTestFiles) return {
-				testFiles: [...command.testFiles ?? []],
+				testFiles: [...options.testFiles ?? []],
 				relatedFiles: (() => {
-					if (command.files !== void 0) return [...command.files];
+					if (options.files !== void 0) return [...options.files];
 				})()
 			};
 			return { relatedFiles: (() => {
-				if (command.files !== void 0) return [...command.files];
+				if (options.files !== void 0) return [...options.files];
 			})() };
 		})();
 		const { rawTests, hasExternalError, externalErrorText } = yield* collectRaw(filter);
-		return {
+		const decision = decideVitestDryRun(new VitestDryRunCommand({
 			rawTests,
 			projectRoot: input.sandboxDirectory,
 			hasExternalError,
 			externalErrorText
-		};
-	})), Cell.decode((raw) => Result.succeed(new VitestDryRunCommand$1({
-		rawTests: raw.rawTests,
-		projectRoot: raw.projectRoot,
-		hasExternalError: raw.hasExternalError,
-		externalErrorText: raw.externalErrorText
-	}))), Cell.decide(vitestDryRunWorkflow), Cell.encode((outcome) => Result.match(outcome, {
-		onFailure: (e) => ({
+		}));
+		const result = Match.value(decision).pipe(Match.tag("Error", (error) => ({
 			status: "error",
-			errorMessage: e.message
-		}),
-		onSuccess: (out) => {
-			const raw = JSON.parse(out.testsJson);
+			errorMessage: error.errorMessage
+		})), Match.tag("Complete", (complete) => {
+			const raw = JSON.parse(complete.testsJson);
 			let tests;
 			if (Array.isArray(raw)) tests = raw.filter(isTestResultLike);
 			else tests = [];
-			if (out.status === "Error") return {
-				status: "error",
-				errorMessage: out.errorMessage ?? "unknown"
-			};
 			return {
 				status: "complete",
 				tests
 			};
-		}
-	})), Cell.write((output) => Effect$1.gen(function* () {
-		if (output.status === "complete") {
+		}), Match.exhaustive);
+		if (result.status === "complete") {
 			const mutantCoverage = yield* readMutantCoverage.pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
 				runnerName: "vitest",
 				phase: "dryRun",
 				cause: errorToString(cause)
 			})));
 			if (mutantCoverage !== void 0) return {
-				...output,
+				...result,
 				mutantCoverage
 			};
 		}
-		return output;
-	})));
-	const mutantRunDescription = pipe(Cell.read((command) => Effect$1.gen(function* () {
-		const ctx = yield* requireCtx;
-		ctx.provide("mode", "mutant");
-		ctx.provide("hitLimit", command.hitLimit);
-		ctx.provide("mutantActivation", command.mutantActivation);
-		ctx.provide("activeMutant", command.activeMutant.id);
-		const { rawTests, hasExternalError, externalErrorText } = yield* collectRaw({
-			testIds: (() => {
-				if (command.testFilter !== void 0) return [...command.testFilter];
-			})(),
-			relatedFiles: [command.sandboxFileName]
-		});
-		const hitCount = yield* readHitCount.pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "mutantRun",
-			cause: errorToString(cause)
-		})), Effect$1.option, Effect$1.map(Option.getOrUndefined));
-		const reportAllKillers = (() => {
-			if (typeof input.options.disableBail === "boolean") return input.options.disableBail;
-			return false;
-		})();
-		if (hitCount === void 0) return {
-			rawTests,
-			projectRoot: input.sandboxDirectory,
-			hasExternalError,
-			externalErrorText,
-			hitLimit: command.hitLimit,
-			reportAllKillers
-		};
-		return {
-			rawTests,
-			projectRoot: input.sandboxDirectory,
-			hasExternalError,
-			externalErrorText,
-			hitCount,
-			hitLimit: command.hitLimit,
-			reportAllKillers
-		};
-	})), Cell.decode((raw) => {
-		const base = {
-			rawTests: raw.rawTests,
-			projectRoot: raw.projectRoot,
-			hasExternalError: raw.hasExternalError,
-			externalErrorText: raw.externalErrorText,
-			reportAllKillers: raw.reportAllKillers
-		};
-		if (raw.hitCount !== void 0) {
-			if (raw.hitLimit !== void 0) return Result.succeed(new VitestMutantRunCommand({
-				...base,
-				hitCount: raw.hitCount,
-				hitLimit: raw.hitLimit
-			}));
-			return Result.succeed(new VitestMutantRunCommand({
-				...base,
-				hitCount: raw.hitCount
-			}));
-		}
-		if (raw.hitLimit !== void 0) return Result.succeed(new VitestMutantRunCommand({
-			...base,
-			hitLimit: raw.hitLimit
-		}));
-		return Result.succeed(new VitestMutantRunCommand(base));
-	}), Cell.decide(vitestMutantRunWorkflow), Cell.encode((outcome) => Result.match(outcome, {
-		onFailure: (e) => ({
-			status: "error",
-			errorMessage: e.message
-		}),
-		onSuccess: (out) => {
-			let parsed;
-			try {
-				const raw = JSON.parse(out.testsJson);
-				if (Array.isArray(raw)) parsed = raw.filter(isIdRecord);
-				else parsed = [];
-			} catch {
-				parsed = [];
-			}
-			const nrOfTests = parsed.length;
-			if (out.status === "Error") return {
-				status: "error",
-				errorMessage: out.errorMessage ?? "unknown"
-			};
-			if (out.status === "Timeout") {
-				if (out.reason === void 0) return { status: "timeout" };
-				return {
-					status: "timeout",
-					reason: out.reason
-				};
-			}
-			if (out.status === "Killed") return {
-				status: "killed",
-				failureMessage: out.failureMessage ?? "",
-				killedBy: (() => {
-					if (out.killerIds !== void 0) return [...out.killerIds];
-					return [];
-				})(),
-				nrOfTests
-			};
-			return {
-				status: "survived",
-				nrOfTests
-			};
-		}
-	})), Cell.write((output) => Effect$1.succeed(output)));
-	const dryRun = (options) => Cell.apply(dryRunDescription, options).pipe(Effect$1.mapError((cause) => (() => {
+		return result;
+	}).pipe(Effect$1.provideService(VitestHarness, harnessImpl), Effect$1.mapError((cause) => (() => {
 		if (cause instanceof TestRunnerFailed) return cause;
 		return new TestRunnerFailed({
 			runnerName: "vitest",
@@ -1083,7 +1021,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			cause: errorToString(cause)
 		});
 	})()));
-	const mutantRun = (options) => Cell.apply(mutantRunDescription, options).pipe(Effect$1.mapError((cause) => (() => {
+	const mutantRun = (options) => Cell.run(mutantRunCell, options).pipe(Effect$1.provideService(VitestHarness, harnessImpl), Effect$1.mapError((cause) => (() => {
 		if (cause instanceof TestRunnerFailed) return cause;
 		return new TestRunnerFailed({
 			runnerName: "vitest",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-vitest-runner",
-  "version": "2.0.2",
+  "version": "3.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -31,8 +31,8 @@
     "coverageAnalysis": "perTest"
   },
   "dependencies": {
-    "@systemfsoftware/effect-cell-types": "^5.0.2",
-    "@systemfsoftware/stryker-js": "^0.1.1"
+    "@systemfsoftware/stryker-js": "^1.0.0",
+    "@systemfsoftware/effect-cell-types": "^6.0.0"
   },
   "peerDependencies": {
     "effect": "^4.0.0-rc.112",
@@ -50,7 +50,7 @@
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/all": "^1.0.2",
+    "@systemfsoftware/all": "^1.1.2",
     "@systemfsoftware/effect-gherkin-spec": "^4.0.0",
     "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/tsconfig": "^1.3.3",