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

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @systemfsoftware/stryker-js-vitest-runner
 
+## 4.0.1
+
+### Patch Changes
+
+- Re-released against @systemfsoftware/stryker-js without the removed --llms manifest. The Run stream no longer carries a manifest terminal event, and the RunEvent / RunTerminalEvent unions no longer include the manifest arm, so any exhaustive consumer of those types must drop that case.
+
+- Rebuilds against updated workspace dependencies, including the new
+  `@systemfsoftware/stryker-js` reporter protocol major.
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js@3.0.0
+
 ## 4.0.0
 
 ### Major Changes

package/dist/index.d.mts

@@ -6,7 +6,7 @@
  * 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").PluginContribution<"TestRunner">[];
+declare const strykerPlugins: import("@systemfsoftware/stryker-js/Plugin").PluginLayerContribution<"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

@@ -12,6 +12,7 @@ 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";
@@ -110,17 +111,15 @@ const toRawTestIdRaw$1 = (test) => {
 		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("#");
-	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}`;
+	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("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 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), {
@@ -194,7 +193,12 @@ const convertTestRaw$1 = (test, projectRoot) => {
 		status
 	})));
 };
-const decideVitestDryRun$1 = (command) => Match.value(command.rawTests.map((t) => convertTestRaw$1(t, command.projectRoot))).pipe(Match.when((tests) => tests.some((t) => t.status === "failed") === false && command.hasExternalError === true, (tests) => Result.succeed(VitestDryRunOutput.make({
+/**
+* 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}`
@@ -203,11 +207,7 @@ const decideVitestDryRun$1 = (command) => Match.value(command.rawTests.map((t) =
 	testsJson: JSON.stringify(tests),
 	errorMessage: void 0
 }))));
-const hitLimitReason = (hitCount, hitLimit) => {
-	if (hitCount === void 0 || hitLimit === void 0) return Option.none();
-	if (hitCount > hitLimit) return Option.some(`Hit limit reached (${hitCount}/${hitLimit})`);
-	return Option.none();
-};
+const 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
@@ -290,7 +290,7 @@ const PackageManifest = S.StructWithRest(S.Struct({
 	name: S.optional(S.String),
 	exports: S.optional(S.Record(S.String, ExportEntry))
 }), [S.Record(S.String, S.Unknown)]);
-const VitestNodeModuleSchema = S.declare((input) => input !== null && typeof input === "object" && !Array.isArray(input), { description: "The project-local vitest/node module" });
+const 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", {
 	rawTests: S.Array(S.Unknown),
