@systemfsoftware/stryker-js-vitest-runner 1.0.0 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @systemfsoftware/stryker-js-vitest-runner
 
+## 2.0.0
+
+### Major Changes
+
+- Three packages are renamed. `plugin-api` is now `@systemfsoftware/stryker-js`, the
+  language every plugin is written against. `mutation-run` is now
+  `@systemfsoftware/stryker-js-platform-node`, the Node host that runs a mutation
+  test. `mutation-report` is now `@systemfsoftware/stryker-js-html-reporter`.
+  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.
+
+### 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
+
+- A mutation run writes the JSON report the `json` reporter is configured to produce.
+
+  Vitest no longer reprints its full summary for every mutant.
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@5.0.0
+
 ## 1.0.0
 
 ### Major Changes

package/dist/index.d.mts

@@ -1,4 +1,3 @@
-import { PluginKind } from "@systemfsoftware/stryker-js-plugin-api/plugin";
 //#region src/index.d.ts
 /**
  * The `vitest` test runner, as the plugin the engine loads.
@@ -7,7 +6,7 @@ import { PluginKind } from "@systemfsoftware/stryker-js-plugin-api/plugin";
  * in, so the requirement is visible in the type and an engine that does not
  * provide it fails to compile.
  */
-declare const strykerPlugins: import("@systemfsoftware/stryker-js-plugin-api/plugin").PluginContribution<PluginKind.TestRunner>[];
+declare const strykerPlugins: import("@systemfsoftware/stryker-js/Plugin").PluginContribution<"TestRunner">[];
 /**
  * The `vitest` option section as a JSON Schema document, for Stryker's option
  * validation — derived from the declaration, never read from a file. It is built

package/dist/index.mjs

@@ -1,20 +1,31 @@
-import { PluginKind, RunConfiguration, SandboxDirectory, declarePlugin } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { RunConfiguration, SandboxDirectory, declarePlugin } from "@systemfsoftware/stryker-js/Plugin";
 import * as Effect$1 from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as S from "effect/Schema";
-import { Effect, Option } from "effect";
-import { INSTRUMENTER_CONSTANTS, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js-plugin-api/core";
-import { DryRunStatus, TestRunner, TestRunnerFailed, TestStatus, determineHitLimitReached, testFilesProvided, toMutantRunResult } from "@systemfsoftware/stryker-js-plugin-api/test-runner";
-import * as FileSystem from "effect/FileSystem";
-import * as Option$1 from "effect/Option";
-import * as Path from "effect/Path";
-import * as Ref from "effect/Ref";
-import { fileURLToPath } from "url";
 import { createRequire } from "module";
 import { pathToFileURL } from "node:url";
 import path from "path";
+import { fileURLToPath } from "url";
 import { createVitest } from "vitest/node";
-//#region src/vitest-runner-options.schema.ts
+import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
+import { INSTRUMENTER_CONSTANTS, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js/Mutant";
+import { TestRunner, TestRunnerFailed, testFilesProvided } from "@systemfsoftware/stryker-js/TestRunner";
+import * as FileSystem from "effect/FileSystem";
+import { pipe } from "effect/Function";
+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.
@@ -29,24 +40,527 @@ const VitestRunnerOptionsSchema = S.Struct({
 * document, or present as a partial, and decoded into the section defaults.
 */
 const VitestSectionSchema = S.optional(VitestRunnerOptionsSchema).pipe(S.withDecodingDefault(Effect.succeed({ related: true })));
