@systemfsoftware/stryker-js-vitest-runner 4.0.3 → 5.0.0

package/dist/index.mjs

@@ -1,1033 +1,48 @@
-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 { createVitest } from "vitest/node";
-import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
-import { Module } from "@systemfsoftware/stryker-js/Module";
-import { INSTRUMENTER_CONSTANTS, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js/Mutant";
-import { TestRunner, TestRunnerFailed, testFilesProvided } from "@systemfsoftware/stryker-js/TestRunner";
-import * as Context from "effect/Context";
-import * as FileSystem from "effect/FileSystem";
-import * as Match from "effect/Match";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as Predicate from "effect/Predicate";
-import * as Ref from "effect/Ref";
-import * as Result from "effect/Result";
 import { Effect } from "effect";
-//#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 = class extends S.TaggedClass()("VitestDryRunOutput", {
-	status: S.Literals(["Complete", "Error"]),
-	testsJson: S.String,
-	errorMessage: S.optional(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)}`;
-};
-const stripProjectRoot = (file, projectRoot) => Match.value(file.startsWith(projectRoot)).pipe(Match.when(true, () => file.slice(projectRoot.length)), Match.when(false, () => file), Match.exhaustive);
-const toProjectRelativePath = (file) => file.replace(/^[/\\]+/, "").replaceAll("\\", "/");
-const normalizeTestIdRaw$1 = (id, projectRoot) => {
-	const hash = id.indexOf("#");
-	return Match.value(hash === -1).pipe(Match.when(true, () => id), Match.when(false, () => {
-		return `${toProjectRelativePath(stripProjectRoot(id.slice(0, hash), projectRoot))}#${id.slice(hash + 1)}`;
-	}), Match.exhaustive);
-};
-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("skip", () => "skipped"), Match.when("todo", () => "skipped"), 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
-	})));
-};
-/**
-* A run whose tests all passed yet reported an error outside the test files: the shape a dry
-* run reports as `Error` rather than `Complete`.
-*/
-const isSilentExternalError = (tests, command) => Match.value(tests.some((test) => test.status === "failed")).pipe(Match.when(true, () => false), Match.when(false, () => command.hasExternalError), Match.exhaustive);
-const decideVitestDryRun$1 = (command) => Match.value(command.rawTests.map((t) => convertTestRaw$1(t, command.projectRoot))).pipe(Match.when((tests) => isSilentExternalError(tests, command), (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) => Option.flatMap(Option.fromNullishOr(hitCount), (count) => Option.flatMap(Option.fromNullishOr(hitLimit), (limit) => Match.value(count > limit).pipe(Match.when(true, () => Option.some(`Hit limit reached (${count}/${limit})`)), Match.when(false, () => Option.none()), Match.exhaustive)));
-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
+import * as Predicate from "effect/Predicate";
 //#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({
+S.optional(VitestRunnerOptionsSchema).pipe(S.withDecodingDefault(Effect.succeed({ related: true })));
+S.Struct({ hitCount: S.optional(S.Finite) });
+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({
+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 }) {};
+S.TaggedError()("CoverageDecodeFailed", { cause: S.Unknown });
 const ExportEntry = S.Union([S.String, S.Record(S.String, S.Unknown)]);
-const PackageManifest = S.StructWithRest(S.Struct({
+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) => Predicate.isObject(input), { description: "The project-local vitest/node module" });
-const VitestPackageSchema = S.Struct({ version: S.String });
-var VitestDryRunCommand = class extends S.TaggedClass()("VitestDryRunCommand", {
+S.declare((input) => Predicate.isObject(input), { description: "The project-local vitest/node module" });
+S.Struct({ version: S.String });
+S.TaggedClass()("VitestDryRunCommand", {
 	rawTests: S.Array(S.Unknown),
 	projectRoot: S.String,
 	hasExternalError: S.Boolean,
 	externalErrorText: S.String
-}) {};
-var DryRunComplete = class extends S.TaggedClass()("Complete", { testsJson: S.String }) {};
-var DryRunExternalError = class extends S.TaggedClass()("Error", {
+});
+S.TaggedClass()("Complete", { testsJson: S.String });
+S.TaggedClass()("Error", {
 	testsJson: 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) {
-	return error instanceof Error && typeof Reflect.get(error, "code") === "string";
-}
-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"));
-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)}`;
-};
-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("skip", () => "skipped"), Match.when("todo", () => "skipped"), 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) => {
-	const tests = command.rawTests.map((t) => convertTestRaw(t, command.projectRoot));
-	const testsJson = JSON.stringify(tests);
-	const hasFailure = tests.some((t) => t.status === "failed");
-	return Match.value(hasFailure).pipe(Match.when(true, () => DryRunComplete.make({ testsJson })), Match.orElse(() => Match.value(command.hasExternalError).pipe(Match.when(true, () => DryRunExternalError.make({
-		testsJson,
-		errorMessage: `An error occurred outside of a test run: ${command.externalErrorText}`
-	})), Match.orElse(() => DryRunComplete.make({ testsJson })))));
-};
-const TYPESCRIPT_SOURCE_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".mts"
-];
-const isTypescriptSourcePath = (filePath) => TYPESCRIPT_SOURCE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
-const typescriptSourcePath = (filePath) => Option.getOrUndefined(Option.filter(Option.some(filePath), isTypescriptSourcePath));
-const sourceTargetOf = (entry) => Match.value(entry).pipe(Match.when(Match.string, (filePath) => typescriptSourcePath(filePath)), Match.orElse(() => void 0));
-const subpathSpecifier = (packageName, exportKey) => Match.value(exportKey.startsWith("./")).pipe(Match.when(true, () => `${packageName}/${exportKey.slice(2)}`), Match.orElse(() => void 0));
-const specifierForExport = (packageName, exportKey) => Match.value(exportKey).pipe(Match.when(".", () => packageName), Match.when("./package.json", () => void 0), Match.orElse((key) => subpathSpecifier(packageName, key)));
-const namedExports = (manifest) => Option.flatMap(Option.filter(Option.fromNullishOr(manifest.name), (name) => name.length > 0), (name) => Option.map(Option.fromNullishOr(manifest.exports), (exportMap) => ({
-	name,
-	exports: exportMap
-})));
-const exportAlias = (packageName, projectRoot, pathService, [exportKey, entry]) => Option.flatMap(Option.fromNullishOr(specifierForExport(packageName, exportKey)), (spec) => Option.map(Option.fromNullishOr(sourceTargetOf(entry)), (target) => ({
-	find: new RegExp(`^${RegExp.escape(spec)}$`),
-	replacement: pathService.resolve(projectRoot, target)
-})));
-const sandboxSelfAliases = (manifest, projectRoot, pathService) => Option.match(namedExports(manifest), {
-	onNone: () => [],
-	onSome: ({ name, exports: exportMap }) => Object.entries(exportMap).flatMap((entry) => Option.toArray(exportAlias(name, projectRoot, pathService, entry)))
-});
-const parseJson = (text) => {
-	try {
-		return JSON.parse(text);
-	} catch {
-		return;
-	}
-};
-const readSandboxSelfAliases = (projectRoot) => Effect$1.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const pathService = yield* Path.Path;
-	const raw = yield* fs.readFileString(pathService.join(projectRoot, "package.json")).pipe(Effect$1.orElseSucceed(() => null));
-	return Option.match(Option.flatMap(Option.fromNullishOr(raw), (content) => S.decodeUnknownOption(PackageManifest)(parseJson(content))), {
-		onNone: () => [],
-		onSome: (manifest) => sandboxSelfAliases(manifest, projectRoot, pathService)
-	});
-});
-const sandboxSelfPlugin = (aliases) => ({
-	name: "stryker-sandbox-self-exports",
-	enforce: "pre",
-	resolveId(source) {
-		return Option.getOrUndefined(Option.map(Option.fromNullishOr(aliases.find((alias) => alias.find.test(source))), (alias) => alias.replacement));
-	}
-});
-const isRunnerTestSuite = (value) => Predicate.isObject(value) && Array.isArray(value["tasks"]);
-const STRYKER_SETUP_URL = new URL("./stryker-setup.mjs", import.meta.url);
-const resolveVitest = (_dir) => Effect$1.gen(function* () {
-	const fallback = Effect$1.gen(function* () {
-		const pathService = yield* Path.Path;
-		const fs = yield* FileSystem.FileSystem;
-		const urlString = import.meta.resolve("vitest/package.json");
-		const packageJsonPath = yield* pathService.fromFileUrl(new URL(urlString));
-		const content = yield* fs.readFileString(packageJsonPath);
-		const parsed = JSON.parse(content);
-		const decoded = yield* S.decodeUnknownEffect(VitestPackageSchema)(parsed);
-		return {
-			createVitest,
-			version: decoded.version
-		};
-	}).pipe(Effect$1.orDie);
-	return yield* Effect$1.gen(function* () {
-		const module = yield* Module;
-		const pathService = yield* Path.Path;
-		const fs = yield* FileSystem.FileSystem;
-		const requireFromProject = module.createRequire(pathService.join(_dir, "package.json"));
-		const imported = requireFromProject("vitest/node");
-		const decodedNode = yield* S.decodeUnknownEffect(VitestNodeModuleSchema)(imported);
-		const packageJsonPath = requireFromProject.resolve("vitest/package.json");
-		const content = yield* fs.readFileString(packageJsonPath);
-		const parsed = JSON.parse(content);
-		const decodedPackage = yield* S.decodeUnknownEffect(VitestPackageSchema)(parsed);
-		return {
-			createVitest: decodedNode.createVitest,
-			version: decodedPackage.version
-		};
-	}).pipe(Effect$1.catchCause(() => fallback), Effect$1.catchDefect(() => fallback));
-}).pipe(Effect$1.orDie);
-const versionPart = (parts, index) => Option.getOrElse(Option.map(Option.fromNullishOr(parts[index]), (part) => Number(part)), () => 0);
-const minimumMinorForMajor = (major) => Match.value(major).pipe(Match.when((value) => value > 4, () => Option.some(0)), Match.when(4, () => Option.some(1)), Match.orElse(() => Option.none()));
-const shouldUseSuiteMetaSecondArg = (version) => {
-	const parts = version.split(".");
-	const major = versionPart(parts, 0);
-	const minor = versionPart(parts, 1);
-	return Match.value(Number.isNaN(major) || Number.isNaN(minor)).pipe(Match.when(true, () => false), Match.orElse(() => Option.exists(minimumMinorForMajor(major), (minimumMinor) => minor >= minimumMinor)));
-};
-const relatedFilesOf = (relatedValue, relatedFiles) => Match.value(relatedValue !== false).pipe(Match.when(true, () => Option.getOrUndefined(Option.map(Option.fromNullishOr(relatedFiles), (files) => files.map(normalizeFileName)))), Match.orElse(() => void 0));
-const testIdPlan = (testIds, projectRoot, pathService) => Option.map(Option.filter(Option.fromNullishOr(testIds), (ids) => ids.length > 0), (ids) => ({
-	testNamePattern: new RegExp(ids.map((id) => RegExp.escape(fromTestId(id).test)).join("|")),
-	testFiles: ids.map((id) => pathService.resolve(projectRoot, fromTestId(id).file))
-}));
-const runFilterPlan = (filter, projectRoot, pathService) => {
-	const plan = testIdPlan(filter.testIds, projectRoot, pathService);
-	return {
-		testNamePattern: Option.getOrUndefined(Option.map(plan, (value) => value.testNamePattern)),
-		testFiles: Option.match(plan, {
-			onNone: () => Option.getOrUndefined(Option.map(Option.fromNullishOr(filter.testFiles), (files) => [...files])),
-			onSome: (value) => value.testFiles
-		})
-	};
-};
-const isMissingTestFilesCause = (cause) => Match.value(isErrorCodeError(cause)).pipe(Match.when(true, () => typeof cause === "string" && cause.includes(VITEST_ERROR_CODES.FILES_NOT_FOUND)), Match.orElse(() => false));
-const experimentalStateGetFiles = (vitest) => vitest.state.getFiles();
-const propertyOf = (value, key) => Option.flatMap(Option.filter(Option.fromNullishOr(value), Predicate.isObject), (record) => Option.fromNullishOr(record[key]));
-const vitestStateOf = (vitest) => propertyOf(vitest, "state");
-const errorsSetOf = (vitest) => Option.flatMap(vitestStateOf(vitest), (state) => propertyOf(state, "errorsSet"));
-const invokeMethod = (holder, name) => Option.match(Option.filter(propertyOf(holder, name), Predicate.isFunction), {
-	onNone: () => void 0,
-	onSome: (method) => {
-		Reflect.apply(method, holder, []);
-	}
-});
-const clearFilesMap = (filesMap) => Match.value(filesMap).pipe(Match.when(Match.instanceOf(Map), (map) => {
-	map.clear();
-}), Match.orElse((value) => invokeMethod(value, "clear")));
-const experimentalStateClearFiles = (vitest) => Option.match(Option.flatMap(vitestStateOf(vitest), (state) => propertyOf(state, "filesMap")), {
-	onNone: () => void 0,
-	onSome: (filesMap) => clearFilesMap(filesMap)
-});
-const entryCountOf = (collection) => Match.value(collection).pipe(Match.when(Match.instanceOf(Set), (set) => Option.some(set.size)), Match.orElse((value) => Option.filter(propertyOf(value, "size"), Predicate.isNumber)));
-const experimentalStateHasExternalErrors = (vitest) => Option.exists(Option.flatMap(errorsSetOf(vitest), entryCountOf), (count) => count > 0);
-const experimentalStateGetExternalErrorText = (vitest) => Option.match(errorsSetOf(vitest), {
-	onNone: () => "",
-	onSome: (errorsSet) => Match.value(errorsSet).pipe(Match.when(Predicate.isIterable, (errors) => [...errors].map(errorToString).join("\n")), Match.orElse(() => ""))
-});
-const applyHarnessValue = (ctx, key, value) => Match.value(key).pipe(Match.when("hitLimit", () => {
-	ctx.provide("hitLimit", Option.getOrUndefined(Option.filter(Option.fromNullishOr(value), Predicate.isNumber)));
-}), Match.when("mutantActivation", () => {
-	Match.value(value).pipe(Match.when(Match.is("runtime", "static"), (activation) => {
-		ctx.provide("mutantActivation", activation);
-	}), Match.orElse(() => void 0));
-}), Match.orElse(() => {
-	Match.value(value).pipe(Match.when(Predicate.isString, (activeMutant) => {
-		ctx.provide("activeMutant", activeMutant);
-	}), Match.orElse(() => void 0));
-}));
-const applyRunFilterToConfig = (vitest, options) => {
-	Reflect.set(vitest.config, "related", options.related);
-	for (const project of vitest.projects) Reflect.set(project.config, "testNamePattern", options.testNamePattern);
-};
-const disableScreenshotFailures = (value) => Option.match(Option.filter(Option.fromNullishOr(value), Predicate.isObject), {
-	onNone: () => void 0,
-	onSome: (browser) => {
-		Reflect.set(browser, "screenshotFailures", false);
-	}
-});
-const setupFilePathsOf = (value) => Match.value(value).pipe(Match.when(Array.isArray, (setupFiles) => setupFiles.filter(Predicate.isString)), Match.orElse(() => []));
-const applySetupFilesToProjects = (vitest, localSetupFile) => {
-	disableScreenshotFailures(Reflect.get(vitest.config, "browser"));
-	for (const project of vitest.projects) {
-		const setupFiles = setupFilePathsOf(Reflect.get(project.config, "setupFiles"));
-		Reflect.set(project.config, "setupFiles", [localSetupFile, ...setupFiles]);
-		disableScreenshotFailures(Reflect.get(project.config, "browser"));
-	}
-};
-const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(function* () {
-	const stateRef = yield* Ref.make({
-		ctx: void 0,
-		localSetupFile: void 0
-	});
-	const fsService = yield* FileSystem.FileSystem;
-	const pathService = yield* Path.Path;
-	const moduleService = yield* Module;
-	const getState = Ref.get(stateRef);
-	const requireCtx = Effect$1.gen(function* () {
-		const state = yield* getState;
-		if (state.ctx === void 0) return yield* new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "dryRun",
-			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) => (() => {
-		if (decoded === void 0) return { related: true };
-		return decoded;
-	})()), Effect$1.mapError((cause) => new TestRunnerFailed({
-		runnerName: "vitest",
-		phase: "init",
-		cause: errorToString(cause)
-	})));
-	const optionsEffect = decodedOptionsEffect(Reflect.get(input.options, "vitest")).pipe(Effect$1.map((vitestOptions) => ({
-		...input.options,
-		vitest: vitestOptions
-	})));
-	const capabilities = Effect$1.succeed({ reloadEnvironment: true });
-	const init = Effect$1.gen(function* () {
-		const options = yield* optionsEffect;
-		yield* Effect$1.sync(() => {
-			process.env.NODE_ENV = "test";
-			process.env.VITEST = "1";
-		});
-		const projectRoot = input.sandboxDirectory;
-		const localSetupFile = pathService.resolve(projectRoot, `stryker-setup-${process.pid}.js`);
-		yield* Ref.update(stateRef, (s) => ({
-			...s,
-			localSetupFile
-		}));
-		const defaultSetupPath = yield* pathService.fromFileUrl(STRYKER_SETUP_URL).pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "init",
-			cause: errorToString(cause)
-		})));
-		const setupFilePath = Option.getOrElse(Option.fromNullishOr(input.setupFilePath), () => defaultSetupPath);
-		yield* fsService.copyFile(setupFilePath, localSetupFile).pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "init",
-			cause: errorToString(cause)
-		})));
-		const { createVitest, version } = yield* Option.getOrElse(Option.fromNullishOr(input.resolveVitestFor), () => resolveVitest)(projectRoot).pipe(Effect$1.provideService(Module, moduleService), Effect$1.provideService(FileSystem.FileSystem, fsService), Effect$1.provideService(Path.Path, pathService), Effect$1.catchDefect((cause) => Effect$1.fail(new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "init",
-			cause: errorToString(cause)
-		}))));
-		const namespace = Option.getOrElse(Option.fromNullishOr(input.globalNamespace), () => INSTRUMENTER_CONSTANTS.NAMESPACE);
-		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({
-			try: () => createVitest("test", {
-				config: options.vitest.configFile,
-				coverage: { enabled: false },
-				maxWorkers: 1,
-				maxConcurrency: 1,
-				watch: false,
-				root: projectRoot,
-				...(() => {
-					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],
-					conditions: ["import"]
-				},
-				plugins: [plugin]
-			}),
-			catch: (cause) => new TestRunnerFailed({
-				runnerName: "vitest",
-				phase: "init",
-				cause: errorToString(cause)
-			})
-		});
-		ctx.provide("globalNamespace", namespace);
-		ctx.provide("isGreaterThanVitest4Point1", shouldUseSuiteMetaSecondArg(version));
-		applySetupFilesToProjects(ctx, localSetupFile);
-		yield* Ref.update(stateRef, (s) => ({
-			...s,
-			ctx
-		}));
-	}).pipe(Effect$1.mapError((cause) => (() => {
-		if (cause instanceof TestRunnerFailed) return cause;
-		return new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "init",
-			cause: errorToString(cause)
-		});
-	})()));
-	const resetContext = Effect$1.gen(function* () {
-		const ctx = yield* requireCtx;
-		experimentalStateClearFiles(ctx);
-	});
-	const getFileMeta = (file) => Option.getOrUndefined(propertyOf(file, "meta"));
-	const readHitCount = Effect$1.gen(function* () {
-		const ctx = yield* requireCtx.pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })));
-		return (yield* Effect$1.forEach(experimentalStateGetFiles(ctx), (file) => Effect$1.map(S.decodeUnknownEffect(HitCountMetaSchema)(getFileMeta(file)).pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })), Effect$1.orElseSucceed(() => ({ hitCount: void 0 }))), (decoded) => Option.getOrElse(Option.fromNullishOr(decoded.hitCount), () => 0)))).reduce((total, count) => total + count, 0);
-	});
-	const stringProperty = (value, key) => Option.getOrElse(Option.filter(propertyOf(value, key), Predicate.isString), () => "");
-	const dedupeFilesByName = (files) => Object.fromEntries(files.map((file) => [`${stringProperty(file, "projectName")}-${stringProperty(file, "name")}`, file]));
-	const validateCoverage = (mutantCoverage) => {
-		const normalized = normalizeCoverage(mutantCoverage, input.sandboxDirectory, pathService);
-		return S.decodeEffect(MutantCoverageShapeSchema)(normalized).pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })), Effect$1.map(() => normalized));
-	};
-	const coverageOfFile = (file) => Effect$1.gen(function* () {
-		const decoded = yield* S.decodeUnknownEffect(MutantCoverageMetaSchema)(getFileMeta(file)).pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })), Effect$1.orElseSucceed(() => ({ mutantCoverage: void 0 })));
-		return yield* Option.match(Option.fromNullishOr(decoded.mutantCoverage), {
-			onNone: () => Effect$1.succeed(void 0),
-			onSome: (mutantCoverage) => validateCoverage(mutantCoverage)
-		});
-	});
-	const mergeTestCoverage = (perTest, testId, coverage) => Option.match(Option.fromNullishOr(perTest[testId]), {
-		onNone: () => {
-			perTest[testId] = coverage;
-		},
-		onSome: (existing) => {
-			mergeCoverage(existing, coverage);
-		}
-	});
-	const mergeProjectCoverage = (acc, projectCoverage) => {
-		for (const [testId, testCoverage] of Object.entries(projectCoverage.perTest)) mergeTestCoverage(acc.perTest, testId, testCoverage);
-		mergeCoverage(acc.static, projectCoverage.static);
-		return acc;
-	};
-	const readMutantCoverage = Effect$1.gen(function* () {
-		const ctx = yield* requireCtx.pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })));
-		const files = Object.values(dedupeFilesByName(experimentalStateGetFiles(ctx)));
-		const coverages = (yield* Effect$1.forEach(files, coverageOfFile)).filter(Predicate.isNotNullish);
-		return Option.getOrUndefined(Option.map(Option.fromNullishOr(coverages[0]), (first) => coverages.slice(1).reduce(mergeProjectCoverage, first)));
-	});
-	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: errorToString(cause)
-		})));
-		const vitestInRun = Reflect.get(options, "vitest");
-		const related = relatedFilesOf(Reflect.get(vitestInRun, "related"), filter.relatedFiles);
-		const plan = runFilterPlan(filter, input.sandboxDirectory, pathService);
-		applyRunFilterToConfig(ctx, {
-			related,
-			testNamePattern: plan.testNamePattern
-		});
-		yield* Effect$1.tryPromise({
-			try: () => ctx.start(plan.testFiles),
-			catch: (cause) => new TestRunnerFailed({
-				runnerName: "vitest",
-				phase: "dryRun",
-				cause: errorToString(cause)
-			})
-		}).pipe(Effect$1.catchIf((error) => isMissingTestFilesCause(error.cause), () => 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 {
-			rawTests,
-			hasExternalError,
-			externalErrorText: Match.value(hasExternalError).pipe(Match.when(true, () => experimentalStateGetExternalErrorText(ctx)), Match.orElse(() => ""))
-		};
-	});
-	const harnessImpl = {
-		setMode: (mode) => Effect$1.gen(function* () {
-			(yield* requireCtx).provide("mode", mode);
-		}),
-		provide: (key, value) => Effect$1.gen(function* () {
-			const ctx = yield* requireCtx;
-			applyHarnessValue(ctx, key, 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) => Result.succeed(new VitestMutantRunCommand({
-			rawTests: raw.rawTests,
-			projectRoot: raw.projectRoot,
-			hasExternalError: raw.hasExternalError,
-			externalErrorText: raw.externalErrorText,
-			hitCount: raw.hitCount,
-			hitLimit: raw.hitLimit,
-			reportAllKillers: raw.reportAllKillers
-		})),
-		decide: interpretVitestRun,
-		encode: (outcome) => Result.match(outcome, {
-			onFailure: (e) => ({
-				status: "error",
-				errorMessage: e.message
-			}),
-			onSuccess: (out) => {
-				const nrOfTests = () => countIdRecords(parseJson(out.testsJson));
-				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 dryRunFilter = (options) => {
-		const relatedFiles = Option.getOrUndefined(Option.map(Option.fromNullishOr(options.files), (files) => [...files]));
-		return Match.value(testFilesProvided(options)).pipe(Match.when(true, () => ({
-			testFiles: Option.getOrElse(Option.map(Option.fromNullishOr(options.testFiles), (files) => [...files]), () => []),
-			relatedFiles
-		})), Match.orElse(() => ({ relatedFiles })));
-	};
-	const completeDryRun = (testsJson) => Effect$1.gen(function* () {
-		const tests = Match.value(parseJson(testsJson)).pipe(Match.when(Array.isArray, (entries) => entries.filter(isTestResultLike)), Match.orElse(() => []));
-		const mutantCoverage = yield* readMutantCoverage.pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "dryRun",
-			cause: errorToString(cause)
-		})));
-		return Match.value(mutantCoverage).pipe(Match.when(Match.defined, (coverage) => ({
-			status: "complete",
-			tests,
-			mutantCoverage: coverage
-		})), Match.orElse(() => ({
-			status: "complete",
-			tests
-		})));
-	});
-	const dryRun = (options) => Effect$1.gen(function* () {
-		yield* (yield* VitestHarness).setMode("dry-run");
-		const filter = dryRunFilter(options);
-		const { rawTests, hasExternalError, externalErrorText } = yield* collectRaw(filter);
-		const decision = decideVitestDryRun(new VitestDryRunCommand({
-			rawTests,
-			projectRoot: input.sandboxDirectory,
-			hasExternalError,
-			externalErrorText
-		}));
-		return yield* Match.value(decision).pipe(Match.tag("Error", (error) => Effect$1.succeed({
-			status: "error",
-			errorMessage: error.errorMessage
-		})), Match.tag("Complete", (complete) => completeDryRun(complete.testsJson)), Match.exhaustive);
-	}).pipe(Effect$1.provideService(VitestHarness, harnessImpl), Effect$1.mapError((cause) => (() => {
-		if (cause instanceof TestRunnerFailed) return cause;
-		return new TestRunnerFailed({
-			runnerName: "vitest",
-			phase: "dryRun",
-			cause: errorToString(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",
-			phase: "mutantRun",
-			cause: errorToString(cause)
-		});
-	})()));
-	const disposeContext = (ctx, localSetupFile) => Effect$1.gen(function* () {
-		Option.match(Option.fromNullishOr(localSetupFile), {
-			onNone: () => void 0,
-			onSome: (file) => {
-				ctx.onClose(() => Effect$1.runPromise(fsService.remove(file, {
-					recursive: true,
-					force: true
-				}).pipe(Effect$1.orElseSucceed(() => void 0))));
-			}
-		});
-		yield* Effect$1.tryPromise({
-			try: () => ctx.close(),
-			catch: (cause) => new TestRunnerFailed({
-				runnerName: "vitest",
-				phase: "dispose",
-				cause: errorToString(cause)
-			})
-		});
-	});
-	const dispose = Effect$1.gen(function* () {
-		const state = yield* getState;
-		return yield* Option.match(Option.fromNullishOr(state.ctx), {
-			onNone: () => Effect$1.void,
-			onSome: (ctx) => disposeContext(ctx, state.localSetupFile)
-		});
-	});
-	return TestRunner.of({
-		capabilities,
-		init,
-		dryRun,
-		mutantRun,
-		dispose
-	});
-}));
-function isTestResultLike(value) {
-	return Predicate.isObject(value) && typeof value["id"] === "string";
-}
-function countIdRecords(raw) {
-	return Match.value(raw).pipe(Match.when(Array.isArray, (entries) => entries.filter(isTestResultLike).length), Match.orElse(() => 0));
-}
-const mergeHitCount = (to, mutantId, hitCount) => Option.match(Option.fromNullishOr(to[mutantId]), {
-	onNone: () => {
-		to[mutantId] = hitCount;
-	},
-	onSome: (existing) => {
-		to[mutantId] = existing + hitCount;
-	}
-});
-function mergeCoverage(to, from) {
-	for (const [mutantId, hitCount] of Object.entries(from)) mergeHitCount(to, mutantId, hitCount);
-}
 //#endregion
 //#region src/index.ts
-/**
-* The `vitest` test runner, as the plugin the engine loads.
-*
-* The declared layer asks for the run's resolved options and the sandbox it runs
-* in, so the requirement is visible in the type and an engine that does not
-* provide it fails to compile.
-*/
-const strykerPlugins = [declarePlugin("TestRunner", "vitest", Layer.unwrap(Effect$1.gen(function* () {
-	const options = yield* RunConfiguration;
-	const sandboxDirectory = yield* SandboxDirectory;
-	return makeVitestRunnerLayer({
-		options,
-		sandboxDirectory
-	});
-})))];
+const strykerPlugins = [{
+	kind: "TestRunner",
+	name: "vitest",
+	workerEntry: new URL("./main.mjs", import.meta.url).href
+}];
 /**
 * 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