@@ -330,8 +330,7 @@ function collectTestsFromSuite(suite) {
 	});
 }
 function isErrorCodeError(error) {
-	if (error instanceof Error && "code" in error) return typeof Reflect.get(error, "code") === "string";
-	return false;
+	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);
@@ -392,7 +391,7 @@ const normalizeTestIdRaw = (id, projectRoot) => {
 		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 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), {
@@ -468,55 +467,48 @@ const convertTestRaw = (test, projectRoot) => {
 };
 const decideVitestDryRun = (command) => {
 	const tests = command.rawTests.map((t) => convertTestRaw(t, command.projectRoot));
-	if (tests.some((t) => t.status === "failed") === false && command.hasExternalError) return DryRunExternalError.make({
-		testsJson: JSON.stringify(tests),
+	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}`
-	});
-	return DryRunComplete.make({ testsJson: JSON.stringify(tests) });
+	})), Match.orElse(() => DryRunComplete.make({ testsJson })))));
 };
 const SOURCE_CONDITION = "@systemfsoftware/source";
-const sourceTargetOf = (entry) => {
-	if (typeof entry === "string") return (() => {
-		if (entry.endsWith(".ts") || entry.endsWith(".tsx") || entry.endsWith(".mts")) return entry;
-	})();
-	const source = entry[SOURCE_CONDITION];
-	return (() => {
-		if (typeof source === "string") return source;
-	})();
-};
-const specifierForExport = (packageName, exportKey) => {
-	if (exportKey === ".") return packageName;
-	if (exportKey === "./package.json" || !exportKey.startsWith("./")) return void 0;
-	return `${packageName}/${exportKey.slice(2)}`;
-};
-const sandboxSelfAliases = (manifest, projectRoot, pathService) => {
-	const name = manifest.name;
-	const exports = manifest.exports;
-	if (name === void 0 || name.length === 0 || exports === void 0) return [];
-	const aliases = [];
-	for (const [key, value] of Object.entries(exports)) {
-		const spec = specifierForExport(name, key);
-		const target = sourceTargetOf(value);
-		if (spec === void 0 || target === void 0) continue;
-		aliases.push({
-			find: new RegExp(`^${RegExp.escape(spec)}$`),
-			replacement: pathService.resolve(projectRoot, target)
-		});
+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((conditions) => Option.getOrUndefined(Option.flatMap(recordOption(conditions), (record) => getStringField(record, SOURCE_CONDITION)))));
+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;
 	}
-	return aliases;
 };
 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));
-	if (raw === null) return [];
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return [];
-	}
-	return Option.match(S.decodeUnknownOption(PackageManifest)(parsed), {
+	return Option.match(Option.flatMap(Option.fromNullishOr(raw), (content) => S.decodeUnknownOption(PackageManifest)(parseJson(content))), {
 		onNone: () => [],
 		onSome: (manifest) => sandboxSelfAliases(manifest, projectRoot, pathService)
 	});
@@ -525,10 +517,10 @@ 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;
+		return Option.getOrUndefined(Option.map(Option.fromNullishOr(aliases.find((alias) => alias.find.test(source))), (alias) => alias.replacement));
 	}
 });
-const isRunnerTestSuite = (value) => typeof value === "object" && value !== null && "tasks" in value && Array.isArray(Reflect.get(value, "tasks"));
+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* () {
@@ -561,72 +553,81 @@ const resolveVitest = (_dir) => Effect$1.gen(function* () {
 		};
 	}).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 = Number(parts[0] ?? "0");
-	const minor = Number(parts[1] ?? "0");
-	if (Number.isNaN(major) || Number.isNaN(minor)) return false;
-	return major > 4 || major === 4 && minor >= 1;
+	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 experimentalStateGetFiles = (vitest) => vitest.state.getFiles();
-const experimentalStateClearFiles = (vitest) => {
-	if (typeof vitest === "object" && vitest !== null && "state" in vitest) {
-		const state = Reflect.get(vitest, "state");
-		if (typeof state === "object" && state !== null && "filesMap" in state) {
-			const filesMap = Reflect.get(state, "filesMap");
-			if (filesMap instanceof Map) filesMap.clear();
-			else if (typeof filesMap === "object" && filesMap !== null && "clear" in filesMap) {
-				const clear = Reflect.get(filesMap, "clear");
-				if (typeof clear === "function") Reflect.apply(clear, filesMap, []);
-			}
-		}
-	}
-};
-const experimentalStateHasExternalErrors = (vitest) => {
-	if (typeof vitest === "object" && vitest !== null && "state" in vitest) {
-		const state = Reflect.get(vitest, "state");
-		if (typeof state === "object" && state !== null && "errorsSet" in state) {
-			const errorsSet = Reflect.get(state, "errorsSet");
-			if (errorsSet instanceof Set) return errorsSet.size > 0;
-			if (typeof errorsSet === "object" && errorsSet !== null && "size" in errorsSet) {
-				const size = Reflect.get(errorsSet, "size");
-				return (() => {
-					if (typeof size === "number") return size > 0;
-					return false;
-				})();
-			}
-		}
-	}
-	return false;
+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 experimentalStateGetExternalErrorText = (vitest) => {
-	if (typeof vitest === "object" && vitest !== null && "state" in vitest) {
-		const state = Reflect.get(vitest, "state");
-		if (typeof state === "object" && state !== null && "errorsSet" in state) {
-			const errorsSet = Reflect.get(state, "errorsSet");
-			if (errorsSet instanceof Set) return [...errorsSet].map(errorToString).join("\n");
-			const isIterable = (value) => typeof value === "object" && value !== null && Symbol.iterator in value && typeof Reflect.get(value, Symbol.iterator) === "function";
-			if (isIterable(errorsSet)) return [...errorsSet].map(errorToString).join("\n");
-		}
+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, []);
 	}
-	return "";
-};
+});
+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) => {
-	const browser = Reflect.get(vitest.config, "browser");
-	if (typeof browser === "object" && browser !== null) Reflect.set(browser, "screenshotFailures", false);
+	disableScreenshotFailures(Reflect.get(vitest.config, "browser"));
 	for (const project of vitest.projects) {
-		const setupFilesRaw = Reflect.get(project.config, "setupFiles");
-		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);
+		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* () {
@@ -677,17 +678,18 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			phase: "init",
 			cause: errorToString(cause)
 		})));
-		yield* fsService.copyFile(input.setupFilePath ?? defaultSetupPath, localSetupFile).pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
+		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* (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({
+		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 = input.globalNamespace ?? INSTRUMENTER_CONSTANTS.NAMESPACE;
+		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);
 		})();
@@ -744,60 +746,42 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		const ctx = yield* requireCtx;
 		experimentalStateClearFiles(ctx);
 	});
-	const getFileMeta = (file) => (() => {
-		if (file !== null && typeof file === "object" && "meta" in file) return Reflect.get(file, "meta");
-	})();
+	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 })));
-		const files = experimentalStateGetFiles(ctx);
-		let total = 0;
-		for (const file of files) {
-			const meta = getFileMeta(file);
-			const decoded = yield* S.decodeUnknownEffect(HitCountMetaSchema)(meta).pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })), Effect$1.orElseSucceed(() => ({ hitCount: void 0 })));
-			if (decoded.hitCount !== void 0) total += decoded.hitCount;
+		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);
 		}
-		return total;
 	});
+	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 = experimentalStateGetFiles(ctx);
-		const deduped = {};
-		for (const file of files) {
-			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)) {
-			const rawMeta = getFileMeta(file);
-			const decoded = yield* S.decodeUnknownEffect(MutantCoverageMetaSchema)(rawMeta).pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })), Effect$1.orElseSucceed(() => ({ mutantCoverage: void 0 })));
-			if (decoded.mutantCoverage !== void 0) {
-				const normalized = normalizeCoverage(decoded.mutantCoverage, input.sandboxDirectory, pathService);
-				const validated = yield* S.decodeEffect(MutantCoverageShapeSchema)(normalized).pipe(Effect$1.mapError((cause) => new CoverageDecodeFailed({ cause })), Effect$1.map(() => normalized));
-				coverages.push(validated);
-			}
-		}
-		if (coverages.length === 0) return void 0;
-		if (coverages.length === 1) return coverages[0];
-		const first = coverages[0];
-		return coverages.slice(1).reduce((acc, projectCoverage) => {
-			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 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;
@@ -808,31 +792,20 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			cause: errorToString(cause)
 		})));
 		const vitestInRun = Reflect.get(options, "vitest");
-		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);
-			pattern = new RegExp(parsedTests.map(({ test: name }) => RegExp.escape(name)).join("|"));
-			testFilesToRun = parsedTests.map(({ file }) => pathService.resolve(input.sandboxDirectory, file));
-		}
+		const related = relatedFilesOf(Reflect.get(vitestInRun, "related"), filter.relatedFiles);
+		const plan = runFilterPlan(filter, input.sandboxDirectory, pathService);
 		applyRunFilterToConfig(ctx, {
 			related,
-			testNamePattern: pattern
+			testNamePattern: plan.testNamePattern
 		});
 		yield* Effect$1.tryPromise({
-			try: () => ctx.start(testFilesToRun),
+			try: () => ctx.start(plan.testFiles),
 			catch: (cause) => new TestRunnerFailed({
 				runnerName: "vitest",
 				phase: "dryRun",
 				cause: errorToString(cause)
 			})
-		}).pipe(Effect$1.catchIf((error) => isErrorCodeError(error.cause) && typeof error.cause === "string" && error.cause.includes(VITEST_ERROR_CODES.FILES_NOT_FOUND), () => Effect$1.void));
+		}).pipe(Effect$1.catchIf((error) => isMissingTestFilesCause(error.cause), () => Effect$1.void));
 		const rawTests = experimentalStateGetFiles(ctx).flatMap((file) => (() => {
 			if (isRunnerTestSuite(file)) return collectTestsFromSuite(file);
 			return [];
@@ -841,10 +814,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		return {
 			rawTests,
 			hasExternalError,
-			externalErrorText: (() => {
-				if (hasExternalError) return experimentalStateGetExternalErrorText(ctx);
-				return "";
-			})()
+			externalErrorText: Match.value(hasExternalError).pipe(Match.when(true, () => experimentalStateGetExternalErrorText(ctx)), Match.orElse(() => ""))
 		};
 	});
 	const harnessImpl = {
@@ -853,12 +823,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		}),
 		provide: (key, value) => Effect$1.gen(function* () {
 			const ctx = yield* requireCtx;
-			if (key === "hitLimit") {
-				if (typeof value === "number" || value === void 0) ctx.provide("hitLimit", value);
-				else ctx.provide("hitLimit", void 0);
-			} else if (key === "mutantActivation") {
-				if (value === "runtime" || value === "static") ctx.provide("mutantActivation", value);
-			} else if (typeof value === "string") ctx.provide("activeMutant", value);
+			applyHarnessValue(ctx, key, value);
 		})
 	};
 	const mutantRunCell = Cell.layer({
@@ -901,31 +866,15 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 				reportAllKillers
 			};
 		}),
-		decode: (raw) => {
-			const base = {
-				rawTests: raw.rawTests,
-				projectRoot: raw.projectRoot,
-				hasExternalError: raw.hasExternalError,
-				externalErrorText: raw.externalErrorText,
-				reportAllKillers: raw.reportAllKillers
-			};
-			if (raw.hitCount !== void 0) {
-				if (raw.hitLimit !== void 0) return Result.succeed(new VitestMutantRunCommand({
-					...base,
-					hitCount: raw.hitCount,
-					hitLimit: raw.hitLimit
-				}));
-				return Result.succeed(new VitestMutantRunCommand({
-					...base,
-					hitCount: raw.hitCount
-				}));
-			}
-			if (raw.hitLimit !== void 0) return Result.succeed(new VitestMutantRunCommand({
-				...base,
-				hitLimit: raw.hitLimit
-			}));
-			return Result.succeed(new VitestMutantRunCommand(base));
-		},
+		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) => ({
@@ -933,15 +882,7 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 				errorMessage: e.message
 			}),
 			onSuccess: (out) => {
-				const nrOfTests = () => {
-					try {
-						const raw = JSON.parse(out.testsJson);
-						if (Array.isArray(raw)) return raw.filter(isIdRecord).length;
-						return 0;
-					} catch {
-						return 0;
-					}
-				};
+				const nrOfTests = () => countIdRecords(parseJson(out.testsJson));
 				return Match.value(out).pipe(Match.tag("Error", (error) => ({
 					status: "error",
 					errorMessage: error.errorMessage ?? "unknown"
@@ -967,20 +908,32 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 		}),
 		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 hasTestFiles = testFilesProvided(options);
-		const filter = (() => {
-			if (hasTestFiles) return {
-				testFiles: [...options.testFiles ?? []],
-				relatedFiles: (() => {
-					if (options.files !== void 0) return [...options.files];
-				})()
-			};
-			return { relatedFiles: (() => {
-				if (options.files !== void 0) return [...options.files];
-			})() };
-		})();
+		const filter = dryRunFilter(options);
 		const { rawTests, hasExternalError, externalErrorText } = yield* collectRaw(filter);
 		const decision = decideVitestDryRun(new VitestDryRunCommand({
 			rawTests,
@@ -988,31 +941,10 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			hasExternalError,
 			externalErrorText
 		}));
-		const result = Match.value(decision).pipe(Match.tag("Error", (error) => ({
+		return yield* Match.value(decision).pipe(Match.tag("Error", (error) => Effect$1.succeed({
 			status: "error",
 			errorMessage: error.errorMessage
-		})), Match.tag("Complete", (complete) => {
-			const raw = JSON.parse(complete.testsJson);
-			let tests;
-			if (Array.isArray(raw)) tests = raw.filter(isTestResultLike);
-			else tests = [];
-			return {
-				status: "complete",
-				tests
-			};
-		}), Match.exhaustive);
-		if (result.status === "complete") {
-			const mutantCoverage = yield* readMutantCoverage.pipe(Effect$1.mapError((cause) => new TestRunnerFailed({
-				runnerName: "vitest",
-				phase: "dryRun",
-				cause: errorToString(cause)
-			})));
-			if (mutantCoverage !== void 0) return {
-				...result,
-				mutantCoverage
-			};
-		}
-		return result;
+		})), 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({
@@ -1029,24 +961,31 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 			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;
-		if (state.ctx !== void 0) {
-			const localSetupFile = state.localSetupFile;
-			if (localSetupFile !== void 0) state.ctx.onClose(() => Effect$1.runPromise(fsService.remove(localSetupFile, {
-				recursive: true,
-				force: true
-			}).pipe(Effect$1.orElseSucceed(() => void 0))));
-			const currentCtx = state.ctx;
-			yield* Effect$1.tryPromise({
-				try: () => currentCtx.close(),
-				catch: (cause) => new TestRunnerFailed({
-					runnerName: "vitest",
-					phase: "dispose",
-					cause: errorToString(cause)
-				})
-			});
-		}
+		return yield* Option.match(Option.fromNullishOr(state.ctx), {
+			onNone: () => Effect$1.void,
+			onSome: (ctx) => disposeContext(ctx, state.localSetupFile)
+		});
 	});
 	return TestRunner.of({
 		capabilities,
@@ -1057,14 +996,21 @@ const makeVitestRunnerLayer = (input) => Layer.effect(TestRunner, Effect$1.gen(f
 	});
 }));
 function isTestResultLike(value) {
-	return typeof value === "object" && value !== null && "id" in value && typeof Reflect.get(value, "id") === "string";
+	return Predicate.isObject(value) && typeof value["id"] === "string";
 }
-function isIdRecord(value) {
-	return typeof value === "object" && value !== null && "id" in value && typeof Reflect.get(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)) if (mutantId in to) to[mutantId] = to[mutantId] + hitCount;
-	else to[mutantId] = hitCount;
+	for (const [mutantId, hitCount] of Object.entries(from)) mergeHitCount(to, mutantId, hitCount);
 }
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-vitest-runner",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -32,29 +32,29 @@
   },
   "dependencies": {
     "@systemfsoftware/effect-cell-types": "^6.0.1",
-    "@systemfsoftware/stryker-js": "^2.0.0"
+    "@systemfsoftware/stryker-js": "^3.0.0"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-rc.112",
+    "effect": "4.0.0-rc.112",
     "vitest": ">=2.0.0"
   },
   "devDependencies": {
-    "@effect/platform-node": "^4.0.0-rc.112",
+    "@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.112",
+    "effect": "4.0.0-rc.112",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/effect-gherkin-spec": "^4.0.1",
-    "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/all": "^2.0.0",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/all": "^1.1.3"
+    "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/effect-gherkin-spec": "^4.0.1",
+    "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "publishConfig": {
     "provenance": true