-//#endregion
-//#region src/sandbox-self-aliases.schema.ts
+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`.
+*/
+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", {
+	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"));
+const getSuite$1 = (value) => recordOption$1(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["suite"])));
+const getFile$1 = (value) => recordOption$1(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["file"])));
+const getResult$1 = (value) => recordOption$1(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["result"])));
+const getErrors$1 = (value) => recordOption$1(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["errors"])), Option.filter((v) => Array.isArray(v)));
+const getMessage$1 = (value) => recordOption$1(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["message"])), Option.filter((v) => typeof v === "string"));
+const getName$1 = (value) => Option.match(recordOption$1(value), {
+	onNone: () => "",
+	onSome: (rec) => Option.getOrElse(getStringField$1(rec, "name"), () => "")
+});
+const getMode$1 = (value) => Option.match(recordOption$1(value), {
+	onNone: () => "run",
+	onSome: (rec) => Option.getOrElse(getStringField$1(rec, "mode"), () => "run")
+});
+const getState$1 = (value) => Match.value(value).pipe(Match.when("pass", () => "pass"), Match.when("fail", () => "fail"), Match.when("skip", () => "skip"), Match.when("todo", () => "todo"), Match.when("run", () => "run"), Match.when("queued", () => "queued"), Match.when("only", () => "only"), Match.when(void 0, () => void 0), Match.orElse(() => void 0));
+const getDuration$1 = (value) => Option.match(recordOption$1(value), {
+	onNone: () => 0,
+	onSome: (rec) => Option.getOrElse(getNumberField$1(rec, "duration"), () => 0)
+});
+const getFilepath$1 = (value) => Option.match(recordOption$1(value), {
+	onNone: () => void 0,
+	onSome: (rec) => Option.getOrUndefined(Option.fromNullishOr(rec["filepath"]).pipe(Option.filter((v) => typeof v === "string")))
+});
+const collectSuiteNames$1 = (suite) => Option.match(Option.fromNullishOr(suite), {
+	onNone: () => [],
+	onSome: (current) => Option.match(recordOption$1(current), {
+		onNone: () => [],
+		onSome: (rec) => {
+			const name = Option.getOrElse(getStringField$1(rec, "name"), () => "");
+			const hasName = name.length > 0;
+			const parentNames = collectSuiteNames$1(rec["suite"]);
+			return Match.value(hasName).pipe(Match.when(true, () => [...parentNames, name]), Match.when(false, () => parentNames), Match.exhaustive);
+		}
+	})
+});
+const collectTestNameRaw$1 = (test) => {
+	const name = getName$1(test);
+	const suite = Option.getOrUndefined(getSuite$1(test));
+	return [...collectSuiteNames$1(suite), name].join(" ").trim();
+};
+const toRawTestIdRaw$1 = (test) => {
+	return `${Option.match(getFile$1(test), {
+		onNone: () => "unknown.js",
+		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;
+	const file = id.slice(0, hash);
+	const rest = id.slice(hash + 1);
+	return `${(() => {
+		if (file.startsWith(projectRoot)) return file.slice(projectRoot.length);
+		return file;
+	})().replace(/^[/\\]+/, "").replaceAll("\\", "/")}#${rest}`;
+};
+const toTestStatus$1 = (taskState, mode) => Match.value(mode === "skip").pipe(Match.when(true, () => "skipped"), Match.when(false, () => Match.value(taskState).pipe(Match.when("pass", () => "success"), Match.when("fail", () => "failed"), Match.when("skip", () => "skipped"), Match.when("todo", () => "skipped"), Match.when(void 0, () => "failed"), Match.when("queued", () => "failed"), Match.when("run", () => "failed"), Match.when("only", () => "failed"), Match.orElse(() => "failed"))), Match.exhaustive);
+const findSuiteErrorRaw$1 = (suite) => Option.match(Option.fromNullishOr(suite), {
+	onNone: () => void 0,
+	onSome: (current) => Option.match(recordOption$1(current), {
+		onNone: () => void 0,
+		onSome: (rec) => {
+			const maybeError = Option.flatMap(getResult$1(rec), (result) => Option.flatMap(getErrors$1(result), (errs) => Match.value(errs.length > 0).pipe(Match.when(true, () => Option.flatMap(Option.fromNullishOr(errs[0]), (first) => getMessage$1(first))), Match.when(false, () => Option.none()), Match.exhaustive)));
+			return Option.match(maybeError, {
+				onNone: () => findSuiteErrorRaw$1(rec["suite"]),
+				onSome: (msg) => msg
+			});
+		}
+	})
+});
+const extractStatus$1 = (test) => {
+	const result = Option.getOrUndefined(getResult$1(test));
+	const mode = getMode$1(test);
+	const state = Option.match(Option.fromNullishOr(result), {
+		onNone: () => void 0,
+		onSome: (r) => Option.match(recordOption$1(r), {
+			onNone: () => void 0,
+			onSome: (rec) => getState$1(rec["state"])
+		})
+	});
+	return toTestStatus$1(state, mode);
+};
+const extractDuration$1 = (test) => Option.match(getResult$1(test), {
+	onNone: () => 0,
+	onSome: (result) => Option.match(recordOption$1(result), {
+		onNone: () => 0,
+		onSome: (rec) => getDuration$1(rec)
+	})
+});
+const extractFileName$1 = (test) => Option.match(getFile$1(test), {
+	onNone: () => void 0,
+	onSome: (file) => getFilepath$1(file)
+});
+const extractRawId$1 = (test, projectRoot) => normalizeTestIdRaw$1(toRawTestIdRaw$1(test), projectRoot);
+const extractName$1 = (test) => collectTestNameRaw$1(test);
+const extractFailureMessage$1 = (test) => Option.match(getResult$1(test), {
+	onNone: () => "StrykerJS: Unknown test failure",
+	onSome: (result) => Option.match(getErrors$1(result), {
+		onNone: () => "StrykerJS: Unknown test failure",
+		onSome: (errs) => Match.value(errs.length > 0).pipe(Match.when(true, () => Option.match(Option.fromNullishOr(errs[0]), {
+			onNone: () => "StrykerJS: Unknown test failure",
+			onSome: (first) => Option.getOrElse(getMessage$1(first), () => "StrykerJS: Unknown test failure")
+		})), Match.when(false, () => "StrykerJS: Unknown test failure"), Match.exhaustive)
+	})
+});
+const convertTestRaw$1 = (test, projectRoot) => {
+	const status = extractStatus$1(test);
+	const base = {
+		id: extractRawId$1(test, projectRoot),
+		name: extractName$1(test),
+		timeSpentMs: extractDuration$1(test),
+		fileName: extractFileName$1(test),
+		status
+	};
+	return Match.value(status).pipe(Match.when("failed", () => ({
+		...base,
+		status,
+		failureMessage: extractFailureMessage$1(test)
+	})), Match.when("skipped", () => Match.value(findSuiteErrorRaw$1(Option.getOrUndefined(getSuite$1(test)))).pipe(Match.when(Match.defined, (suiteError) => ({
+		...base,
+		status: "failed",
+		failureMessage: suiteError
+	})), Match.orElse(() => ({
+		...base,
+		status
+	})))), Match.orElse(() => ({
+		...base,
+		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 vitestDryRunWorkflow = Workflow.make(VitestDryRunCommand$1, decideVitestDryRun$1);
 //#endregion
-//#region src/sandbox-self-aliases.ts
+//#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 }) {};
+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"]),
+	testsJson: S.String,
+	errorMessage: S.optional(S.String)
+}) {};
+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"));
+const getSuite = (value) => recordOption(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["suite"])));
+const getFile = (value) => recordOption(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["file"])));
+const getResult = (value) => recordOption(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["result"])));
+const getErrors = (value) => recordOption(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["errors"])), Option.filter((v) => Array.isArray(v)));
+const getMessage = (value) => recordOption(value).pipe(Option.flatMap((rec) => Option.fromNullishOr(rec["message"])), Option.filter((v) => typeof v === "string"));
+const getName = (value) => Option.match(recordOption(value), {
+	onNone: () => "",
+	onSome: (rec) => Option.getOrElse(getStringField(rec, "name"), () => "")
+});
+const getMode = (value) => Option.match(recordOption(value), {
+	onNone: () => "run",
+	onSome: (rec) => Option.getOrElse(getStringField(rec, "mode"), () => "run")
+});
+const getState = (value) => Match.value(value).pipe(Match.when("pass", () => "pass"), Match.when("fail", () => "fail"), Match.when("skip", () => "skip"), Match.when("todo", () => "todo"), Match.when("run", () => "run"), Match.when("queued", () => "queued"), Match.when("only", () => "only"), Match.when(void 0, () => void 0), Match.orElse(() => void 0));
+const getDuration = (value) => Option.match(recordOption(value), {
+	onNone: () => 0,
+	onSome: (rec) => Option.getOrElse(getNumberField(rec, "duration"), () => 0)
+});
+const getFilepath = (value) => Option.match(recordOption(value), {
+	onNone: () => void 0,
+	onSome: (rec) => Option.getOrUndefined(Option.fromNullishOr(rec["filepath"]).pipe(Option.filter((v) => typeof v === "string")))
+});
+const collectSuiteNames = (suite) => Option.match(Option.fromNullishOr(suite), {
+	onNone: () => [],
+	onSome: (current) => Option.match(recordOption(current), {
+		onNone: () => [],
+		onSome: (rec) => {
+			const name = Option.getOrElse(getStringField(rec, "name"), () => "");
+			const hasName = name.length > 0;
+			const parentNames = collectSuiteNames(rec["suite"]);
+			return Match.value(hasName).pipe(Match.when(true, () => [...parentNames, name]), Match.when(false, () => parentNames), Match.exhaustive);
+		}
+	})
+});
+const collectTestNameRaw = (test) => {
+	const name = getName(test);
+	const suite = Option.getOrUndefined(getSuite(test));
+	return [...collectSuiteNames(suite), name].join(" ").trim();
+};
+const toRawTestIdRaw = (test) => {
+	return `${Option.match(getFile(test), {
+		onNone: () => "unknown.js",
+		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;
+	const file = id.slice(0, hash);
+	const rest = id.slice(hash + 1);
+	return `${(() => {
+		if (file.startsWith(projectRoot)) return file.slice(projectRoot.length);
+		return file;
+	})().replace(/^[/\\]+/, "").replaceAll("\\", "/")}#${rest}`;
+};
+const toTestStatus = (taskState, mode) => Match.value(mode === "skip").pipe(Match.when(true, () => "skipped"), Match.when(false, () => Match.value(taskState).pipe(Match.when("pass", () => "success"), Match.when("fail", () => "failed"), Match.when("skip", () => "skipped"), Match.when("todo", () => "skipped"), Match.when(void 0, () => "failed"), Match.when("queued", () => "failed"), Match.when("run", () => "failed"), Match.when("only", () => "failed"), Match.orElse(() => "failed"))), Match.exhaustive);
+const findSuiteErrorRaw = (suite) => Option.match(Option.fromNullishOr(suite), {
+	onNone: () => void 0,
+	onSome: (current) => Option.match(recordOption(current), {
+		onNone: () => void 0,
+		onSome: (rec) => {
+			const maybeError = Option.flatMap(getResult(rec), (result) => Option.flatMap(getErrors(result), (errs) => Match.value(errs.length > 0).pipe(Match.when(true, () => Option.flatMap(Option.fromNullishOr(errs[0]), (first) => getMessage(first))), Match.when(false, () => Option.none()), Match.exhaustive)));
+			return Option.match(maybeError, {
+				onNone: () => findSuiteErrorRaw(rec["suite"]),
+				onSome: (msg) => msg
+			});
+		}
+	})
+});
+const extractStatus = (test) => {
+	const result = Option.getOrUndefined(getResult(test));
+	const mode = getMode(test);
+	const state = Option.match(Option.fromNullishOr(result), {
+		onNone: () => void 0,
+		onSome: (r) => Option.match(recordOption(r), {
+			onNone: () => void 0,
+			onSome: (rec) => getState(rec["state"])
+		})
+	});
+	return toTestStatus(state, mode);
+};
+const extractDuration = (test) => Option.match(getResult(test), {
+	onNone: () => 0,
+	onSome: (result) => Option.match(recordOption(result), {
+		onNone: () => 0,
+		onSome: (rec) => getDuration(rec)
+	})
+});
+const extractFileName = (test) => Option.match(getFile(test), {
+	onNone: () => void 0,
+	onSome: (file) => getFilepath(file)
+});
+const extractRawId = (test, projectRoot) => normalizeTestIdRaw(toRawTestIdRaw(test), projectRoot);
+const extractName = (test) => collectTestNameRaw(test);
+const extractFailureMessage = (test) => Option.match(getResult(test), {
+	onNone: () => "StrykerJS: Unknown test failure",
+	onSome: (result) => Option.match(getErrors(result), {
+		onNone: () => "StrykerJS: Unknown test failure",
+		onSome: (errs) => Match.value(errs.length > 0).pipe(Match.when(true, () => Option.match(Option.fromNullishOr(errs[0]), {
+			onNone: () => "StrykerJS: Unknown test failure",
+			onSome: (first) => Option.getOrElse(getMessage(first), () => "StrykerJS: Unknown test failure")
+		})), Match.when(false, () => "StrykerJS: Unknown test failure"), Match.exhaustive)
+	})
+});
+const convertTestRaw = (test, projectRoot) => {
+	const status = extractStatus(test);
+	const base = {
+		id: extractRawId(test, projectRoot),
+		name: extractName(test),
+		timeSpentMs: extractDuration(test),
+		fileName: extractFileName(test),
+		status
+	};
+	return Match.value(status).pipe(Match.when("failed", () => ({
+		...base,
+		status,
+		failureMessage: extractFailureMessage(test)
+	})), Match.when("skipped", () => Match.value(findSuiteErrorRaw(Option.getOrUndefined(getSuite(test)))).pipe(Match.when(Match.defined, (suiteError) => ({
+		...base,
+		status: "failed",
+		failureMessage: suiteError
+	})), Match.orElse(() => ({
+		...base,
+		status
+	})))), Match.orElse(() => ({
+		...base,
+		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;
+	});
+}
+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" });
 const SOURCE_CONDITION = "@systemfsoftware/source";
 const sourceTargetOf = (entry) => {
-	if (typeof entry === "string") return entry.endsWith(".ts") || entry.endsWith(".tsx") || entry.endsWith(".mts") ? entry : void 0;
+	if (typeof entry === "string") return (() => {
+		if (entry.endsWith(".ts") || entry.endsWith(".tsx") || entry.endsWith(".mts")) return entry;
+	})();
 	const source = entry[SOURCE_CONDITION];
-	return typeof source === "string" ? source : void 0;
+	return (() => {
+		if (typeof source === "string") return source;
+	})();
 };
 const specifierForExport = (packageName, exportKey) => {
 	if (exportKey === ".") return packageName;
-	if (exportKey === "./package.json" || !exportKey.startsWith("./")) return;
+	if (exportKey === "./package.json" || !exportKey.startsWith("./")) return void 0;
 	return `${packageName}/${exportKey.slice(2)}`;
 };
 const sandboxSelfAliases = (manifest, projectRoot, pathService) => {
@@ -87,117 +601,13 @@ const readSandboxSelfAliases = (projectRoot) => Effect$1.gen(function* () {
 * zero tests. Returning the sandbox source path from `resolveId` makes the
 * dep a real filesystem path related-mode can walk.
 */
-const sandboxSelfPlugin = (aliases) => {
-	return {
-		name: "stryker-sandbox-self-exports",
-		enforce: "pre",
-		resolveId(source) {
-			for (const alias of aliases) if (alias.find.test(source)) return alias.replacement;
-		}
-	};
-};
-//#endregion
-//#region src/test-identity.ts
-function collectTestName({ name, suite }) {
-	const nameParts = [name];
-	let currentSuite = suite;
-	while (currentSuite) {
-		nameParts.unshift(currentSuite.name);
-		currentSuite = currentSuite.suite;
-	}
-	return nameParts.join(" ").trim();
-}
-function toRawTestId(test) {
-	return `${test.file?.filepath ?? "unknown.js"}#${collectTestName(test)}`;
-}
-//#endregion
-//#region src/vitest-task-mapping.ts
-function convertTaskStateToTestStatus(taskState, testMode) {
-	if (testMode === "skip") return TestStatus.Skipped;
-	switch (taskState) {
-		case "pass": return TestStatus.Success;
-		case "fail": return TestStatus.Failed;
-		case "skip":
-		case "todo": return TestStatus.Skipped;
-		case void 0:
-		case "queued":
-		case "run":
-		case "only": return TestStatus.Failed;
+const sandboxSelfPlugin = (aliases) => ({
+	name: "stryker-sandbox-self-exports",
+	enforce: "pre",
+	resolveId(source) {
+		for (const alias of aliases) if (alias.find.test(source)) return alias.replacement;
 	}
-}
-function convertTestToTestResult(test, projectRoot, pathService) {
-	const status = convertTaskStateToTestStatus(test.result?.state, test.mode);
-	const baseTestResult = {
-		id: normalizeTestId(toRawTestId(test), projectRoot, pathService),
-		name: collectTestName(test),
-		timeSpentMs: test.result?.duration ?? 0,
-		fileName: test.file?.filepath && pathService.resolve(test.file.filepath)
-	};
-	if (status === TestStatus.Failed) return {
-		...baseTestResult,
-		status,
-		failureMessage: test.result?.errors?.[0]?.message ?? "StrykerJS: Unknown test failure"
-	};
-	else if (status === TestStatus.Skipped) {
-		const suiteError = findSuiteError(test.suite);
-		if (suiteError) return {
-			...baseTestResult,
-			status: TestStatus.Failed,
-			failureMessage: suiteError
-		};
-	}
-	return {
-		...baseTestResult,
-		status
-	};
-}
-function findSuiteError(suite) {
-	if (!suite) return;
-	if (suite.result?.state === "fail") return suite.result?.errors?.[0]?.message ?? "StrykerJS: Suite execution failed";
-	return findSuiteError(suite.suite);
-}
-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);
-		else if (task.type === "test") return task;
-		else return [];
-	});
-}
-function isErrorCodeError(error) {
-	return error instanceof Error && "code" in error && typeof error.code === "string";
-}
-/** @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" });
-//#endregion
-//#region src/vitest-wrapper.schema.ts
-/**
-* 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/vitest-wrapper.ts
+});
 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) => {
@@ -206,7 +616,7 @@ const resolveVitest = async (dir) => {
 		const vitestNodePath = projectRequire.resolve("vitest/node");
 		const vitestNodeUrl = pathToFileURL(vitestNodePath).href;
 		return {
-			createVitest: S.decodeUnknownSync(VitestNodeModuleSchema)(await import(vitestNodeUrl)).createVitest ?? createVitest,
+			createVitest: S.decodeUnknownSync(VitestNodeModuleSchema)(await import(vitestNodeUrl)).createVitest,
 			version: readVitestVersion(() => projectRequire(projectRequire.resolve("vitest/package.json")))
 		};
 	} catch {
@@ -217,20 +627,6 @@ const resolveVitest = async (dir) => {
 		};
 	}
 };
-//#endregion
-//#region src/vitest-runner-coverage.schema.ts
-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 }) {};
-//#endregion
-//#region src/vitest-test-runner.ts
 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));
 const shouldUseSuiteMetaSecondArg = (version) => {
@@ -262,7 +658,10 @@ const experimentalStateHasExternalErrors = (vitest) => {
 			if (errorsSet instanceof Set) return errorsSet.size > 0;
 			if (typeof errorsSet === "object" && errorsSet !== null && "size" in errorsSet) {
 				const size = Reflect.get(errorsSet, "size");
-				return typeof size === "number" ? size > 0 : false;
+				return (() => {
+					if (typeof size === "number") return size > 0;
+					return false;
+				})();
 			}
 		}
 	}
@@ -289,7 +688,10 @@ const applySetupFilesToProjects = (vitest, localSetupFile) => {
 	if (typeof browser === "object" && browser !== null) Reflect.set(browser, "screenshotFailures", false);
 	for (const project of vitest.projects) {
 		const setupFilesRaw = Reflect.get(project.config, "setupFiles");
-		const files = Array.isArray(setupFilesRaw) ? setupFilesRaw.filter((x) => typeof x === "string") : [];
+		const files = (() => {
+			if (Array.isArray(setupFilesRaw)) return setupFilesRaw.filter((x) => typeof x === "string");
+			return [];
+		})();
 		Reflect.set(project.config, "setupFiles", [localSetupFile, ...files]);
 		const pBrowser = Reflect.get(project.config, "browser");
 		if (typeof pBrowser === "object" && pBrowser !== null) Reflect.set(pBrowser, "screenshotFailures", false);
@@ -308,14 +710,17 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		if (state.ctx === void 0) return yield* new TestRunnerFailed({
 			runnerName: "vitest",
 			phase: "dryRun",
-			cause: /* @__PURE__ */ new Error("Vitest runner is not initialized; call init() before running tests")
+			cause: errorToString(/* @__PURE__ */ new Error("Vitest runner is not initialized; call init() before running tests"))
 		});
 		return state.ctx;
 	});
