@systemfsoftware/stryker-js-vitest-runner 2.1.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,100 @@
 # @systemfsoftware/stryker-js-vitest-runner
 
+## 4.0.0
+
+### Major Changes
+
+- The packages are renamed. `plugin-api` is now `@systemfsoftware/stryker-js`, the
+  language every plugin is written against. `mutation-run` is split: the run
+  itself is `@systemfsoftware/stryker-js-engine`
+  (host-neutral, no Node on its manifest) and the Node process entries are
+  `@systemfsoftware/stryker-js-cli`, which owns the worker files and the runtime
+  gate. `mutation-report` is now `@systemfsoftware/stryker-js-html-reporter`.
+  `@systemfsoftware/stryker-js-platform-node` is never published — do not install
+  it. Install the new names and change your imports.
+
+  Options types moved. `StrykerOptions`, `PartialStrykerOptions` and `LogLevel` are
+  imported from the `Schema` export; `Mutant`, `MutantStatus`, `Position` and
+  `Location` from the `Mutant` export. Point a config's `extends` at the language
+  package's `Schema` export.
+
+  `MutantStatus` accepts one spelling per outcome: `Killed`, `Survived`,
+  `NoCoverage`, `Timeout`, `CompileError`, `RuntimeError`, `Ignored` and `Pending`.
+  The lowercase and abbreviated forms — `killed`, `timedOut`, `noCoverage` and the
+  rest — are gone. A comparison against a removed spelling never matched the value
+  the reporter actually produced, so check any status comparison you wrote.
+
+  Statuses, plugin kinds, exit classes and AST formats are string literal unions
+  rather than enums, so read them as their string values. Member access such as
+  `ExitClass.VerdictFail` no longer resolves.
+
+  A plugin no longer receives a logger, and the logger port is gone. Plugins log
+  through Effect, and the host decides where that output goes.
+
+  The bundled base preset is gone. A config inherits from the language package's
+  `Schema` export and states the thresholds, reporters and plugins it wants; you no
+  longer silently inherit a package manager, a plugin list or a break threshold.
+
+- effect is now a required peer dependency. Install it alongside these packages. They previously bundled their own copy, which meant two Effect instances in one process and services that could not find each other across the boundary.
+
+### Minor Changes
+
+- Machine-readable mutation progress is a newline-delimited JSON file next to the HTML and JSON reports, not the console.
+
+  The console prints bounded progress prose: phase names, a count line, at most twenty surviving mutants, and a verdict. Killed mutants now advance that count. Child test runs during mutation no longer print per-test output or GitHub workflow commands.
+
+  If you parsed the console as JSON lines, read the stream file instead. A hard kill can leave that file without a closing verdict line.
+
+### Patch Changes
+
+- New version is published through npm trusted publishing, so it carries a provenance attestation you can verify.
+
+- Peer Effect requirement advances to 4.0.0-rc.112. No API changes.
+
+- A mutation run writes the JSON report the `json` reporter is configured to produce.
+
+  Vitest no longer reprints its full summary for every mutant.
+
+- Each of these packages now has a README, so its registry page says what the package is, how
+  to install it, and what to import or register — previously the page was blank. The lint
+  plugins show the configuration line that enables what they recommend.
+
+  `@systemfsoftware/stryker-js-html-reporter` also carries its licence text
+
+- The shared helpers package is gone. Nothing installs it any more, and the
+  handful of helpers worth sharing now live in the plugin contract next to the
+  types they serve:
+
+  - `strykerReportBugUrl`, `normalizeFileName`, `propertyPath`, `errorToString`
+    and `isErrnoException` from `@systemfsoftware/stryker-js/core`
+  - `noopLogger` from `@systemfsoftware/stryker-js/logging`
+  - `testFilesProvided` from `@systemfsoftware/stryker-js/test-runner`
+
+  If you imported any of those, change the specifier. Everything else it exported
+  had no consumer and is removed: use `Predicate.isNotNullish` from Effect in place
+  of `notEmpty`, and `RegExp.escape` in place of `escapeRegExp`.
+
+- These packages no longer install dependencies they never imported, so installing them pulls less into your tree.
+
+  `tslib` is gone from all six. The mutation runner additionally stops installing `lodash.groupby`, `semver` and `source-map`, and the command line interface stops installing `@effect/platform-node-shared`. Nothing exported changes.
+
+- Published packages no longer carry build artifacts left over from earlier builds. One package was shipping about a megabyte of bundled test-runner internals this way.
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js@2.0.0
+
+## 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

package/dist/index.mjs

@@ -7,81 +7,61 @@ 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"));
@@ -130,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;
@@ -220,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"));
@@ -327,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;
@@ -417,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 (() => {
@@ -592,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",
@@ -924,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",
@@ -1094,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,12 +1,12 @@
 {
   "name": "@systemfsoftware/stryker-js-vitest-runner",
-  "version": "2.1.0",
+  "version": "4.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
-    "directory": "packages/testing/mutation/stryker-js/vitest-runner"
+    "directory": "packages/stryker-js/stryker-js-vitest-runner"
   },
-  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/testing/mutation/stryker-js/vitest-runner#readme",
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/stryker-js/stryker-js-vitest-runner#readme",
   "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
   "description": "Vitest test-runner plugin for Stryker",
   "type": "module",
@@ -31,8 +31,8 @@
     "coverageAnalysis": "perTest"
   },
   "dependencies": {
-    "@systemfsoftware/effect-cell-types": "^5.0.2",
-    "@systemfsoftware/stryker-js": "^0.2.0"
+    "@systemfsoftware/effect-cell-types": "^6.0.1",
+    "@systemfsoftware/stryker-js": "^2.0.0"
   },
   "peerDependencies": {
     "effect": "^4.0.0-rc.112",
@@ -50,12 +50,11 @@
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/all": "^1.1.0",
-    "@systemfsoftware/effect-gherkin-spec": "^4.0.0",
+    "@systemfsoftware/effect-gherkin-spec": "^4.0.1",
     "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/stryker-js-platform-node": "^0.2.0",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/all": "^1.1.3"
   },
   "publishConfig": {
     "provenance": true