-	const decodedOptionsEffect = (raw) => S.decodeUnknownEffect(VitestSectionSchema)(raw).pipe(Effect$1.map((decoded) => decoded === void 0 ? { related: true } : decoded), Effect$1.mapError((cause) => new TestRunnerFailed({
+	const decodedOptionsEffect = (raw) => S.decodeUnknownEffect(VitestSectionSchema)(raw).pipe(Effect$1.map((decoded) => (() => {
+		if (decoded === void 0) return { related: true };
+		return decoded;
+	})()), Effect$1.mapError((cause) => new TestRunnerFailed({
 		runnerName: "vitest",
 		phase: "init",
-		cause
+		cause: errorToString(cause)
 	})));
 	const optionsEffect = decodedOptionsEffect(Reflect.get(input.options, "vitest")).pipe(Effect$1.map((vitestOptions) => ({
 		...input.options,
@@ -337,7 +742,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		yield* fsService.copyFile(input.setupFilePath ?? STRYKER_SETUP, localSetupFile).pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
 			runnerName: "vitest",
 			phase: "init",
-			cause
+			cause: errorToString(cause)
 		})));
 		const resolver = input.resolveVitestFor ?? resolveVitest;
 		const { createVitest, version } = yield* Effect$1.tryPromise({
@@ -345,11 +750,13 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			catch: (cause) => new TestRunnerFailed({
 				runnerName: "vitest",
 				phase: "init",
-				cause
+				cause: errorToString(cause)
 			})
 		});
 		const namespace = input.globalNamespace ?? INSTRUMENTER_CONSTANTS.NAMESPACE;
-		const scanDir = typeof options.vitest.dir === "string" ? pathService.resolve(projectRoot, options.vitest.dir) : void 0;
+		const scanDir = (() => {
+			if (typeof options.vitest.dir === "string") return pathService.resolve(projectRoot, options.vitest.dir);
+		})();
 		const aliases = yield* readSandboxSelfAliases(projectRoot).pipe(Effect$1.provideService(FileSystem.FileSystem, fsService), Effect$1.provideService(Path.Path, pathService));
 		const plugin = sandboxSelfPlugin(aliases);
 		const ctx = yield* Effect$1.tryPromise({
@@ -360,9 +767,17 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 				maxConcurrency: 1,
 				watch: false,
 				root: projectRoot,
-				...scanDir === void 0 ? {} : { dir: scanDir },
-				bail: options.disableBail ? 0 : 1,
-				onConsoleLog: () => false
+				...(() => {
+					if (scanDir === void 0) return {};
+					return { dir: scanDir };
+				})(),
+				bail: (() => {
+					if (options.disableBail) return 0;
+					return 1;
+				})(),
+				onConsoleLog: () => false,
+				silent: true,
+				reporters: [{ onInit(_vitest) {} }]
 			}, {
 				resolve: {
 					alias: [...aliases],
@@ -373,29 +788,31 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			catch: (cause) => new TestRunnerFailed({
 				runnerName: "vitest",
 				phase: "init",
-				cause
+				cause: errorToString(cause)
 			})
 		});
 		ctx.provide("globalNamespace", namespace);
 		ctx.provide("isGreaterThanVitest4Point1", shouldUseSuiteMetaSecondArg(version));
 		applySetupFilesToProjects(ctx, localSetupFile);
-		yield* Effect$1.logDebug(`vitest final config: ${JSON.stringify(ctx.config, null, 2)}`);
 		yield* Ref.update(stateRef, (s) => ({
 			...s,
 			ctx
 		}));
-	}).pipe(Effect$1.mapError((cause) => cause instanceof TestRunnerFailed ? cause : new TestRunnerFailed({
-		runnerName: "vitest",
-		phase: "init",
-		cause
-	})));
+	}).pipe(Effect$1.mapError((cause) => (() => {
+		if (cause instanceof TestRunnerFailed) return cause;
+		return new TestRunnerFailed({
+			runnerName: "vitest",
+			phase: "init",
+			cause
+		});
+	})()));
 	const resetContext = Effect$1.gen(function* () {
 		const ctx = yield* requireCtx;
 		experimentalStateClearFiles(ctx);
 	});
-	const getFileMeta = (file) => {
+	const getFileMeta = (file) => (() => {
 		if (file !== null && typeof file === "object" && "meta" in file) return Reflect.get(file, "meta");
-	};
+	})();
 	const readHitCount = Effect$1.gen(function* () {
 		const ctx = yield* requireCtx.pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })));
 		const files = experimentalStateGetFiles(ctx);
@@ -412,11 +829,21 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		const files = experimentalStateGetFiles(ctx);
 		const deduped = {};
 		for (const file of files) {
-			const projectNameValue = typeof file === "object" && file !== null && "projectName" in file ? Reflect.get(file, "projectName") : void 0;
-			const projectName = typeof projectNameValue === "string" ? projectNameValue : "";
-			const nameValue = typeof file === "object" && file !== null && "name" in file ? Reflect.get(file, "name") : void 0;
-			const key = `${projectName}-${typeof nameValue === "string" ? nameValue : ""}`;
-			deduped[key] = file;
+			const projectNameValue = (() => {
+				if (typeof file === "object" && file !== null && "projectName" in file) return Reflect.get(file, "projectName");
+			})();
+			const projectName = (() => {
+				if (typeof projectNameValue === "string") return projectNameValue;
+				return "";
+			})();
+			const nameValue = (() => {
+				if (typeof file === "object" && file !== null && "name" in file) return Reflect.get(file, "name");
+			})();
+			const name = (() => {
+				if (typeof nameValue === "string") return nameValue;
+				return "";
+			})();
+			deduped[`${projectName}-${name}`] = file;
 		}
 		const coverages = [];
 		for (const file of Object.values(deduped)) {
@@ -428,36 +855,36 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 				coverages.push(validated);
 			}
 		}
-		if (coverages.length === 0) return;
+		if (coverages.length === 0) return void 0;
 		if (coverages.length === 1) return coverages[0];
 		const first = coverages[0];
-		if (first === void 0) return;
 		return coverages.slice(1).reduce((acc, projectCoverage) => {
-			for (const [testId, testCoverage] of Object.entries(projectCoverage.perTest)) {
-				const existing = acc.perTest[testId];
-				if (existing !== void 0) mergeCoverage(existing, testCoverage);
-				else acc.perTest[testId] = testCoverage;
-			}
+			for (const [testId, testCoverage] of Object.entries(projectCoverage.perTest)) if (testId in acc.perTest) mergeCoverage(acc.perTest[testId], testCoverage);
+			else acc.perTest[testId] = testCoverage;
 			mergeCoverage(acc.static, projectCoverage.static);
 			return acc;
 		}, first);
 	});
-	const run = (filter) => Effect$1.gen(function* () {
+	const collectRaw = (filter) => Effect$1.gen(function* () {
 		const ctx = yield* requireCtx;
 		const options = yield* optionsEffect;
 		yield* resetContext.pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
 			runnerName: "vitest",
 			phase: "dryRun",
-			cause
+			cause: errorToString(cause)
 		})));
 		const vitestInRun = Reflect.get(options, "vitest");
-		const related = Reflect.get(vitestInRun, "related") !== false && filter.relatedFiles !== void 0 ? filter.relatedFiles.map(normalizeFileName) : void 0;
-		let testFilesToRun = filter.testFiles;
+		const relatedValue = Reflect.get(vitestInRun, "related");
+		const related = (() => {
+			if (relatedValue !== false && filter.relatedFiles !== void 0) return filter.relatedFiles.map(normalizeFileName);
+		})();
+		let testFilesToRun = (() => {
+			if (filter.testFiles !== void 0) return [...filter.testFiles];
+		})();
 		let pattern;
 		if ((filter.testIds ?? []).length > 0) {
 			const parsedTests = (filter.testIds ?? []).map(fromTestId);
-			const regexTestNameFilter = parsedTests.map(({ test: name }) => RegExp.escape(name)).join("|");
-			pattern = new RegExp(regexTestNameFilter);
+			pattern = new RegExp(parsedTests.map(({ test: name }) => RegExp.escape(name)).join("|"));
 			testFilesToRun = parsedTests.map(({ file }) => pathService.resolve(input.sandboxDirectory, file));
 		}
 		applyRunFilterToConfig(ctx, {
@@ -469,77 +896,201 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			catch: (cause) => new TestRunnerFailed({
 				runnerName: "vitest",
 				phase: "dryRun",
-				cause
+				cause: errorToString(cause)
 			})
-		}).pipe(Effect$1.catchIf((error) => isErrorCodeError(error.cause) && error.cause.code === VITEST_ERROR_CODES.FILES_NOT_FOUND, () => Effect$1.void));
-		const tests = experimentalStateGetFiles(ctx).flatMap((file) => isRunnerTestSuite(file) ? collectTestsFromSuite(file) : []).filter((test) => test.result !== void 0);
-		let failure = false;
-		const testResults = tests.map((test) => {
-			const testResult = convertTestToTestResult(test, input.sandboxDirectory, pathService);
-			failure ||= testResult.status === TestStatus.Failed;
-			return testResult;
-		});
-		if (!failure && experimentalStateHasExternalErrors(ctx)) {
-			const errorText = experimentalStateGetExternalErrorText(ctx);
-			return {
-				status: DryRunStatus.Error,
-				errorMessage: `An error occurred outside of a test run: ${errorText}`
-			};
-		}
+		}).pipe(Effect$1.catchIf((error) => isErrorCodeError(error.cause) && typeof error.cause === "string" && error.cause.includes(VITEST_ERROR_CODES.FILES_NOT_FOUND), () => Effect$1.void));
+		const rawTests = experimentalStateGetFiles(ctx).flatMap((file) => (() => {
+			if (isRunnerTestSuite(file)) return collectTestsFromSuite(file);
+			return [];
+		})()).filter((test) => test.result !== void 0);
+		const hasExternalError = experimentalStateHasExternalErrors(ctx);
 		return {
-			tests: testResults,
-			status: DryRunStatus.Complete
+			rawTests,
+			hasExternalError,
+			externalErrorText: (() => {
+				if (hasExternalError) return experimentalStateGetExternalErrorText(ctx);
+				return "";
+			})()
 		};
 	});
-	const dryRun = (options) => Effect$1.gen(function* () {
+	const dryRunDescription = pipe(Cell.read((command) => Effect$1.gen(function* () {
 		(yield* requireCtx).provide("mode", "dry-run");
-		const testResult = testFilesProvided(options) ? yield* run({
-			testFiles: options.testFiles,
-			relatedFiles: options.files
-		}) : yield* run({ relatedFiles: options.files });
-		if (testResult.status === DryRunStatus.Complete && testResult.tests.length === 0 && (yield* optionsEffect).vitest.related !== false && !options.testFiles) yield* Effect$1.logWarning("Vitest failed to find test files related to mutated files. Either disable `vitest.related` or import your source files directly from your test files. See https://stryker-mutator.io/docs/stryker-js/troubleshooting/#vitest-failed-to-find-test-files-related-to-mutated-files");
-		if (testResult.status === DryRunStatus.Complete) {
+		const hasTestFiles = testFilesProvided(command);
+		const filter = (() => {
+			if (hasTestFiles) return {
+				testFiles: [...command.testFiles ?? []],
+				relatedFiles: (() => {
+					if (command.files !== void 0) return [...command.files];
+				})()
+			};
+			return { relatedFiles: (() => {
+				if (command.files !== void 0) return [...command.files];
+			})() };
+		})();
+		const { rawTests, hasExternalError, externalErrorText } = yield* collectRaw(filter);
+		return {
+			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) => ({
+			status: "error",
+			errorMessage: e.message
+		}),
+		onSuccess: (out) => {
+			const raw = JSON.parse(out.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") {
 			const mutantCoverage = yield* readMutantCoverage.pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
 				runnerName: "vitest",
 				phase: "dryRun",
-				cause
+				cause: errorToString(cause)
 			})));
-			if (mutantCoverage === void 0) return testResult;
-			return {
-				...testResult,
+			if (mutantCoverage !== void 0) return {
+				...output,
 				mutantCoverage
 			};
 		}
-		return testResult;
-	}).pipe(Effect$1.mapError((cause) => cause instanceof TestRunnerFailed ? cause : new TestRunnerFailed({
-		runnerName: "vitest",
-		phase: "dryRun",
-		cause
+		return output;
 	})));
-	const mutantRun = (options) => Effect$1.gen(function* () {
+	const mutantRunDescription = pipe(Cell.read((command) => Effect$1.gen(function* () {
 		const ctx = yield* requireCtx;
 		ctx.provide("mode", "mutant");
-		ctx.provide("hitLimit", options.hitLimit);
-		ctx.provide("mutantActivation", options.mutantActivation);
-		ctx.provide("activeMutant", options.activeMutant.id);
-		const dryRunResult = yield* run({
-			testIds: options.testFilter,
-			relatedFiles: [options.sandboxFileName]
+		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
-		})));
-		const timeOut = determineHitLimitReached(hitCount, options.hitLimit);
-		const effectiveResult = Option$1.isSome(timeOut) ? timeOut.value : dryRunResult;
-		const reportAllKillers = typeof input.options.disableBail === "boolean" ? input.options.disableBail : false;
-		return toMutantRunResult(effectiveResult, reportAllKillers);
-	}).pipe(Effect$1.mapError((cause) => cause instanceof TestRunnerFailed ? cause : new TestRunnerFailed({
-		runnerName: "vitest",
-		phase: "mutantRun",
-		cause
-	})));
+			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) => (() => {
+		if (cause instanceof TestRunnerFailed) return cause;
+		return new TestRunnerFailed({
+			runnerName: "vitest",
+			phase: "dryRun",
+			cause: errorToString(cause)
+		});
+	})()));
+	const mutantRun = (options) => Cell.apply(mutantRunDescription, options).pipe(Effect$1.mapError((cause) => (() => {
+		if (cause instanceof TestRunnerFailed) return cause;
+		return new TestRunnerFailed({
+			runnerName: "vitest",
+			phase: "mutantRun",
+			cause: errorToString(cause)
+		});
+	})()));
 	const dispose = Effect$1.gen(function* () {
 		const state = yield* getState;
 		if (state.ctx !== void 0) {
@@ -554,7 +1105,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 				catch: (cause) => new TestRunnerFailed({
 					runnerName: "vitest",
 					phase: "dispose",
-					cause
+					cause: errorToString(cause)
 				})
 			});
 		}
@@ -567,12 +1118,15 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		dispose
 	});
 }));
+function isTestResultLike(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof Reflect.get(value, "id") === "string";
+}
+function isIdRecord(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof Reflect.get(value, "id") === "string";
+}
 function mergeCoverage(to, from) {
-	for (const [mutantId, hitCount] of Object.entries(from)) {
-		const existing = to[mutantId];
-		if (existing !== void 0) to[mutantId] = existing + hitCount;
-		else to[mutantId] = hitCount;
-	}
+	for (const [mutantId, hitCount] of Object.entries(from)) if (mutantId in to) to[mutantId] = to[mutantId] + hitCount;
+	else to[mutantId] = hitCount;
 }
 //#endregion
 //#region src/index.ts
@@ -583,7 +1137,7 @@ function mergeCoverage(to, from) {
 * in, so the requirement is visible in the type and an engine that does not
 * provide it fails to compile.
 */
-const strykerPlugins = [declarePlugin(PluginKind.TestRunner, "vitest", Layer.unwrap(Effect$1.gen(function* () {
+const strykerPlugins = [declarePlugin("TestRunner", "vitest", Layer.unwrap(Effect$1.gen(function* () {
 	const options = yield* RunConfiguration;
 	const sandboxDirectory = yield* SandboxDirectory;
 	return makeVitestRunnerLayer({

package/dist/stryker-setup.mjs

@@ -45,7 +45,7 @@ function collectTestName({ name, suite }) {
 	return nameParts.join(" ").trim();
 }
 function toRawTestId(test) {
-	return `${test.file?.filepath ?? "unknown.js"}#${collectTestName(test)}`;
+	return `${test.file.filepath}#${collectTestName(test)}`;
 }
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-vitest-runner",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -31,24 +31,26 @@
     "coverageAnalysis": "perTest"
   },
   "dependencies": {
-    "@systemfsoftware/stryker-js-plugin-api": "^3.0.0"
+    "@systemfsoftware/effect-cell-types": "^5.0.0",
+    "@systemfsoftware/stryker-js": "^0.1.0"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-rc.111",
+    "effect": "^4.0.0-rc.112",
     "vitest": ">=2.0.0"
   },
   "devDependencies": {
-    "@effect/platform-node": "^4.0.0-rc.111",
-    "@effect/vitest": "4.0.0-rc.111",
+    "@effect/platform-node": "^4.0.0-rc.112",
+    "@effect/vitest": "4.0.0-rc.112",
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
     "@vitest/browser-playwright": "^4",
-    "effect": "^4.0.0-rc.111",
+    "effect": "^4.0.0-rc.112",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4.1.10",
+    "@systemfsoftware/all": "^1.0.0",
     "@systemfsoftware/effect-gherkin-spec": "^2.0.1",
     "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/tsconfig": "^1.3.3",