@systemfsoftware/stryker-js 13.0.0 → 13.1.0

package/dist/{run-stages.cell-BN__EOCk.mjs → run-stages.cell-rdoY0cVH.mjs}

@@ -1,9 +1,9 @@
-import { a as Reporter_exports, c as ErrorText_exports, d as Mutant_exports, i as Report_exports, l as Format_exports, n as Options_exports, o as TestRunner_exports, r as Plugin_exports, s as Trace_exports$1, t as Checker_exports, u as Instrument_exports } from "./dist-BscHZmXN.mjs";
-import { n as mergeConfigs, t as mergeConfig } from "./merge-config-DA_v1hGx.mjs";
-import { A as PluginLoadRefusedError, D as StreamSchemaVersion, E as VerdictReached, M as ModeSignal, N as OutputMode, O as PeerFailureTag, S as RunStarted, T as VerdictMutant, _ as RunFailed, c as Heartbeat, d as PhaseEntered, f as PlanKnown, g as RunEvent, i as FormatRegistryResolved, j as PluginNotFoundError, l as HelpRendered, m as PluginsReported, n as StageError, t as PrepareError, v as RunId, w as SkippedReported } from "./Run.schema-Bj7b_FMA.mjs";
+import { a as Reporter_exports, c as ErrorText_exports, d as Mutant_exports, i as Report_exports, l as Format_exports, n as Options_exports, o as TestRunner_exports, r as Plugin_exports, s as Trace_exports$1, t as Checker_exports, u as Instrument_exports } from "./dist-CQ7r4AaH.mjs";
+import { n as mergeConfigs, t as mergeConfig } from "./merge-config-DZHwEkGY.mjs";
+import { A as PluginLoadRefusedError, D as StreamSchemaVersion, E as VerdictReached, M as ModeSignal, N as OutputMode, O as PeerFailureTag, S as RunStarted, T as VerdictMutant, _ as RunFailed, c as Heartbeat, d as PhaseEntered, f as PlanKnown, g as RunEvent, i as FormatRegistryResolved, j as PluginNotFoundError, l as HelpRendered, m as PluginsReported, n as StageError, t as PrepareError, v as RunId, w as SkippedReported } from "./Run.schema-Cv2_Kup0.mjs";
 import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Boolean$1 from "effect/Boolean";
-import * as Match from "effect/Match";
+import * as Match$1 from "effect/Match";
 import * as Option$1 from "effect/Option";
 import * as Predicate$1 from "effect/Predicate";
 import * as Result from "effect/Result";
@@ -13,7 +13,7 @@ import { absurd, dual, pipe } from "effect/Function";
 import * as SchemaGetter$1 from "effect/SchemaGetter";
 import * as Arr from "effect/Array";
 import * as Context from "effect/Context";
-import { Boolean, Option, Predicate, Record, Schema, SchemaGetter, SchemaTransformation } from "effect";
+import { Boolean, Match, Option, Predicate, Record, Schema, SchemaGetter, SchemaTransformation } from "effect";
 import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
 import * as Metric from "effect/Metric";
 import * as Cause from "effect/Cause";
@@ -75,12 +75,20 @@ var CheckerAnsweredUnrequested = class extends S.TaggedError()("CheckerAnsweredU
 	phase: S.Literals(["check", "group"]),
 	unrequestedIds: S.Array(S.String),
 	requestedIds: S.Array(S.String)
-}) {};
+}) {
+	get message() {
+		return `Checker "${this.checkerName}" answered about mutants it was not asked about (${this.phase} phase): ${this.unrequestedIds.join(", ")}`;
+	}
+};
 var CheckerSkippedRequested = class extends S.TaggedError()("CheckerSkippedRequested", {
 	checkerName: S.String,
 	phase: S.Literals(["check", "group"]),
 	missingIds: S.Array(S.String)
-}) {};
+}) {
+	get message() {
+		return `Checker "${this.checkerName}" skipped requested mutants (${this.phase} phase): ${this.missingIds.join(", ")}`;
+	}
+};
 var CheckerCommand = class extends S.TaggedClass()("CheckerCommand", {
 	checkerName: S.String,
 	requestedIds: S.Array(Mutant_exports.MutantId),
@@ -137,7 +145,7 @@ const admitCheckerAnswer = Workflow.make({
 	command: CheckerCommand,
 	decision: S.Union([CheckGroupDecision, CheckResultDecision]),
 	error: S.Union([CheckerAnsweredUnrequested, CheckerSkippedRequested]),
-	decide: (command) => Match.value(command.phase).pipe(Match.when("group", () => evaluateGroup(command)), Match.when("check", () => evaluateCheckResult(command)), Match.exhaustive)
+	decide: (command) => Match$1.value(command.phase).pipe(Match$1.when("group", () => evaluateGroup(command)), Match$1.when("check", () => evaluateCheckResult(command)), Match$1.exhaustive)
 });
 Schema.TaggedError()("WorkerMethodError", {
 	message: Schema.String,
@@ -161,6 +169,13 @@ var ChildProcessCrashedError = class extends Schema.TaggedError()("ChildProcessC
 }) {
 	[WorkerExitTypeId$1] = WorkerExitTypeId$1;
 	exitClass = "InternalError";
+	get message() {
+		const exit = Match.valueTags(this.exit, {
+			Code: ({ code }) => `exit code ${code}`,
+			Signal: ({ signal }) => `signal ${signal}`
+		});
+		return `Worker child process ${this.pid} crashed (${exit})`;
+	}
 };
 var OutOfMemoryError = class extends Schema.TaggedError()("OutOfMemoryError", {
 	pid: ProcessId,
@@ -168,9 +183,15 @@ var OutOfMemoryError = class extends Schema.TaggedError()("OutOfMemoryError", {
 }) {
 	[WorkerExitTypeId$1] = WorkerExitTypeId$1;
 	exitClass = "RuntimeError";
+	get message() {
+		return `Worker process ${this.pid} ran out of memory (exit code ${this.exitCode})`;
+	}
 };
 var WorkerBootTimeoutError = class extends Schema.TaggedError()("WorkerBootTimeoutError", { pid: ProcessId }) {
 	exitClass = "InternalError";
+	get message() {
+		return `Worker process ${this.pid} did not boot before the boot window closed`;
+	}
 };
 //#endregion
 //#region src/Checker/Checker.handle.ts
@@ -194,7 +215,7 @@ const connectionCrashed = (cause) => ChildProcessCrashedError.make({
 const recordCheckerCall = (spanName, checkerName, mutants, call) => call.pipe(Effect$1.withSpan(spanName, { attributes: {
 	"stryker.checker.name": checkerName,
 	"stryker.mutants.count": mutants.length
-} }), Effect$1.timed, Effect$1.onExit((exit) => Match.value(exit).pipe(Match.tag("Success", () => Metric.update(checkerMutantsChecked, mutants.length)), Match.tag("Failure", (failure) => failure.cause.pipe(Cause.hasInterruptsOnly, Match.value, Match.when(true, () => Effect$1.void), Match.orElse(() => Metric.update(checkerRpcFailures, 1)))), Match.exhaustive)), Effect$1.tap(([duration]) => Metric.update(checkerDuration, duration)), Effect$1.map(([, result]) => result), Effect$1.mapError((error) => Match.value(error).pipe(Match.tag("CheckerFailed", (failed) => failed), Match.orElse((e) => connectionCrashed(e.message)))));
+} }), Effect$1.timed, Effect$1.onExit((exit) => Match$1.value(exit).pipe(Match$1.tag("Success", () => Metric.update(checkerMutantsChecked, mutants.length)), Match$1.tag("Failure", (failure) => failure.cause.pipe(Cause.hasInterruptsOnly, Match$1.value, Match$1.when(true, () => Effect$1.void), Match$1.orElse(() => Metric.update(checkerRpcFailures, 1)))), Match$1.exhaustive)), Effect$1.tap(([duration]) => Metric.update(checkerDuration, duration)), Effect$1.map(([, result]) => result), Effect$1.mapError((error) => Match$1.value(error).pipe(Match$1.tag("CheckerFailed", (failed) => failed), Match$1.orElse((e) => connectionCrashed(e.message)))));
 const checkOf = (self, checkerName, mutants) => recordCheckerCall("stryker.checker.check", checkerName, mutants, CheckerHandle.slot(self).check({
 	checkerName,
 	mutants: [...mutants]
@@ -214,6 +235,9 @@ var UndescribableMutant = class extends S.TaggedError()("UndescribableMutant", {
 	reason: S.String
 }) {
 	static skipped = Metric.counter("stryker.checker.mutants.skipped", { description: "Total number of mutants dropped because they cannot be described to a checker" });
+	get message() {
+		return `Mutant ${this.id} in ${this.fileName} cannot be described to a checker: ${this.reason}`;
+	}
 };
 const CheckerMutant = S.toType(Checker_exports.CheckerMutantWire);
 const CheckerMutantFromMutant = S.decodeTo(CheckerMutant, SchemaTransformation$1.transform({
@@ -407,7 +431,7 @@ const freezeSetValue = (value) => Object.freeze(new Set([...value.values()].map(
 const freezeRegExpValue = (value) => Object.freeze(value);
 const freezeRecordValue = (value) => Object.freeze(Record$1.map(value, (propertyValue) => deepFreeze(propertyValue)));
 function deepFreeze(target) {
-	return Match.value(target).pipe(Match.when(isArrayValue$1, freezeArrayValue), Match.when((value) => value instanceof Map, freezeMapValue), Match.when((value) => value instanceof RegExp, freezeRegExpValue), Match.when((value) => value instanceof Set, freezeSetValue), Match.when(isRecordValue, freezeRecordValue), Match.orElse(() => target));
+	return Match$1.value(target).pipe(Match$1.when(isArrayValue$1, freezeArrayValue), Match$1.when((value) => value instanceof Map, freezeMapValue), Match$1.when((value) => value instanceof RegExp, freezeRegExpValue), Match$1.when((value) => value instanceof Set, freezeSetValue), Match$1.when(isRecordValue, freezeRecordValue), Match$1.orElse(() => target));
 }
 const createDefaultOptions = S.decodeEffect(Options_exports.StrykerOptionsSchema)({}).pipe(Effect$1.orDie);
 const defaultOptions = Effect$1.map(createDefaultOptions, (options) => deepFreeze(options));
@@ -415,6 +439,9 @@ const defaultOptions = Effect$1.map(createDefaultOptions, (options) => deepFreez
 //#region src/ConfigError.schema.ts
 var ConfigFileNotFoundError = class extends S.TaggedError()("ConfigFileNotFoundError", { file: S.String }) {
 	exitClass = "ConfigError";
+	get message() {
+		return `Config file not found: ${this.file}`;
+	}
 };
 var ConfigFileUnsupportedError = class extends S.TaggedError()("ConfigFileUnsupportedError", {
 	file: S.String,
@@ -430,12 +457,18 @@ var ConfigFileUnreadableError = class extends S.TaggedError()("ConfigFileUnreada
 	cause: S.Unknown
 }) {
 	exitClass = "ConfigError";
+	get message() {
+		return `Config file is unreadable: ${this.file}`;
+	}
 };
 var ConfigFileInvalidError = class extends S.TaggedError()("ConfigFileInvalidError", {
 	file: S.String,
 	cause: S.Unknown
 }) {
 	exitClass = "ConfigError";
+	get message() {
+		return `Invalid config file: ${this.file}`;
+	}
 };
 var ConfigFactoryFailed = class extends S.TaggedError()("ConfigFactoryFailed", {
 	message: S.String,
@@ -484,7 +517,7 @@ const unloadableOf = (file, code, message) => ConfigImportDescribed.make({
 	code,
 	message
 });
-const importDecisionOf = (command) => Match.value(errorCodeOf(command.cause)).pipe(Match.when("ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX", (code) => unloadableOf(command.file, code, `The config file "${command.file}" uses TypeScript syntax Node cannot execute. ${ERASABLE_SYNTAX_HELP}`)), Match.when("ERR_UNKNOWN_FILE_EXTENSION", (code) => unloadableOf(command.file, code, `The config file "${command.file}" has an extension Node cannot load. Stryker reads config modules with ${SUPPORTED_CONFIG_FILE_EXTENSION_GUIDE$1}.`)), Match.when("ERR_MODULE_NOT_FOUND", (code) => unloadableOf(command.file, code, `The config file "${command.file}" imports a module Node cannot find. The specifier is most likely not installed — install it as a dependency of the project, or remove the import. Node reported: ${importFailureDetailOf(command)}`)), Match.when("ERR_PACKAGE_PATH_NOT_EXPORTED", (code) => unloadableOf(command.file, code, `The config file "${command.file}" imports a path a package does not export. The package is installed but its "exports" map leaves this specifier out — import a path the package publishes. Node reported: ${importFailureDetailOf(command)}`)), Match.orElse(() => ConfigImportUnclassified.make({})));
+const importDecisionOf = (command) => Match$1.value(errorCodeOf(command.cause)).pipe(Match$1.when("ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX", (code) => unloadableOf(command.file, code, `The config file "${command.file}" uses TypeScript syntax Node cannot execute. ${ERASABLE_SYNTAX_HELP}`)), Match$1.when("ERR_UNKNOWN_FILE_EXTENSION", (code) => unloadableOf(command.file, code, `The config file "${command.file}" has an extension Node cannot load. Stryker reads config modules with ${SUPPORTED_CONFIG_FILE_EXTENSION_GUIDE$1}.`)), Match$1.when("ERR_MODULE_NOT_FOUND", (code) => unloadableOf(command.file, code, `The config file "${command.file}" imports a module Node cannot find. The specifier is most likely not installed — install it as a dependency of the project, or remove the import. Node reported: ${importFailureDetailOf(command)}`)), Match$1.when("ERR_PACKAGE_PATH_NOT_EXPORTED", (code) => unloadableOf(command.file, code, `The config file "${command.file}" imports a path a package does not export. The package is installed but its "exports" map leaves this specifier out — import a path the package publishes. Node reported: ${importFailureDetailOf(command)}`)), Match$1.orElse(() => ConfigImportUnclassified.make({})));
 const describeConfigModuleFailure = Workflow.make({
 	command: DescribeConfigImportCommand,
 	decision: S.Union([ConfigImportDescribed, ConfigImportUnclassified]),
@@ -632,13 +665,13 @@ const nextStateOf = (state, file, document) => ({
 	}]
 });
 const doneOf = (state) => ExtendsStepDone.make({ options: mergeChainDocuments(state.documents) });
-const extendsValueOf = (extendValue, state) => Match.value(isModuleSpecifier(extendValue)).pipe(Match.when(true, () => ExtendsStepResolve.make({
+const extendsValueOf = (extendValue, state) => Match$1.value(isModuleSpecifier(extendValue)).pipe(Match$1.when(true, () => ExtendsStepResolve.make({
 	specifier: extendValue,
 	state
-})), Match.when(false, () => ExtendsStepRead.make({
+})), Match$1.when(false, () => ExtendsStepRead.make({
 	specifier: extendValue,
 	state
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const cycleRefusalOf = (file) => ExtendsStepRefused.make({
 	reason: "cycle",
 	file
@@ -649,9 +682,9 @@ const nonStringRefusalOf = (file) => ExtendsStepRefused.make({
 });
 const advanceStepOf = (command) => {
 	const nextState = nextStateOf(command.state, command.file, command.document);
-	return Match.value(command.document["extends"]).pipe(Match.when(void 0, () => doneOf(nextState)), Match.when(null, () => doneOf(nextState)), Match.when(Match.string, (extendValue) => extendsValueOf(extendValue, nextState)), Match.orElse(() => nonStringRefusalOf(command.file)));
+	return Match$1.value(command.document["extends"]).pipe(Match$1.when(void 0, () => doneOf(nextState)), Match$1.when(null, () => doneOf(nextState)), Match$1.when(Match$1.string, (extendValue) => extendsValueOf(extendValue, nextState)), Match$1.orElse(() => nonStringRefusalOf(command.file)));
 };
-const stepDecisionOf = (command) => Match.value(command.state.visited.includes(command.file)).pipe(Match.when(true, () => cycleRefusalOf(command.file)), Match.orElse(() => advanceStepOf(command)));
+const stepDecisionOf = (command) => Match$1.value(command.state.visited.includes(command.file)).pipe(Match$1.when(true, () => cycleRefusalOf(command.file)), Match$1.orElse(() => advanceStepOf(command)));
 const extendsStepWorkflow = Workflow.make({
 	command: ExtendsStepCommand,
 	decision: S.Union([
@@ -670,7 +703,11 @@ var StrykerError = class extends Schema.TaggedError()("StrykerError", {
 	message: Schema.String,
 	cause: Schema.optional(Schema.Unknown)
 }) {};
-var ReporterStageForged = class extends Schema.TaggedError()("ReporterStageForged", {}) {};
+var ReporterStageForged = class extends Schema.TaggedError()("ReporterStageForged", {}) {
+	get message() {
+		return "Reporter stage is missing its attachments";
+	}
+};
 var ReporterFactoryThrew = class extends Schema.TaggedError()("ReporterFactoryThrew", {
 	reporterName: Schema.String,
 	message: Schema.String,
@@ -715,7 +752,7 @@ const extendsChildKind = (configFile, pathService) => Boolean$1.match(isLegacyCo
 	onFalse: () => "supported"
 });
 const exists = Effect$1.fn("stryker.config.exists")(function* (fileName) {
-	return yield* (yield* FileSystem.FileSystem).access(fileName).pipe(Effect$1.as(true), Effect$1.catchTag("PlatformError", (error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect$1.succeed(false)), Match.orElse(() => Effect$1.fail(ConfigFileUnreadableError.make({
+	return yield* (yield* FileSystem.FileSystem).access(fileName).pipe(Effect$1.as(true), Effect$1.catchTag("PlatformError", (error) => Match$1.value(error.reason).pipe(Match$1.tag("NotFound", () => Effect$1.succeed(false)), Match$1.orElse(() => Effect$1.fail(ConfigFileUnreadableError.make({
 		file: fileName,
 		cause: error
 	}))))), Effect$1.mapError((error) => ConfigFileUnreadableError.make({
@@ -728,13 +765,13 @@ const firstExistingConfigFile = (fileNames) => Stream.fromIterable(fileNames).pi
 	present
 })))), Stream.filter((probed) => probed.present), Stream.map((probed) => probed.fileName), Stream.runHead);
 const discoveryDecisionOf = (command) => Result.getOrElse(discoverConfigFile(command), (neverError) => neverError);
-const actionableConfigFileOf = (decision) => Match.value(decision).pipe(Match.tag("ConfigFileRead", (read) => Option$1.match(Option$1.fromUndefinedOr(read.shadowedLegacyWarning), {
+const actionableConfigFileOf = (decision) => Match$1.value(decision).pipe(Match$1.tag("ConfigFileRead", (read) => Option$1.match(Option$1.fromUndefinedOr(read.shadowedLegacyWarning), {
 	onSome: (warning) => Effect$1.as(Effect$1.logWarning(warning), Option$1.some(read.file)),
 	onNone: () => Effect$1.succeedSome(read.file)
-})), Match.tag("ConfigFileRefused", (refused) => Effect$1.fail(ConfigFileUnsupportedError.make({
+})), Match$1.tag("ConfigFileRefused", (refused) => Effect$1.fail(ConfigFileUnsupportedError.make({
 	file: refused.file,
 	hint: refused.hint
-}))), Match.tag("ConfigFileMissing", (missing) => Effect$1.fail(ConfigFileNotFoundError.make({ file: missing.file }))), Match.tag("NoConfigFile", () => Effect$1.succeedNone), Match.exhaustive);
+}))), Match$1.tag("ConfigFileMissing", (missing) => Effect$1.fail(ConfigFileNotFoundError.make({ file: missing.file }))), Match$1.tag("NoConfigFile", () => Effect$1.succeedNone), Match$1.exhaustive);
 const configFilePresence = (configFileName, kind) => kind === "supported" ? exists(configFileName) : Effect$1.succeed(false);
 const expectedConfigFileOf = Effect$1.fn("stryker.config.expectedFile")(function* (configFileName, context) {
 	const pathService = yield* Path.Path;
@@ -801,16 +838,16 @@ const resolveExtendsSpecifier = (specifier) => Effect$1.try({
 		cause
 	})
 });
-const configImportCauseOf = (configFile, failure) => Match.value(Result.getOrElse(describeConfigModuleFailure(DescribeConfigImportCommand.make({
+const configImportCauseOf = (configFile, failure) => Match$1.value(Result.getOrElse(describeConfigModuleFailure(DescribeConfigImportCommand.make({
 	file: configFile,
 	message: failure.message,
 	cause: failure.cause
-})), (neverError) => neverError)).pipe(Match.tag("ConfigImportDescribed", (described) => ConfigModuleUnloadable.make({
+})), (neverError) => neverError)).pipe(Match$1.tag("ConfigImportDescribed", (described) => ConfigModuleUnloadable.make({
 	code: described.code,
 	file: configFile,
 	message: described.message,
 	cause: failure.cause
-})), Match.tag("ConfigImportUnclassified", () => failure), Match.exhaustive);
+})), Match$1.tag("ConfigImportUnclassified", () => failure), Match$1.exhaustive);
 const FACTORY_FAILED = "Evaluating the config module's exported factory failed";
 const factoryFailureOf = (cause) => ConfigFactoryFailed.make({
 	cause,
@@ -868,14 +905,14 @@ const resolveExtends = Effect$1.fn("stryker.config.extends")(function* (configFi
 			return yield* loop(nextState, childFile, childDocument);
 		});
 		const resolvedChild = (specifier, nextState) => resolveExtendsSpecifier(specifier).pipe(Effect$1.flatMap((resolvedUrl) => readExtendsChild(resolvedUrl, configEnv).pipe(Effect$1.flatMap((childDocument) => loop(nextState, resolvedUrl, childDocument)))));
-		return yield* Match.value(extendsStep(ExtendsStepCommand.make({
+		return yield* Match$1.value(extendsStep(ExtendsStepCommand.make({
 			state,
 			document: currentDocument,
 			file: canonicalFile
-		}))).pipe(Match.tag("done", (decision) => Effect$1.succeed(decision.options)), Match.tag("read", (decision) => readChild(decision.specifier, decision.state)), Match.tag("resolve", (decision) => resolvedChild(decision.specifier, decision.state)), Match.tag("refused", (decision) => Effect$1.fail(ConfigFileInvalidError.make({
+		}))).pipe(Match$1.tag("done", (decision) => Effect$1.succeed(decision.options)), Match$1.tag("read", (decision) => readChild(decision.specifier, decision.state)), Match$1.tag("resolve", (decision) => resolvedChild(decision.specifier, decision.state)), Match$1.tag("refused", (decision) => Effect$1.fail(ConfigFileInvalidError.make({
 			file: decision.file,
-			cause: Match.value(decision.reason).pipe(Match.when("cycle", () => `Config inheritance cycle detected at "${decision.file}"`), Match.orElse(() => `Invalid config file "${decision.file}". "extends" must be a string`))
-		}))), Match.exhaustive);
+			cause: Match$1.value(decision.reason).pipe(Match$1.when("cycle", () => `Config inheritance cycle detected at "${decision.file}"`), Match$1.orElse(() => `Invalid config file "${decision.file}". "extends" must be a string`))
+		}))), Match$1.exhaustive);
 	});
 	return yield* loop(initialExtendsStepState, configFile, document);
 });
@@ -929,37 +966,37 @@ const PATH_LINE = /^at\s+(\[[^\]]*\])$/;
 const PATH_SEGMENT = /\["([^"]*)"\]|\[(\d+)\]/g;
 const EXPECTED_PATTERN = /^Expected a string matching the RegExp (.+)$/;
 const EXPECTED_TYPE = /^Expected (.+)$/;
-const appendPathSegment = (path, segment) => Match.value(segment[2]).pipe(Match.when(void 0, () => appendKeySegment(path, Option$1.getOrElse(Option$1.fromUndefinedOr(segment[1]), () => ""))), Match.orElse((index) => `${path}[${index}]`));
-const appendKeySegment = (path, key) => Match.value(path.length > 0).pipe(Match.when(true, () => `${path}.${key}`), Match.orElse(() => `${path}${key}`));
+const appendPathSegment = (path, segment) => Match$1.value(segment[2]).pipe(Match$1.when(void 0, () => appendKeySegment(path, Option$1.getOrElse(Option$1.fromUndefinedOr(segment[1]), () => ""))), Match$1.orElse((index) => `${path}[${index}]`));
+const appendKeySegment = (path, key) => Match$1.value(path.length > 0).pipe(Match$1.when(true, () => `${path}.${key}`), Match$1.orElse(() => `${path}${key}`));
 const dottedPath = (raw) => Array.from(raw.matchAll(PATH_SEGMENT)).reduce(appendPathSegment, "");
-const phraseExpectedType = (expectation) => Match.value(EXPECTED_TYPE.exec(expectation)).pipe(Match.when((match) => match !== null, (match) => `should be ${Option$1.getOrElse(Option$1.fromUndefinedOr(match[1]), () => "")}`), Match.orElse(() => expectation));
-const phrase = (expectation) => Match.value(EXPECTED_PATTERN.exec(expectation)).pipe(Match.when((match) => match !== null, (match) => `must match pattern "${Option$1.getOrElse(Option$1.fromUndefinedOr(match[1]), () => "")}"`), Match.orElse(() => phraseExpectedType(expectation)));
+const phraseExpectedType = (expectation) => Match$1.value(EXPECTED_TYPE.exec(expectation)).pipe(Match$1.when((match) => match !== null, (match) => `should be ${Option$1.getOrElse(Option$1.fromUndefinedOr(match[1]), () => "")}`), Match$1.orElse(() => expectation));
+const phrase = (expectation) => Match$1.value(EXPECTED_PATTERN.exec(expectation)).pipe(Match$1.when((match) => match !== null, (match) => `must match pattern "${Option$1.getOrElse(Option$1.fromUndefinedOr(match[1]), () => "")}"`), Match$1.orElse(() => phraseExpectedType(expectation)));
 const EMPTY_ERROR_DESCRIPTION_STATE = {
 	messages: [],
 	expectation: void 0
 };
 const isBlankLine = (line) => line.length === 0;
-const startExpectation = (state, line) => Match.value(state.expectation).pipe(Match.when(void 0, () => ({
+const startExpectation = (state, line) => Match$1.value(state.expectation).pipe(Match$1.when(void 0, () => ({
 	messages: state.messages,
 	expectation: line
-})), Match.orElse((pending) => ({
+})), Match$1.orElse((pending) => ({
 	messages: [...state.messages, pending],
 	expectation: line
 })));
-const completeExpectation = (state, pathText, line) => Match.value(state.expectation).pipe(Match.when(void 0, () => startExpectation(state, line)), Match.orElse((pending) => ({
+const completeExpectation = (state, pathText, line) => Match$1.value(state.expectation).pipe(Match$1.when(void 0, () => startExpectation(state, line)), Match$1.orElse((pending) => ({
 	messages: [...state.messages, `Config option "${dottedPath(pathText)}" ${phrase(pending)}.`],
 	expectation: void 0
 })));
-const applyErrorLine = (state, line) => Match.value(PATH_LINE.exec(line)).pipe(Match.when((match) => match !== null, (match) => completeExpectation(state, Option$1.getOrElse(Option$1.fromUndefinedOr(match[1]), () => ""), line)), Match.orElse(() => startExpectation(state, line)));
-const advanceErrorDescription = (state, rawLine) => Match.value(rawLine.trim()).pipe(Match.when(isBlankLine, () => state), Match.orElse((line) => applyErrorLine(state, line)));
-const completedErrorMessages = (state) => Match.value(state.expectation).pipe(Match.when(void 0, () => state.messages), Match.orElse((pending) => [...state.messages, pending]));
-const errorMessageOrFallback = (messages, fallback) => Match.value(messages.length > 0).pipe(Match.when(true, () => [...messages]), Match.orElse(() => [fallback]));
+const applyErrorLine = (state, line) => Match$1.value(PATH_LINE.exec(line)).pipe(Match$1.when((match) => match !== null, (match) => completeExpectation(state, Option$1.getOrElse(Option$1.fromUndefinedOr(match[1]), () => ""), line)), Match$1.orElse(() => startExpectation(state, line)));
+const advanceErrorDescription = (state, rawLine) => Match$1.value(rawLine.trim()).pipe(Match$1.when(isBlankLine, () => state), Match$1.orElse((line) => applyErrorLine(state, line)));
+const completedErrorMessages = (state) => Match$1.value(state.expectation).pipe(Match$1.when(void 0, () => state.messages), Match$1.orElse((pending) => [...state.messages, pending]));
+const errorMessageOrFallback = (messages, fallback) => Match$1.value(messages.length > 0).pipe(Match$1.when(true, () => [...messages]), Match$1.orElse(() => [fallback]));
 const messageErrorsOf = (message) => {
 	const state = message.split("\n").reduce(advanceErrorDescription, EMPTY_ERROR_DESCRIPTION_STATE);
 	return completedErrorMessages(state);
 };
 const messageErrorsOrFallback = (messages, fallback) => errorMessageOrFallback(messages, fallback);
-const configErrorHeadline = (errors) => Match.value(errors.length === 1).pipe(Match.when(true, () => "Please correct this configuration error and try again."), Match.orElse(() => "Please correct these configuration errors and try again."));
+const configErrorHeadline = (errors) => Match$1.value(errors.length === 1).pipe(Match$1.when(true, () => "Please correct this configuration error and try again."), Match$1.orElse(() => "Please correct these configuration errors and try again."));
 const configErrorMessage = (errors) => `${configErrorHeadline(errors)} ${errors.join(" ")}`;
 const describedOf = (command) => Option$1.match(Option$1.fromUndefinedOr(command.errors), {
 	onSome: (errors) => ConfigErrorDescribed.make({
@@ -1059,12 +1096,12 @@ const PRECEDENCE = [
 	"VerdictFail"
 ];
 const precedenceOf = (pending) => Arr.findFirst(PRECEDENCE, (candidate) => pending.includes(candidate));
-const decisionOf$2 = (exitClass) => Match.value(exitClass).pipe(Match.when("VerdictFail", () => ExitVerdictFailed.make({})), Match.when("ConfigError", () => ExitConfigErrored.make({})), Match.when("RuntimeError", () => ExitRuntimeErrored.make({})), Match.when("InternalError", () => ExitInternalErrored.make({})), Match.exhaustive);
-const verdictExitClass = (score, breakingThreshold) => Match.valueTags(score, {
+const decisionOf$2 = (exitClass) => Match$1.value(exitClass).pipe(Match$1.when("VerdictFail", () => ExitVerdictFailed.make({})), Match$1.when("ConfigError", () => ExitConfigErrored.make({})), Match$1.when("RuntimeError", () => ExitRuntimeErrored.make({})), Match$1.when("InternalError", () => ExitInternalErrored.make({})), Match$1.exhaustive);
+const verdictExitClass = (score, breakingThreshold) => Match$1.valueTags(score, {
 	Unscored: () => null,
 	Scored: ({ percentage }) => Option$1.match(Option$1.fromNullishOr(breakingThreshold), {
 		onNone: () => null,
-		onSome: (threshold) => Match.value(percentage < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)
+		onSome: (threshold) => Match$1.value(percentage < threshold).pipe(Match$1.when(true, () => "VerdictFail"), Match$1.when(false, () => null), Match$1.exhaustive)
 	})
 });
 const decide$15 = (command) => Option$1.match(Option$1.fromNullishOr(verdictExitClass(command.score, command.breakingThreshold)), {
@@ -1085,7 +1122,11 @@ const classifyExit = Workflow.make({
 var ManifestUnreadable = class extends Schema.TaggedError()("ManifestUnreadable", {
 	specifier: Schema.String,
 	cause: Schema.Unknown
-}) {};
+}) {
+	get message() {
+		return `Package manifest is unreadable: ${this.specifier}`;
+	}
+};
 const ManifestSchema = Schema.Struct({ version: Schema.optional(Schema.String) });
 //#endregion
 //#region src/project-files.service.ts
@@ -1142,7 +1183,11 @@ var __exportAll$1 = (all, no_symbols) => {
 };
 //#endregion
 //#region ../stryker-js-plugin-runtime/dist/index.mjs
-var TraceContextUnavailable = class extends S.TaggedError()("TraceContextUnavailable", { reason: S.Literals(["invalid-span-context", "undecodable-parts"]) }) {};
+var TraceContextUnavailable = class extends S.TaggedError()("TraceContextUnavailable", { reason: S.Literals(["invalid-span-context", "undecodable-parts"]) }) {
+	get message() {
+		return Match$1.value(this.reason).pipe(Match$1.when("invalid-span-context", () => "Cannot read trace context: the span context is invalid"), Match$1.when("undecodable-parts", () => "Cannot read trace context: the trace context parts could not be decoded"), Match$1.exhaustive);
+	}
+};
 const CURRENT_VERSION = "00";
 const SAMPLED_FLAG = 1;
 const EffectSpanShape = S.Struct({
@@ -1267,10 +1312,10 @@ var WorkerOptions = class WorkerOptions extends Context.Service()("@systemfsoftw
 const traceContextServer = layerTraceContextServer;
 const NAMED_PIPE_PREFIX = "\\\\.\\pipe\\";
 const restrictSocket = Effect$1.fn("restrictSocket")(function* (address) {
-	yield* Match.value(address).pipe(Match.tag("UnixPathAddress", ({ path }) => Boolean$1.match(path.startsWith(NAMED_PIPE_PREFIX), {
+	yield* Match$1.value(address).pipe(Match$1.tag("UnixPathAddress", ({ path }) => Boolean$1.match(path.startsWith(NAMED_PIPE_PREFIX), {
 		onTrue: () => Effect$1.void,
 		onFalse: () => Effect$1.flatMap(FileSystem.FileSystem, (fs) => fs.chmod(path, 384))
-	})), Match.orElse(() => Effect$1.void));
+	})), Match$1.orElse(() => Effect$1.void));
 });
 const restrictedSocket = Layer.effectDiscard(Effect$1.flatMap(SocketServer.SocketServer, (socket) => restrictSocket(socket.address)));
 const TypeId$12 = Symbol.for("~systemfsoftware/stryker-js-plugin-runtime/WorkerServer");
@@ -1482,7 +1527,7 @@ const offerToChannel = Effect$1.fn("stryker.reporterStream.offerToChannel")(func
 	const offered = yield* PubSub.publish(attachment.channel, event).pipe(Effect$1.timeoutOption(REPORTER_STALL_TIMEOUT));
 	return yield* Option$1.match(offered, {
 		onNone: () => detachStalledReporter(attachment),
-		onSome: (accepted) => Match.value(accepted).pipe(Match.when(true, () => noteTerminalOffered(attachment, event)), Match.orElse(() => warnEventDropped(attachment)))
+		onSome: (accepted) => Match$1.value(accepted).pipe(Match$1.when(true, () => noteTerminalOffered(attachment, event)), Match$1.orElse(() => warnEventDropped(attachment)))
 	});
 });
 const deliverReporterEvent = (attachment, event) => Effect$1.flatMap(SynchronizedRef.get(attachment.state), (state) => Boolean$1.match(state.detached, {
@@ -1526,7 +1571,7 @@ const settleAttachment = Effect$1.fn("stryker.reporterStream.settle")(function*
 		})
 	});
 });
-const failedReporterNames = (outcome) => Match.value(outcome).pipe(Match.when({ kind: "terminal-failed" }, (failed) => [failed.name]), Match.orElse(() => []));
+const failedReporterNames = (outcome) => Match$1.value(outcome).pipe(Match$1.when({ kind: "terminal-failed" }, (failed) => [failed.name]), Match$1.orElse(() => []));
 const shutdownUnreportedChannel = (attachment) => Effect$1.flatMap(SynchronizedRef.get(attachment.state), (state) => Boolean$1.match(state.terminalOffered, {
 	onTrue: () => Effect$1.void,
 	onFalse: () => PubSub.shutdown(attachment.channel)
@@ -1563,6 +1608,17 @@ const environmentTraceInit = Effect$1.fn("stryker.reporterStream.environmentTrac
 	};
 });
 const initFromEnvironment = () => Effect$1.map(environmentTraceInit(), (init) => Option$1.getOrUndefined(Option$1.filter(Option$1.some(init), hasTraceFields)));
+Effect$1.gen(function* () {
+	const traceparent = yield* Config.String("TRACEPARENT").pipe(Effect$1.option);
+	const tracestate = yield* Config.String("TRACESTATE").pipe(Effect$1.option);
+	return Option$1.map(Option$1.flatMap(traceparent, S.decodeOption(Trace_exports$1.Traceparent)), (parts) => ({
+		...parts,
+		...Option$1.match(Option$1.flatMap(tracestate, S.decodeOption(Trace_exports$1.Tracestate)), {
+			onNone: () => ({}),
+			onSome: (traceState) => ({ traceState })
+		})
+	}));
+});
 const currentReporterInit = Effect$1.fn("stryker.reporterStream.currentReporterInit")(function* (span) {
 	const fromEnvironment = yield* initFromEnvironment();
 	const current = Option$1.getOrUndefined(yield* Effect$1.currentSpan.pipe(Effect$1.option));
@@ -1582,7 +1638,7 @@ var MetricsResultFromReport = class MetricsResultFromReport extends S.Class("Met
 }) {};
 //#endregion
 //#region src/reporting/metrics-from-report.ts
-const segmentOf = (fileName) => Match.value(fileName.indexOf("/")).pipe(Match.when((separator) => separator < 0, () => fileName), Match.orElse((separator) => fileName.slice(0, separator)));
+const segmentOf = (fileName) => Match$1.value(fileName.indexOf("/")).pipe(Match$1.when((separator) => separator < 0, () => fileName), Match$1.orElse((separator) => fileName.slice(0, separator)));
 const groupBySegment = (entries) => Arr.groupBy(entries, ([fileName]) => segmentOf(fileName));
 const metricsOf = (entries) => Report_exports.metricsFromMutants(Arr.flatMap(entries, ([, file]) => file.mutants));
 const fileResultOf = (fileName, file) => MetricsResultFromReport.make({
@@ -1598,7 +1654,7 @@ const nestedGroupResult = (segment, entries) => {
 		childResults: childResultsOf(nested)
 	});
 };
-const groupResultsOf = (segment, entries) => Match.value(entries.every(([fileName]) => fileName === segment)).pipe(Match.when(true, () => entries.map(([fileName, file]) => fileResultOf(fileName, file))), Match.orElse(() => [nestedGroupResult(segment, entries)]));
+const groupResultsOf = (segment, entries) => Match$1.value(entries.every(([fileName]) => fileName === segment)).pipe(Match$1.when(true, () => entries.map(([fileName, file]) => fileResultOf(fileName, file))), Match$1.orElse(() => [nestedGroupResult(segment, entries)]));
 const childResultsOf = (entries) => Object.entries(groupBySegment(entries)).flatMap(([segment, grouped]) => groupResultsOf(segment, grouped)).sort((left, right) => left.name.localeCompare(right.name));
 const metricsResultFromFiles = (files) => MetricsResultFromReport.make({
 	name: "All files",
@@ -1633,7 +1689,7 @@ const emitQuint = (accumulator) => {
 		chars: accumulator.chars + CROCKFORD_BASE32[accumulator.value >>> bits & 31]
 	};
 };
-const drainQuints = (accumulator) => Match.value(accumulator.bits >= 5).pipe(Match.when(true, () => drainQuints(emitQuint(accumulator))), Match.when(false, () => accumulator), Match.exhaustive);
+const drainQuints = (accumulator) => Match$1.value(accumulator.bits >= 5).pipe(Match$1.when(true, () => drainQuints(emitQuint(accumulator))), Match$1.when(false, () => accumulator), Match$1.exhaustive);
 const pushByte = (accumulator, byte) => drainQuints({
 	value: accumulator.value << 8 | byte,
 	bits: accumulator.bits + 8,
@@ -1655,7 +1711,7 @@ const runIdTextOf = (now) => {
 		bits: 0,
 		chars: ""
 	}, pushByte);
-	return Match.value(drained.bits > 0).pipe(Match.when(true, () => drained.chars + CROCKFORD_BASE32[drained.value << 5 - drained.bits & 31]), Match.when(false, () => drained.chars), Match.exhaustive);
+	return Match$1.value(drained.bits > 0).pipe(Match$1.when(true, () => drained.chars + CROCKFORD_BASE32[drained.value << 5 - drained.bits & 31]), Match$1.when(false, () => drained.chars), Match$1.exhaustive);
 };
 const generateRunId = (now) => RunId.make(runIdTextOf(now));
 const isActionableStatus = S.is(Mutant_exports.ActionableStatusSchema);
@@ -1702,7 +1758,7 @@ var RunEvents = class extends Context.Service()("@systemfsoftware/stryker-js/run
 var RunIdentity = class extends Context.Service()("@systemfsoftware/stryker-js/run-events.service/RunIdentity") {};
 //#endregion
 //#region package.json
-var version = "13.0.0";
+var version = "13.1.0";
 //#endregion
 //#region src/stryker-package.schema.ts
 var StrykerPackage = class extends S.Class("StrykerPackage")({
@@ -1784,11 +1840,11 @@ const reasonedOutcomeOf = (reason) => Option$1.match(Option$1.fromNullishOr(reas
 	onNone: () => ({}),
 	onSome: (present) => ({ statusReason: present })
 });
-const mapRunResult = (mutant, result) => Match.value(result).pipe(Match.discriminator("status")("error", (errored) => reportMutant(mutant, "RuntimeError", { statusReason: errored.errorMessage })), Match.discriminator("status")("killed", (killed) => reportMutant(mutant, "Killed", {
+const mapRunResult = (mutant, result) => Match$1.value(result).pipe(Match$1.discriminator("status")("error", (errored) => reportMutant(mutant, "RuntimeError", { statusReason: errored.errorMessage })), Match$1.discriminator("status")("killed", (killed) => reportMutant(mutant, "Killed", {
 	testsCompleted: killed.nrOfTests,
 	killedBy: [...killed.killedBy],
 	statusReason: killed.failureMessage
-})), Match.discriminator("status")("timeout", (timedOut) => reportMutant(mutant, "Timeout", reasonedOutcomeOf(timedOut.reason))), Match.discriminator("status")("survived", (survived) => reportMutant(mutant, "Survived", { testsCompleted: survived.nrOfTests })), Match.exhaustive);
+})), Match$1.discriminator("status")("timeout", (timedOut) => reportMutant(mutant, "Timeout", reasonedOutcomeOf(timedOut.reason))), Match$1.discriminator("status")("survived", (survived) => reportMutant(mutant, "Survived", { testsCompleted: survived.nrOfTests })), Match$1.exhaustive);
 const uniqueNames = (names) => Arr.dedupe(Arr.filter(names, (name) => name !== void 0));
 const partitionByFile = (files, fileNames) => {
 	const [missing, present] = Arr.separate(Arr.map(fileNames, (fileName) => Option$1.match(MutableHashMap.get(files, fileName), {
@@ -2002,7 +2058,7 @@ const determineExitCode = (input) => (metrics) => {
 		breakingThreshold: breaking
 	})), {
 		onFailure: (refused) => refused,
-		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("ExitVerdictFailed", () => "VerdictFail"), Match.orElse(() => null))
+		onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("ExitVerdictFailed", () => "VerdictFail"), Match$1.orElse(() => null))
 	}));
 	return Report_exports.MutationScore.match(score, {
 		Scored: ({ percentage }) => Option$1.match(failure, {
@@ -2012,8 +2068,8 @@ const determineExitCode = (input) => (metrics) => {
 		Unscored: () => Effect$1.as(logUnscored(breaking), Option$1.getOrNull(failure))
 	});
 };
-const logScoredPass = (breaking, percentage) => Match.value(breaking).pipe(Match.when(null, () => Effect$1.logDebug("No breaking threshold configured. Won't fail the build no matter how low your mutation score is. Set `thresholds.break` to change this behavior.")), Match.orElse((threshold) => Effect$1.logInfo(`Final mutation score of ${percentage.toFixed(2)} is greater than or equal to break threshold ${String(threshold)}`)));
-const logUnscored = (breaking) => Match.value(breaking).pipe(Match.when(null, () => Effect$1.void), Match.orElse((threshold) => Effect$1.logInfo(`No valid mutant was tested, so there is no mutation score to hold against break threshold ${String(threshold)}`)));
+const logScoredPass = (breaking, percentage) => Match$1.value(breaking).pipe(Match$1.when(null, () => Effect$1.logDebug("No breaking threshold configured. Won't fail the build no matter how low your mutation score is. Set `thresholds.break` to change this behavior.")), Match$1.orElse((threshold) => Effect$1.logInfo(`Final mutation score of ${percentage.toFixed(2)} is greater than or equal to break threshold ${String(threshold)}`)));
+const logUnscored = (breaking) => Match$1.value(breaking).pipe(Match$1.when(null, () => Effect$1.void), Match$1.orElse((threshold) => Effect$1.logInfo(`No valid mutant was tested, so there is no mutation score to hold against break threshold ${String(threshold)}`)));
 const logBroken = (breaking, percentage) => Effect$1.andThen(Effect$1.logError(`Final mutation score ${percentage.toFixed(2)} under breaking threshold ${String(breaking)}, setting exit code to 1 (failure).`), Effect$1.logInfo("(improve mutation score or set `thresholds.break = null` to prevent this error in the future)"));
 const emitVerdict = Effect$1.fn("stryker.mutationReporting.emitVerdict")(function* (deps, input, report) {
 	const envelope = buildVerdictEnvelope(report, input.resolvedMode.mode, input.resolvedMode.signal, RunId.make(input.runId), input.basePath, deps.path);
@@ -2050,7 +2106,7 @@ const reportAll = Effect$1.fn("stryker.mutationReporting.reportAll")(function* (
 		breakingThreshold: null
 	})), {
 		onFailure: (refused) => refused,
-		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("ExitVerdictFailed", () => "VerdictFail"), Match.tag("ExitConfigErrored", () => "ConfigError"), Match.tag("ExitRuntimeErrored", () => "RuntimeError"), Match.tag("ExitInternalErrored", () => "InternalError"), Match.orElse(() => null))
+		onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("ExitVerdictFailed", () => "VerdictFail"), Match$1.tag("ExitConfigErrored", () => "ConfigError"), Match$1.tag("ExitRuntimeErrored", () => "RuntimeError"), Match$1.tag("ExitInternalErrored", () => "InternalError"), Match$1.orElse(() => null))
 	});
 	yield* emitVerdict(deps, input, report);
 	yield* Boolean$1.match(input.options.incremental, {
@@ -2200,7 +2256,7 @@ const emphasized = (allowColor, tone) => Boolean$1.match(allowColor, {
 	onFalse: () => "plain"
 });
 const codePointOf = (char) => Option$1.getOrElse(Option$1.fromNullishOr(char.codePointAt(0)), () => 0);
-const charWidth = (char) => Match.value(char).pipe(Match.when((candidate) => KNOWN_EMOJI[candidate] === true, () => 2), Match.when((candidate) => codePointOf(candidate) > 65535, () => 2), Match.orElse(() => 1));
+const charWidth = (char) => Match$1.value(char).pipe(Match$1.when((candidate) => KNOWN_EMOJI[candidate] === true, () => 2), Match$1.when((candidate) => codePointOf(candidate) > 65535, () => 2), Match$1.orElse(() => 1));
 const stringWidth = (text) => Arr.reduce(Array.from(text), 0, (width, char) => width + charWidth(char));
 const spanWidth = (span) => span.leftPad + span.rightPad + stringWidth(span.text) * span.repeat;
 const lineWidth = (line) => Arr.reduce(line, 0, (width, span) => width + spanWidth(span));
@@ -2210,13 +2266,13 @@ const paddingWidth = (style) => Boolean$1.match(isFirstColumn(style), {
 	onTrue: () => 1,
 	onFalse: () => 2
 });
-const padsOf = (style, contentWidth, netWidth) => Match.value(style).pipe(Match.when("file", () => ({
+const padsOf = (style, contentWidth, netWidth) => Match$1.value(style).pipe(Match$1.when("file", () => ({
 	leftPad: 0,
 	rightPad: max(netWidth + 1 - contentWidth, 0)
-})), Match.when("first", () => ({
+})), Match$1.when("first", () => ({
 	leftPad: max(netWidth - contentWidth, 0),
 	rightPad: 1
-})), Match.orElse(() => ({
+})), Match$1.orElse(() => ({
 	leftPad: max(netWidth - contentWidth, 0) + 1,
 	rightPad: 1
 })));
@@ -2350,7 +2406,7 @@ const statusReasonTail = (mutant) => Option$1.match(Option$1.fromUndefinedOr(mut
 	onNone: () => [],
 	onSome: (statusReason) => [[plain("Error message: "), plain(statusReason)]]
 });
-const statusTail = (mutant, render) => Match.value(mutant.status).pipe(Match.when("Survived", () => survivorTail(mutant, render)), Match.when("Killed", () => killerTail(mutant)), Match.whenOr("RuntimeError", "CompileError", () => statusReasonTail(mutant)), Match.orElse(() => []));
+const statusTail = (mutant, render) => Match$1.value(mutant.status).pipe(Match$1.when("Survived", () => survivorTail(mutant, render)), Match$1.when("Killed", () => killerTail(mutant)), Match$1.whenOr("RuntimeError", "CompileError", () => statusReasonTail(mutant)), Match$1.orElse(() => []));
 const completedTests = (entry) => Option$1.getOrElse(Option$1.fromUndefinedOr(entry.mutant.testsCompleted), () => 0);
 const chunkListFor = (entries, channel, render) => entries.filter((entry) => CHANNEL_BY_STATUS[entry.mutant.status] === channel).flatMap((entry) => mutantBlock(entry, render));
 const mutantBlock = (entry, render) => [
@@ -2399,7 +2455,7 @@ const mutantReportSection = (report, metrics, render) => Boolean$1.match(render.
 	},
 	onFalse: () => EMPTY_SECTIONS
 });
-const hasFullScore = (metrics) => Match.valueTags(metrics.mutationScore, {
+const hasFullScore = (metrics) => Match$1.valueTags(metrics.mutationScore, {
 	Scored: ({ percentage }) => percentage === 100,
 	Unscored: () => false
 });
@@ -2411,13 +2467,13 @@ const drawsScoreTable = (metrics, render) => Boolean$1.match(render.reportScoreT
 	onTrue: () => partialScoresVisible(metrics, render),
 	onFalse: () => false
 });
-const mutationScoreOf = (scoreType, metrics) => Match.value(scoreType).pipe(Match.when("total", () => metrics.mutationScore), Match.when("covered", () => metrics.mutationScoreBasedOnCoveredCode), Match.exhaustive);
-const scoreText = (scoreType, row) => Match.valueTags(mutationScoreOf(scoreType, row.metrics), {
+const mutationScoreOf = (scoreType, metrics) => Match$1.value(scoreType).pipe(Match$1.when("total", () => metrics.mutationScore), Match$1.when("covered", () => metrics.mutationScoreBasedOnCoveredCode), Match$1.exhaustive);
+const scoreText = (scoreType, row) => Match$1.valueTags(mutationScoreOf(scoreType, row.metrics), {
 	Scored: ({ percentage }) => percentage.toFixed(2),
 	Unscored: () => "n/a"
 });
-const thresholdTone = (thresholds, score) => Match.valueTags(score, {
-	Scored: ({ percentage }) => Match.value(percentage).pipe(Match.when((value) => value >= thresholds.high, () => "positive"), Match.when((value) => value >= thresholds.low, () => "warning"), Match.orElse(() => "negative")),
+const thresholdTone = (thresholds, score) => Match$1.valueTags(score, {
+	Scored: ({ percentage }) => Match$1.value(percentage).pipe(Match$1.when((value) => value >= thresholds.high, () => "positive"), Match$1.when((value) => value >= thresholds.low, () => "warning"), Match$1.orElse(() => "negative")),
 	Unscored: () => "muted"
 });
 const scoreTone = (thresholds, scoreType, allowColor) => Boolean$1.match(allowColor, {
@@ -2590,10 +2646,10 @@ const failAsClearText = (cause) => Reporter_exports.ReporterFailed.make({
 	event: "mutationTestReportReady",
 	cause: Option$1.getOrElse(Option$1.map(ErrorText_exports.errorTextOf(cause), (rendered) => rendered.text), () => "")
 });
-const terminalReportOf = Filter.make((event) => Match.value(event).pipe(Match.tag("mutationTestReportReady", (ready) => Result.succeed({
+const terminalReportOf = Filter.make((event) => Match$1.value(event).pipe(Match$1.tag("mutationTestReportReady", (ready) => Result.succeed({
 	report: ready.report,
 	metrics: ready.metrics
-})), Match.orElse(() => Result.fail("not-terminal"))));
+})), Match$1.orElse(() => Result.fail("not-terminal"))));
 const renderOptionsOf = (options) => ({
 	allowColor: options.clearTextReporter.allowColor,
 	allowEmojis: options.clearTextReporter.allowEmojis,
@@ -2696,7 +2752,7 @@ const failAsJsonReporter = (cause) => Reporter_exports.ReporterFailed.make({
 	event: "mutationTestReportReady",
 	cause: Option$1.getOrElse(Option$1.map(ErrorText_exports.errorTextOf(cause), (rendered) => rendered.text), () => "")
 });
-const reportOf$1 = Filter.make((event) => Match.value(event).pipe(Match.tag("mutationTestReportReady", (ready) => Result.succeed(ready.report)), Match.orElse(() => Result.fail("not-ready"))));
+const reportOf$1 = Filter.make((event) => Match$1.value(event).pipe(Match$1.tag("mutationTestReportReady", (ready) => Result.succeed(ready.report)), Match$1.orElse(() => Result.fail("not-ready"))));
 const readJsonReport = (input) => Effect$1.map(Stream.fromAsyncIterable(input.events, failAsJsonReporter).pipe(Stream.filterMap(reportOf$1), Stream.run(Sink.last())), (last) => ({
 	_tag: "JsonReportCommand",
 	reported: Option$1.getOrUndefined(last),
@@ -2871,7 +2927,7 @@ const planReadyState = (state, planReady, now) => {
 		}
 	};
 };
-const advance = (state, event, now) => Match.value(event).pipe(Match.tag("dryRunCompleted", (dryRun) => ({
+const advance = (state, event, now) => Match$1.value(event).pipe(Match$1.tag("dryRunCompleted", (dryRun) => ({
 	kind: "skip",
 	state: {
 		...state,
@@ -2881,10 +2937,10 @@ const advance = (state, event, now) => Match.value(event).pipe(Match.tag("dryRun
 			capabilities: { reloadEnvironment: dryRun.capabilities.reloadEnvironment }
 		}
 	}
-})), Match.tag("mutationTestingPlanReady", (planReady) => ({
+})), Match$1.tag("mutationTestingPlanReady", (planReady) => ({
 	kind: "skip",
 	state: planReadyState(state, planReady, now)
-})), Match.tag("mutantTested", (tested) => Option$1.match(Record$1.get(state.tally.ticksByMutantId, tested.id), {
+})), Match$1.tag("mutantTested", (tested) => Option$1.match(Record$1.get(state.tally.ticksByMutantId, tested.id), {
 	onNone: () => ({
 		kind: "skip",
 		state
@@ -2896,10 +2952,10 @@ const advance = (state, event, now) => Match.value(event).pipe(Match.tag("dryRun
 			bar: Option$1.getOrNull(Option$1.map(Option$1.fromNullishOr(state.bar), (bar) => tickProgressBar(bar, ticks)))
 		}
 	})
-})), Match.tag("mutationTestReportReady", () => ({
+})), Match$1.tag("mutationTestReportReady", () => ({
 	kind: "skip",
 	state
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const progressStep = (state, event, now) => Option$1.match(Option$1.fromNullishOr(event), {
 	onNone: () => ({
 		kind: "finalize",
@@ -2912,10 +2968,10 @@ const secondsBetween = (now, startedAt) => floor$1((now - startedAt) / 1e3);
 const formatTime = (timeInSeconds) => {
 	const hours = floor$1(timeInSeconds / 3600);
 	const minutes = floor$1(timeInSeconds % 3600 / 60);
-	return Match.value(hours > 0).pipe(Match.when(true, () => `~${hours}h ${minutes}m`), Match.when(false, () => Match.value(minutes > 0).pipe(Match.when(true, () => `~${minutes}m`), Match.when(false, () => "<1m"), Match.exhaustive)), Match.exhaustive);
+	return Match$1.value(hours > 0).pipe(Match$1.when(true, () => `~${hours}h ${minutes}m`), Match$1.when(false, () => Match$1.value(minutes > 0).pipe(Match$1.when(true, () => `~${minutes}m`), Match$1.when(false, () => "<1m"), Match$1.exhaustive)), Match$1.exhaustive);
 };
 const remainingSeconds = (tally, now) => floor$1(secondsBetween(now, tally.startedAt) / tally.ticks * (tally.total - tally.ticks));
-const positiveTimeLabel = (remaining) => Match.value(remaining > 0).pipe(Match.when(true, () => formatTime(remaining)), Match.when(false, () => "n/a"), Match.exhaustive);
+const positiveTimeLabel = (remaining) => Match$1.value(remaining > 0).pipe(Match$1.when(true, () => formatTime(remaining)), Match$1.when(false, () => "n/a"), Match$1.exhaustive);
 const remainingLabel = (tally, now) => {
 	const remaining = remainingSeconds(tally, now);
 	return Boolean$1.match(Number.isFinite(remaining), {
@@ -2934,7 +2990,7 @@ const progressData = (tally, now) => ({
 	etc: remainingLabel(tally, now)
 });
 const formatBar = (bar, data) => {
-	const ratio = Match.value(bar.total === 0).pipe(Match.when(true, () => 0), Match.when(false, () => min$1(bar.curr / bar.total, 1)), Match.exhaustive);
+	const ratio = Match$1.value(bar.total === 0).pipe(Match$1.when(true, () => 0), Match$1.when(false, () => min$1(bar.curr / bar.total, 1)), Match$1.exhaustive);
 	const filled = floor$1(ratio * bar.width);
 	const filledBar = bar.complete.repeat(filled) + bar.incomplete.repeat(bar.width - filled);
 	const percent = `${floor$1(ratio * 100).toString().padStart(3, " ")}%`;
@@ -2947,7 +3003,7 @@ const renderTick = (tick) => `\r${formatBar(tick.bar, progressData(tick.tally, t
 })}`;
 const renderDecisionOf = (command) => {
 	const step = progressStep(command.state, command.event, command.now);
-	return Match.value(step.kind).pipe(Match.when("finalize", () => Option$1.match(Option$1.fromNullishOr(step.state.bar), {
+	return Match$1.value(step.kind).pipe(Match$1.when("finalize", () => Option$1.match(Option$1.fromNullishOr(step.state.bar), {
 		onNone: () => ProgressChunkSuppressed.make({ state: step.state }),
 		onSome: (bar) => Boolean$1.match(isComplete(bar), {
 			onTrue: () => ProgressChunkSuppressed.make({ state: step.state }),
@@ -2956,7 +3012,7 @@ const renderDecisionOf = (command) => {
 				state: step.state
 			})
 		})
-	})), Match.when("skip", () => ProgressChunkSuppressed.make({ state: step.state })), Match.when("tick", () => Option$1.match(Option$1.fromNullishOr(step.state.bar), {
+	})), Match$1.when("skip", () => ProgressChunkSuppressed.make({ state: step.state })), Match$1.when("tick", () => Option$1.match(Option$1.fromNullishOr(step.state.bar), {
 		onNone: () => ProgressChunkSuppressed.make({ state: step.state }),
 		onSome: (bar) => ProgressBarTick.make({
 			chunk: renderTick({
@@ -2966,7 +3022,7 @@ const renderDecisionOf = (command) => {
 			}),
 			state: step.state
 		})
-	})), Match.exhaustive);
+	})), Match$1.exhaustive);
 };
 const renderProgressReport = Workflow.make({
 	command: ProgressReportCommand,
@@ -3081,7 +3137,7 @@ var IdGenerator = class IdGenerator extends Context.Service()("@systemfsoftware/
 //#region src/run/RunEnvironment.service.ts
 var RunEnvironment = class RunEnvironment extends Context.Service()("@systemfsoftware/stryker-js/run/RunEnvironment.service/RunEnvironment") {
 	static stage = dual((args) => Predicate$1.isObject(args[0]) && !Queue.isQueue(args[0]), (env, events) => {
-		const eventsLayer = Match.value(events).pipe(Match.when(void 0, () => Layer.effect(RunEvents, Queue.bounded(RunEvent.QUEUE_BOUND))), Match.orElse((queue) => Layer.succeed(RunEvents, queue)));
+		const eventsLayer = Match$1.value(events).pipe(Match$1.when(void 0, () => Layer.effect(RunEvents, Queue.bounded(RunEvent.QUEUE_BOUND))), Match$1.orElse((queue) => Layer.succeed(RunEvents, queue)));
 		const stageLayer = Layer.mergeAll(Layer.succeed(RunEnvironment, env), eventsLayer, IdGenerator.layer, ProjectFiles.layer, Layer.effect(Scope.Scope, Effect$1.gen(function* () {
 			const stageScope = yield* Scope.make();
 			yield* Effect$1.addFinalizer(() => Scope.close(stageScope, Exit.void));
@@ -3196,9 +3252,9 @@ var OptionsUndecodable = class extends S.TaggedClass()("OptionsUndecodable", {
 }) {
 	[ValidateOptionsDecisionTypeId] = ValidateOptionsDecisionTypeId;
 };
-const ignoreStaticErrors = (options) => Match.value(Boolean$1.and(options.ignoreStatic, options.coverageAnalysis !== "perTest")).pipe(Match.when(true, () => [`Config option "ignoreStatic" is not supported with coverage analysis "${options.coverageAnalysis}". Either turn off "ignoreStatic", or configure "coverageAnalysis" to be "perTest".`]), Match.orElse(() => []));
-const startLineErrors = (index, mutationRange, start) => Match.value(start < 1).pipe(Match.when(true, () => [`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid, line ${start} does not exist (lines start at 1).`]), Match.orElse(() => []));
-const lineOrderErrors = (index, mutationRange, start, end) => Match.value(start > end).pipe(Match.when(true, () => [`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid. The "from" line number (${start}) should be less then the "to" line number (${end}).`]), Match.orElse(() => []));
+const ignoreStaticErrors = (options) => Match$1.value(Boolean$1.and(options.ignoreStatic, options.coverageAnalysis !== "perTest")).pipe(Match$1.when(true, () => [`Config option "ignoreStatic" is not supported with coverage analysis "${options.coverageAnalysis}". Either turn off "ignoreStatic", or configure "coverageAnalysis" to be "perTest".`]), Match$1.orElse(() => []));
+const startLineErrors = (index, mutationRange, start) => Match$1.value(start < 1).pipe(Match$1.when(true, () => [`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid, line ${start} does not exist (lines start at 1).`]), Match$1.orElse(() => []));
+const lineOrderErrors = (index, mutationRange, start, end) => Match$1.value(start > end).pipe(Match$1.when(true, () => [`Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid. The "from" line number (${start}) should be less then the "to" line number (${end}).`]), Match$1.orElse(() => []));
 const columnSuffixOf = (column) => Option$1.match(Option$1.fromUndefinedOr(column), {
 	onNone: () => "",
 	onSome: (present) => `:${present}`
@@ -3216,7 +3272,7 @@ const mutationRangeErrors = (mutateString, index) => Option$1.match(decodeMutati
 	onSome: (specifier) => requireUnmagicalMutationRange(mutateString, index, specifier)
 });
 const IGNORED_NODE_ARGS_WARNING = "Using \"testRunnerNodeArgs\" together with the \"command\" test runner is not supported, these arguments will be ignored. You can add your custom arguments by setting the \"commandRunner.command\" option.";
-const isCommandRunnerName = (name) => Match.value(name).pipe(Match.when(Match.string, (value) => value.toLowerCase() === "command"), Match.orElse(() => false));
+const isCommandRunnerName = (name) => Match$1.value(name).pipe(Match$1.when(Match$1.string, (value) => value.toLowerCase() === "command"), Match$1.orElse(() => false));
 const commandRunnerWarningsOf = (options) => Boolean$1.match(Boolean$1.and(isCommandRunnerName(options.testRunner), options.testRunnerNodeArgs.length > 0), {
 	onTrue: () => [IGNORED_NODE_ARGS_WARNING],
 	onFalse: () => []
@@ -3227,12 +3283,12 @@ const OPTIONS_ADDED_BY_STRYKER = [
 	"configFile",
 	"$schema"
 ];
-const schemaPropertyNames = (schema) => Match.value(schema["properties"]).pipe(Match.when(isNonNullObject, (properties) => Object.keys(properties)), Match.orElse(() => []));
+const schemaPropertyNames = (schema) => Match$1.value(schema["properties"]).pipe(Match$1.when(isNonNullObject, (properties) => Object.keys(properties)), Match$1.orElse(() => []));
 const excessOptionNames = (options, schema) => {
 	const schemaKeys = schemaPropertyNames(schema);
 	return Object.keys(options).filter((key) => key.endsWith("_comment") === false).filter((key) => OPTIONS_ADDED_BY_STRYKER.includes(key) === false).filter((key) => schemaKeys.includes(key) === false);
 };
-const warningRequested = (warning, warnings) => Match.value(warnings).pipe(Match.when(S.is(S.Boolean), (global) => global), Match.orElse((configured) => configured[warning] === true));
+const warningRequested = (warning, warnings) => Match$1.value(warnings).pipe(Match$1.when(S.is(S.Boolean), (global) => global), Match$1.orElse((configured) => configured[warning] === true));
 const pluginsJson = (options) => Result.getOrElse(S.encodeResult(S.String.pipe(S.Array, S.fromJsonString))([...options.plugins]), () => "[]");
 const POSSIBLE_CAUSES_OF = (loadedPlugins) => `Possible causes:
      * Is it a typo on your end?
@@ -3243,7 +3299,7 @@ const POSSIBLE_CAUSES_OF = (loadedPlugins) => `Possible causes:
 const unknownOptionWarnings = (options, schema) => {
 	return excessOptionNames(options, schema).map((excess) => `Unknown stryker config option "${excess}".`).concat(POSSIBLE_CAUSES_OF(pluginsJson(options)));
 };
-const excessOptionWarningsOf = (options, schema) => Match.value(warningRequested("unknownOptions", options.warnings)).pipe(Match.when(true, () => unknownOptionWarnings(options, schema)), Match.orElse(() => []));
+const excessOptionWarningsOf = (options, schema) => Match$1.value(warningRequested("unknownOptions", options.warnings)).pipe(Match$1.when(true, () => unknownOptionWarnings(options, schema)), Match$1.orElse(() => []));
 const NON_JSON_PRIMITIVE_TYPES = {
 	bigint: true,
 	function: true,
@@ -3258,7 +3314,7 @@ const describedChild = (scope) => (child) => Option$1.match(Option$1.fromUndefin
 	onSome: (descriptions) => descriptions.map(scopedUnserializable(scope))
 });
 const describedEntries = (entries) => entries.flatMap(([scope, child]) => describedChild(scope)(child));
-const classNameOf = (value) => Match.value(value.constructor).pipe(Match.when(Match.defined, (constructor) => constructor.name), Match.orElse(() => "Object"));
+const classNameOf = (value) => Match$1.value(value.constructor).pipe(Match$1.when(Match$1.defined, (constructor) => constructor.name), Match$1.orElse(() => "Object"));
 const describeUnserializableInstance = (value) => [{
 	path: [],
 	reason: `Value is an instance of "${classNameOf(value)}", this detail will get lost in translation during serialization`
@@ -3266,7 +3322,7 @@ const describeUnserializableInstance = (value) => [{
 const isArrayValue = (value) => Array.isArray(value);
 const isPlainObjectValue = (value) => Boolean$1.and(Array.isArray(value) === false, value.constructor === Object);
 const describedIndexedChildren = (arrayed) => describedEntries(arrayed.map((child, index) => [index.toString(), child]));
-const describeUnserializableObject = (value) => Match.value(value).pipe(Match.when(isArrayValue, describedIndexedChildren), Match.orElse((recorded) => Option$1.match(Option$1.liftPredicate(recorded, isPlainObjectValue), {
+const describeUnserializableObject = (value) => Match$1.value(value).pipe(Match$1.when(isArrayValue, describedIndexedChildren), Match$1.orElse((recorded) => Option$1.match(Option$1.liftPredicate(recorded, isPlainObjectValue), {
 	onNone: () => describeUnserializableInstance(recorded),
 	onSome: (plain) => describedEntries(Object.entries(plain))
 })));
@@ -3305,7 +3361,7 @@ const unserializableWarningsOf = (options) => Option$1.match(Option$1.fromUndefi
 	onNone: () => [],
 	onSome: (unserializables) => unserializables.map((unserializable) => `Config option "${unserializable.path.join(".")}" is not (fully) serializable. ${unserializable.reason}. Any test runner or checker worker processes might not receive this value as intended.`).concat("(disable \"warnings.unserializableOptions\" to ignore this warning)")
 });
-const unserializableOptionsWarningsOf = (options) => Match.value(warningRequested("unserializableOptions", options.warnings)).pipe(Match.when(true, () => unserializableWarningsOf(options)), Match.orElse(() => []));
+const unserializableOptionsWarningsOf = (options) => Match$1.value(warningRequested("unserializableOptions", options.warnings)).pipe(Match$1.when(true, () => unserializableWarningsOf(options)), Match$1.orElse(() => []));
 const markOptions = (options, schema) => [...excessOptionWarningsOf(options, schema), ...unserializableOptionsWarningsOf(options)];
 const validatedOf = (options, schema) => {
 	const customErrors = customValidationErrors(options);
@@ -3506,7 +3562,7 @@ const nodeWorkerLauncherLayer = (childEnv) => Layer.effect(WorkerLauncher, Effec
 	return { spawn: Effect$1.fn("stryker.worker.spawn")(function* (params) {
 		const workerDir = yield* fs.makeTempDirectoryScoped({ prefix: params.tempDirPrefix });
 		const workerId = yield* crypto.randomUUIDv4;
-		const socketPath = Match.value(globalThis.process.platform).pipe(Match.when("win32", () => `\\\\.\\pipe\\stryker-worker-${workerId}`), Match.orElse(() => path.join(workerDir, "worker.sock")));
+		const socketPath = Match$1.value(globalThis.process.platform).pipe(Match$1.when("win32", () => `\\\\.\\pipe\\stryker-worker-${workerId}`), Match$1.orElse(() => path.join(workerDir, "worker.sock")));
 		const optionsFile = path.join(workerDir, "options.json");
 		yield* fs.writeFileString(optionsFile, params.optionsJson);
 		yield* restrictToOwnerOrWarn(fs, optionsFile);
@@ -3528,17 +3584,17 @@ const nodeWorkerLauncherLayer = (childEnv) => Layer.effect(WorkerLauncher, Effec
 			exitCode
 		})), {
 			onFailure: (refused) => Effect$1.fail(refused),
-			onSuccess: (decision) => Match.value(decision).pipe(Match.tag("WorkerOutOfMemory", (outOfMemory) => Effect$1.fail(OutOfMemoryError.make({
+			onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("WorkerOutOfMemory", (outOfMemory) => Effect$1.fail(OutOfMemoryError.make({
 				pid: outOfMemory.pid,
 				exitCode: outOfMemory.exitCode
-			}))), Match.tag("WorkerCrashed", (crashed) => Effect$1.fail(ChildProcessCrashedError.make({
+			}))), Match$1.tag("WorkerCrashed", (crashed) => Effect$1.fail(ChildProcessCrashedError.make({
 				pid: crashed.pid,
 				exit: {
 					_tag: "Code",
 					code: crashed.exitCode
 				},
 				cause: "worker exited before it accepted the RPC connection"
-			}))), Match.exhaustive)
+			}))), Match$1.exhaustive)
 		})));
 		return make$3({
 			pid: Number(handle.pid),
@@ -3689,7 +3745,7 @@ const buildReportHtml = (report, scriptContent) => `<!DOCTYPE html>
   </body>
   </html>`;
 const BUNDLE_SPECIFIER = "mutation-testing-elements/dist/mutation-test-elements.js";
-const inlinedBundle = () => Match.value(typeof __STRYKER_HTML_REPORTER_CLIENT_BUNDLE__).pipe(Match.when("undefined", () => void 0), Match.orElse(() => __STRYKER_HTML_REPORTER_CLIENT_BUNDLE__));
+const inlinedBundle = () => Match$1.value(typeof __STRYKER_HTML_REPORTER_CLIENT_BUNDLE__).pipe(Match$1.when("undefined", () => void 0), Match$1.orElse(() => __STRYKER_HTML_REPORTER_CLIENT_BUNDLE__));
 const readBundleFromDisk = Effect$1.fn("html_report.read_bundle_from_disk")(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const bundlePath = yield* (yield* Path.Path).fromFileUrl(new URL(import.meta.resolve(BUNDLE_SPECIFIER)));
@@ -3780,11 +3836,11 @@ const percentageDetails = (text, availableParallelism) => Option$1.match(percent
 		announcement: Option$1.none()
 	})
 });
-const detailsOf = (concurrency, availableParallelism) => Match.value(concurrency).pipe(Match.when(Predicate$1.isString, (text) => percentageDetails(text, availableParallelism)), Match.when(Predicate$1.isNumber, (total) => ({
+const detailsOf = (concurrency, availableParallelism) => Match$1.value(concurrency).pipe(Match$1.when(Predicate$1.isString, (text) => percentageDetails(text, availableParallelism)), Match$1.when(Predicate$1.isNumber, (total) => ({
 	total,
 	isPercentage: false,
 	announcement: Option$1.none()
-})), Match.orElse(() => ({
+})), Match$1.orElse(() => ({
 	total: defaultedTotal(availableParallelism),
 	isPercentage: false,
 	announcement: Option$1.none()
@@ -3845,7 +3901,7 @@ const concurrencyCell = Sandwich.named("stryker.concurrency")(readConcurrency).d
 const CompileGlobTypeId = Symbol.for("@systemfsoftware/stryker-js/CompileGlobDecision");
 const escapeRegex = (value) => value.replace(/[\\^$.|()+]/g, "\\$&");
 const orEmpty = (value) => Option$1.getOrElse(Option$1.fromUndefinedOr(value), () => "");
-const globSegmentToRegex = (segment) => Match.value(segment.length === 0).pipe(Match.withReturnType(), Match.when(true, () => ""), Match.orElse(() => Match.value(segment.charCodeAt(0) - 42).pipe(Match.withReturnType(), Match.when(0, () => {
+const globSegmentToRegex = (segment) => Match$1.value(segment.length === 0).pipe(Match$1.withReturnType(), Match$1.when(true, () => ""), Match$1.orElse(() => Match$1.value(segment.charCodeAt(0) - 42).pipe(Match$1.withReturnType(), Match$1.when(0, () => {
 	const rest = segment.slice(1);
 	return Boolean.match(rest.startsWith("*"), {
 		onTrue: () => {
@@ -3857,7 +3913,7 @@ const globSegmentToRegex = (segment) => Match.value(segment.length === 0).pipe(M
 		},
 		onFalse: () => `[^/]*${globSegmentToRegex(rest)}`
 	});
-}), Match.when(21, () => `[^/]${globSegmentToRegex(segment.slice(1))}`), Match.when(81, () => {
+}), Match$1.when(21, () => `[^/]${globSegmentToRegex(segment.slice(1))}`), Match$1.when(81, () => {
 	const close = segment.indexOf("}");
 	return Boolean.match(close < 0, {
 		onTrue: () => `${escapeRegex("{")}${globSegmentToRegex(segment.slice(1))}`,
@@ -3865,13 +3921,13 @@ const globSegmentToRegex = (segment) => Match.value(segment.length === 0).pipe(M
 			return `(?:${segment.slice(1, close).split(",").map(globSegmentToRegex).join("|")})${globSegmentToRegex(segment.slice(close + 1))}`;
 		}
 	});
-}), Match.when(49, () => {
+}), Match$1.when(49, () => {
 	const close = segment.indexOf("]", 1);
 	return Boolean.match(close < 0, {
 		onTrue: () => `${escapeRegex("[")}${globSegmentToRegex(segment.slice(1))}`,
 		onFalse: () => `${segment.slice(0, close + 1)}${globSegmentToRegex(segment.slice(close + 1))}`
 	});
-}), Match.orElse(() => `${escapeRegex(orEmpty(segment[0]))}${globSegmentToRegex(segment.slice(1))}`))));
+}), Match$1.orElse(() => `${escapeRegex(orEmpty(segment[0]))}${globSegmentToRegex(segment.slice(1))}`))));
 var GlobMatcher = class extends S.TaggedClass()("GlobMatcher", {
 	source: S.String,
 	flags: S.String
@@ -3895,7 +3951,7 @@ const matcherOf = (pattern, caseInsensitive) => GlobMatcher.make({
 		onFalse: () => ""
 	})
 });
-const decisionOf$1 = (command) => Match.value(command.pattern).pipe(Match.withReturnType(), Match.when(Match.string, (value) => matcherOf(value, command.caseInsensitive)), Match.orElse(() => GlobUnmatchable.make({ pattern: command.pattern })));
+const decisionOf$1 = (command) => Match$1.value(command.pattern).pipe(Match$1.withReturnType(), Match$1.when(Match$1.string, (value) => matcherOf(value, command.caseInsensitive)), Match$1.orElse(() => GlobUnmatchable.make({ pattern: command.pattern })));
 const compileGlob = Workflow.make({
 	command: CompileGlobCommand,
 	decision: CompileGlobDecision,
@@ -3923,7 +3979,7 @@ const compileIgnoreRule = (pattern) => {
 		onTrue: () => pattern.slice(1),
 		onFalse: () => pattern
 	});
-	return Match.value(expressionOf$1(body, true)).pipe(Match.withReturnType(), Match.tag("GlobMatcher", (matcher) => ruleOf(negate, new RegExp(matcher.source, matcher.flags))), Match.tag("GlobUnmatchable", () => ruleOf(negate, UNMATCHABLE)), Match.exhaustive);
+	return Match$1.value(expressionOf$1(body, true)).pipe(Match$1.withReturnType(), Match$1.tag("GlobMatcher", (matcher) => ruleOf(negate, new RegExp(matcher.source, matcher.flags))), Match$1.tag("GlobUnmatchable", () => ruleOf(negate, UNMATCHABLE)), Match$1.exhaustive);
 };
 const matchesDirectoryPartially = (entryPath, rule) => [`/${entryPath}`, entryPath].some((candidate) => rule.prefix.test(candidate));
 const matchesFileCandidate = (entryName, entryPath, rule) => [
@@ -3999,7 +4055,7 @@ const decide$12 = (command) => Option$1.match(Option$1.fromUndefinedOr(command.r
 		actual: void 0,
 		expected: command.expectedVersion
 	}),
-	onSome: (report) => Match.value(report.incrementalVersion === command.expectedVersion).pipe(Match.when(true, () => IncrementalReportKeep.make({ report })), Match.orElse(() => IncrementalReportDiscard.make({
+	onSome: (report) => Match$1.value(report.incrementalVersion === command.expectedVersion).pipe(Match$1.when(true, () => IncrementalReportKeep.make({ report })), Match$1.orElse(() => IncrementalReportDiscard.make({
 		actual: report.incrementalVersion,
 		expected: command.expectedVersion
 	})))
@@ -4065,10 +4121,10 @@ const consumeCharClass = (pattern, index) => {
 		})
 	});
 };
-const consumeGlobChar = (pattern, index) => Match.value(pattern[index]).pipe(Match.withReturnType(), Match.when("*", () => consumeStar(pattern, index)), Match.when("?", () => ({
+const consumeGlobChar = (pattern, index) => Match$1.value(pattern[index]).pipe(Match$1.withReturnType(), Match$1.when("*", () => consumeStar(pattern, index)), Match$1.when("?", () => ({
 	consumed: 1,
 	output: "[^/]"
-})), Match.when("{", () => consumeBrace(pattern, index)), Match.when("[", () => consumeCharClass(pattern, index)), Match.orElse(() => ({
+})), Match$1.when("{", () => consumeBrace(pattern, index)), Match$1.when("[", () => consumeCharClass(pattern, index)), Match$1.orElse(() => ({
 	consumed: 1,
 	output: escapeRegExp(Option$1.getOrElse(Option$1.fromUndefinedOr(pattern[index]), () => ""))
 })));
@@ -4098,7 +4154,7 @@ const resolveAgainstBase = (basePath, pattern) => {
 		})}`
 	});
 };
-const globPatternOf = (pattern) => Match.value(pattern).pipe(Match.withReturnType(), Match.when(Match.string, (value) => normalizeFileName(value)), Match.when(true, () => DEFAULT_GLOB$1), Match.orElse(() => void 0));
+const globPatternOf = (pattern) => Match$1.value(pattern).pipe(Match$1.withReturnType(), Match$1.when(Match$1.string, (value) => normalizeFileName(value)), Match$1.when(true, () => DEFAULT_GLOB$1), Match$1.orElse(() => void 0));
 const hasHiddenSegment$1 = (fileName, base) => {
 	return Boolean.match(fileName.startsWith(base), {
 		onTrue: () => fileName.slice(base.length),
@@ -4112,7 +4168,7 @@ const isExcludedHiddenFile = (normalizedFile, base, allowHiddenFiles, patternHas
 		onFalse: () => false
 	})
 });
-const createPureMatcher = (pattern, allowHiddenFiles, basePath) => Match.value(globPatternOf(pattern)).pipe(Match.withReturnType(), Match.when(void 0, () => () => false), Match.orElse((relative) => {
+const createPureMatcher = (pattern, allowHiddenFiles, basePath) => Match$1.value(globPatternOf(pattern)).pipe(Match$1.withReturnType(), Match$1.when(void 0, () => () => false), Match$1.orElse((relative) => {
 	const regex = globToRegExp(resolveAgainstBase(basePath, relative));
 	const patternHasDot = relative.includes(".");
 	const base = `${trimTrailingSlashes(normalizeFileName(basePath))}/`;
@@ -4362,7 +4418,7 @@ const parseAndDecodeIncrementalReport = Schema.decodeUnknownResult(Schema.fromJs
 const reportOf = (contents) => Option$1.getOrUndefined(Option$1.flatMap(Option$1.fromUndefinedOr(contents), (text) => Result.getSuccess(parseAndDecodeIncrementalReport(text))));
 const incrementalContentsOf = (fs, options) => Boolean.match(options.incremental, {
 	onFalse: () => Effect$1.succeedNone,
-	onTrue: () => fs.readFileString(options.incrementalFile).pipe(Effect$1.asSome, Effect$1.tapError((error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect$1.logInfo(`No incremental result file found at ${options.incrementalFile}, a full mutation testing run will be performed.`)), Match.orElse(() => Effect$1.void))), Effect$1.catchTag("PlatformError", (error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect$1.succeedNone), Match.orElse(() => Effect$1.fail(error)))))
+	onTrue: () => fs.readFileString(options.incrementalFile).pipe(Effect$1.asSome, Effect$1.tapError((error) => Match$1.value(error.reason).pipe(Match$1.tag("NotFound", () => Effect$1.logInfo(`No incremental result file found at ${options.incrementalFile}, a full mutation testing run will be performed.`)), Match$1.orElse(() => Effect$1.void))), Effect$1.catchTag("PlatformError", (error) => Match$1.value(error.reason).pipe(Match$1.tag("NotFound", () => Effect$1.succeedNone), Match$1.orElse(() => Effect$1.fail(error)))))
 });
 const testFileSelectionOf = (options) => ({
 	testFilePatterns: options.testFiles,
@@ -4523,28 +4579,28 @@ S.Struct({
 	mode: OutputMode,
 	signal: ModeSignal
 });
-const nextFramingState = (state, event) => Match.value(event).pipe(Match.tag("verdict", "error", "help", () => FramingState.make({
+const nextFramingState = (state, event) => Match$1.value(event).pipe(Match$1.tag("verdict", "error", "help", () => FramingState.make({
 	mode: state.mode,
 	signal: state.signal,
 	headerWritten: state.headerWritten,
 	terminalSeen: true,
 	completed: state.completed,
 	total: state.total
-})), Match.tag("plan", (e) => FramingState.make({
+})), Match$1.tag("plan", (e) => FramingState.make({
 	mode: state.mode,
 	signal: state.signal,
 	headerWritten: state.headerWritten,
 	terminalSeen: state.terminalSeen,
 	completed: state.completed,
 	total: e.total
-})), Match.tag("mutantTested", (e) => FramingState.make({
+})), Match$1.tag("mutantTested", (e) => FramingState.make({
 	mode: state.mode,
 	signal: state.signal,
 	headerWritten: state.headerWritten,
 	terminalSeen: state.terminalSeen,
 	completed: e.completed,
 	total: e.total
-})), Match.tag("stream", () => state), Match.tag("phase", () => state), Match.tag("tick", () => state), Match.tag("plugins", () => state), Match.tag("formats", () => state), Match.tag("skipped", () => state), Match.exhaustive);
+})), Match$1.tag("stream", () => state), Match$1.tag("phase", () => state), Match$1.tag("tick", () => state), Match$1.tag("plugins", () => state), Match$1.tag("formats", () => state), Match$1.tag("skipped", () => state), Match$1.exhaustive);
 const noteState = (state, event) => nextFramingState(state, event);
 const formatScore = (score) => Option$1.match(Option$1.fromNullishOr(score), {
 	onNone: () => "n/a",
@@ -4554,7 +4610,7 @@ const formatTotal = (total) => Option$1.match(Option$1.fromNullishOr(total), {
 	onNone: () => "?",
 	onSome: (val) => String(val)
 });
-const formatStderrEvent = (event) => Match.value(event).pipe(Match.tag("plan", (e) => `plan ${e.total} mutants`), Match.tag("phase", (e) => `phase ${e.phase}`), Match.tag("tick", (e) => `${e.completed}/${formatTotal(e.total)} elapsed ${e.elapsedMs}ms`), Match.tag("verdict", (e) => `score ${formatScore(e.score)} killed ${e.counts.killed} survived ${e.counts.survived}`), Match.tag("error", (e) => `error ${e.error}`), Match.tag("stream", () => null), Match.tag("mutantTested", () => null), Match.tag("help", () => null), Match.tag("plugins", () => null), Match.tag("formats", () => null), Match.tag("skipped", () => null), Match.exhaustive);
+const formatStderrEvent = (event) => Match$1.value(event).pipe(Match$1.tag("plan", (e) => `plan ${e.total} mutants`), Match$1.tag("phase", (e) => `phase ${e.phase}`), Match$1.tag("tick", (e) => `${e.completed}/${formatTotal(e.total)} elapsed ${e.elapsedMs}ms`), Match$1.tag("verdict", (e) => `score ${formatScore(e.score)} killed ${e.counts.killed} survived ${e.counts.survived}`), Match$1.tag("error", (e) => `error ${e.error}`), Match$1.tag("stream", () => null), Match$1.tag("mutantTested", () => null), Match$1.tag("help", () => null), Match$1.tag("plugins", () => null), Match$1.tag("formats", () => null), Match$1.tag("skipped", () => null), Match$1.exhaustive);
 const stderrLineFor = (state, event) => Boolean$1.match(Boolean$1.and(state.mode === "human", !state.terminalSeen), {
 	onTrue: () => formatStderrEvent(event),
 	onFalse: () => null
@@ -4564,14 +4620,14 @@ const decideFrame = (command) => {
 	const nextState = noteState(command.state, command.event);
 	const stderrLine = stderrLineFor(command.state, command.event);
 	const framed = shouldFrame(command.state);
-	return Match.value(framed).pipe(Match.when(true, () => Result.succeed(EventFramed.make({
+	return Match$1.value(framed).pipe(Match$1.when(true, () => Result.succeed(EventFramed.make({
 		state: nextState,
 		event: command.event,
 		stderrLine
-	}))), Match.when(false, () => Result.succeed(EventSuppressed.make({
+	}))), Match$1.when(false, () => Result.succeed(EventSuppressed.make({
 		state: nextState,
 		stderrLine
-	}))), Match.exhaustive);
+	}))), Match$1.exhaustive);
 };
 const frameRunEvent = Workflow.make({
 	command: FrameRunEventCommand,
@@ -4588,7 +4644,7 @@ const jsonArgumentText = (argument) => Result.getOrElse(Result.try({
 const inspectValue = (value) => Option$1.getOrElse(Option$1.liftPredicate(value, Predicate$1.isString), () => Formatter.format(value));
 const PLACEHOLDER = /(%[sdijfopO%])/g;
 const PLACEHOLDER_PART = /^%[sdijfopO%]$/;
-const placeholderText = (placeholder, argument) => Match.value(placeholder).pipe(Match.when(Match.is("%s"), () => String(argument)), Match.when(Match.is("%d", "%i", "%f"), () => Number(argument).toString()), Match.when(Match.is("%j"), () => jsonArgumentText(argument)), Match.when(Match.is("%o", "%O", "%p"), () => inspectValue(argument)), Match.orElse((unmatched) => unmatched));
+const placeholderText = (placeholder, argument) => Match$1.value(placeholder).pipe(Match$1.when(Match$1.is("%s"), () => String(argument)), Match$1.when(Match$1.is("%d", "%i", "%f"), () => Number(argument).toString()), Match$1.when(Match$1.is("%j"), () => jsonArgumentText(argument)), Match$1.when(Match$1.is("%o", "%O", "%p"), () => inspectValue(argument)), Match$1.orElse((unmatched) => unmatched));
 const appendLiteral = (progress, literal) => ({
 	args: progress.args,
 	cursor: progress.cursor,
@@ -4602,8 +4658,8 @@ const substitutePlaceholder = (progress, placeholder) => Boolean$1.match(progres
 	}),
 	onFalse: () => appendLiteral(progress, placeholder)
 });
-const consumePlaceholder = (progress, placeholder) => Match.value(placeholder).pipe(Match.when(Match.is("%%"), () => appendLiteral(progress, "%")), Match.orElse(() => substitutePlaceholder(progress, placeholder)));
-const formatStep = (progress, part) => Match.value(part).pipe(Match.when((candidate) => PLACEHOLDER_PART.test(candidate), (placeholder) => consumePlaceholder(progress, placeholder)), Match.orElse((literal) => appendLiteral(progress, literal)));
+const consumePlaceholder = (progress, placeholder) => Match$1.value(placeholder).pipe(Match$1.when(Match$1.is("%%"), () => appendLiteral(progress, "%")), Match$1.orElse(() => substitutePlaceholder(progress, placeholder)));
+const formatStep = (progress, part) => Match$1.value(part).pipe(Match$1.when((candidate) => PLACEHOLDER_PART.test(candidate), (placeholder) => consumePlaceholder(progress, placeholder)), Match$1.orElse((literal) => appendLiteral(progress, literal)));
 const formatTemplate = (template, args) => {
 	const progress = template.split(PLACEHOLDER).reduce(formatStep, {
 		args,
@@ -4719,15 +4775,15 @@ const UNKNOWN_FAILURE = "Unknown failure";
 const SIGNAL_REMEDIATION = "the run was interrupted by a signal; re-run it to continue";
 const PARSE_REMEDIATION = "re-run with --help to see the full usage";
 const DEFAULT_REMEDIATION = "see --reportFile or the verdict envelope on stdout";
-const exitCodeOf = (outcome) => Match.value(outcome).pipe(Match.tag("RunOk", () => 0), Match.tag("RunInterrupted", (error) => error.code), Match.tag("RunParseFailed", () => CONFIG_CODE), Match.tag("RunSurvivorsRejected", () => CONFIG_CODE), Match.tag("RunConfigFailed", () => CONFIG_CODE), Match.tag("RunFailed", (failed) => failed.code), Match.exhaustive);
+const exitCodeOf = (outcome) => Match$1.value(outcome).pipe(Match$1.tag("RunOk", () => 0), Match$1.tag("RunInterrupted", (error) => error.code), Match$1.tag("RunParseFailed", () => CONFIG_CODE), Match$1.tag("RunSurvivorsRejected", () => CONFIG_CODE), Match$1.tag("RunConfigFailed", () => CONFIG_CODE), Match$1.tag("RunFailed", (failed) => failed.code), Match$1.exhaustive);
 const nonEmptyText = Option$1.liftPredicate(S.is(S.NonEmptyString));
 const capturedOrUnknown = (captured) => Option$1.getOrElse(nonEmptyText(captured), () => UNKNOWN_FAILURE);
 const capturedThenRecorded = (captured, recorded) => Option$1.getOrElse(nonEmptyText(captured), () => Option$1.getOrElse(Option$1.fromNullishOr(recorded), () => UNKNOWN_FAILURE));
-const failureTextOf = (error, captured) => Match.value(error).pipe(Match.tag("RunParseFailed", (failed) => Option$1.getOrElse(Option$1.map(Option$1.fromNullishOr(failed.unrecognized), (value) => `Received unknown argument: '${value}'`), () => capturedOrUnknown(captured))), Match.tag("RunSurvivorsRejected", (failed) => Option$1.getOrElse(Option$1.fromNullishOr(failed.diagnostic), () => UNKNOWN_FAILURE)), Match.tag("RunInterrupted", () => capturedOrUnknown(captured)), Match.tag("RunConfigFailed", (failed) => capturedThenRecorded(captured, failed.detail)), Match.tag("RunFailed", (failed) => capturedThenRecorded(captured, failed.diagnostic)), Match.exhaustive);
-const remediationTextOf = (error) => Match.value(error).pipe(Match.tag("RunInterrupted", () => SIGNAL_REMEDIATION), Match.tag("RunParseFailed", () => PARSE_REMEDIATION), Match.tag("RunSurvivorsRejected", (failed) => Option$1.getOrElse(Option$1.fromNullishOr(failed.diagnostic), () => DEFAULT_REMEDIATION)), Match.tag("RunConfigFailed", (failed) => Option$1.match(Option$1.fromNullishOr(failed.detail), {
+const failureTextOf = (error, captured) => Match$1.value(error).pipe(Match$1.tag("RunParseFailed", (failed) => Option$1.getOrElse(Option$1.map(Option$1.fromNullishOr(failed.unrecognized), (value) => `Received unknown argument: '${value}'`), () => capturedOrUnknown(captured))), Match$1.tag("RunSurvivorsRejected", (failed) => Option$1.getOrElse(Option$1.fromNullishOr(failed.diagnostic), () => UNKNOWN_FAILURE)), Match$1.tag("RunInterrupted", () => capturedOrUnknown(captured)), Match$1.tag("RunConfigFailed", (failed) => capturedThenRecorded(captured, failed.detail)), Match$1.tag("RunFailed", (failed) => capturedThenRecorded(captured, failed.diagnostic)), Match$1.exhaustive);
+const remediationTextOf = (error) => Match$1.value(error).pipe(Match$1.tag("RunInterrupted", () => SIGNAL_REMEDIATION), Match$1.tag("RunParseFailed", () => PARSE_REMEDIATION), Match$1.tag("RunSurvivorsRejected", (failed) => Option$1.getOrElse(Option$1.fromNullishOr(failed.diagnostic), () => DEFAULT_REMEDIATION)), Match$1.tag("RunConfigFailed", (failed) => Option$1.match(Option$1.fromNullishOr(failed.detail), {
 	onSome: (detail) => `check the config file: ${detail}`,
 	onNone: () => "check the config file"
-})), Match.tag("RunFailed", () => DEFAULT_REMEDIATION), Match.exhaustive);
+})), Match$1.tag("RunFailed", () => DEFAULT_REMEDIATION), Match$1.exhaustive);
 const errorEnvelopeFromOutcome = (input) => ErrorEnvelope.make({
 	schemaVersion: StreamSchemaVersion.literal,
 	code: exitCodeOf(input.error),
@@ -4773,7 +4829,7 @@ const stateAfter = (decision, fallback) => Result.match(decision, {
 });
 const framedEventOf = (decision) => Option$1.match(decision, {
 	onNone: () => Result.fail(void 0),
-	onSome: (d) => Match.value(d).pipe(Match.tag("EventFramed", (framed) => Result.succeed(framed.event)), Match.tag("EventSuppressed", () => Result.fail(void 0)), Match.exhaustive)
+	onSome: (d) => Match$1.value(d).pipe(Match$1.tag("EventFramed", (framed) => Result.succeed(framed.event)), Match$1.tag("EventSuppressed", () => Result.fail(void 0)), Match$1.exhaustive)
 });
 const DEFAULT_PROGRESS_STREAM_FILE = "reports/mutation-stream.jsonl";
 var RunEventDrain = class RunEventDrain extends Context.Service()("@systemfsoftware/stryker-js/run-event-stream.service/RunEventDrain") {
@@ -4884,10 +4940,10 @@ const emitMachineModeOutput = Effect$1.fn("stryker.runEventStream.emitMachineMod
 	const { stream, mode, outcome, basePath, pathService } = params;
 	const captured = (yield* MachineConsole).read();
 	return yield* Result.match(outcome, {
-		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("RunOk", (ok) => Option$1.match(helpPayload(ok, captured), {
+		onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("RunOk", (ok) => Option$1.match(helpPayload(ok, captured), {
 			onSome: (help) => emitHelpEnvelope(stream, help),
 			onNone: () => emitNullScoreVerdictWhenOpen(stream, mode, basePath, pathService)
-		})), Match.tag("RunParseFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.tag("RunSurvivorsRejected", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.tag("RunConfigFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.tag("RunFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.exhaustive),
+		})), Match$1.tag("RunParseFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunSurvivorsRejected", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunConfigFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.tag("RunFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match$1.exhaustive),
 		onFailure: (failure) => offerFailureEnvelope(stream, failure, captured)
 	});
 });
@@ -5040,31 +5096,31 @@ var DryRunFailed = class extends S.TaggedClass()("DryRunFailed", {
 }) {
 	[DryRunDecisionTypeId] = DryRunDecisionTypeId;
 };
-const completeOutcomeOf = (command) => Match.value(command).pipe(Match.when({
+const completeOutcomeOf = (command) => Match$1.value(command).pipe(Match$1.when({
 	testCount: 0,
 	allowEmpty: false
-}, () => "noTests"), Match.when({ failedTestCount: (count) => count > 0 }, () => "failed"), Match.orElse(() => "passed"));
-const decideComplete = (command) => Match.value({
+}, () => "noTests"), Match$1.when({ failedTestCount: (count) => count > 0 }, () => "failed"), Match$1.orElse(() => "passed"));
+const decideComplete = (command) => Match$1.value({
 	outcome: completeOutcomeOf(command),
 	testCount: command.testCount,
 	failedTestCount: command.failedTestCount,
 	failedTests: command.failedTests
-}).pipe(Match.when({ outcome: "noTests" }, () => Result.fail(DryRunError.make({
+}).pipe(Match$1.when({ outcome: "noTests" }, () => Result.fail(DryRunError.make({
 	stage: "dryRunNoTests",
 	reason: "No tests were executed. Stryker will exit prematurely. Please check your configuration."
-}))), Match.when({ outcome: "failed" }, ({ testCount, failedTestCount, failedTests }) => Result.succeed(DryRunFailed.make({
+}))), Match$1.when({ outcome: "failed" }, ({ testCount, failedTestCount, failedTests }) => Result.succeed(DryRunFailed.make({
 	testCount,
 	failedTestCount,
 	failedTests
-}))), Match.when({ outcome: "passed" }, ({ testCount }) => Result.succeed(DryRunPassed.make({ testCount }))), Match.exhaustive);
-const reasonOrDefault = (reason, fallback) => Match.value(reason).pipe(Match.when(void 0, () => fallback), Match.orElse((present) => present));
-const decide$11 = (command) => Match.value(command.status).pipe(Match.when("Error", () => Result.fail(DryRunError.make({
+}))), Match$1.when({ outcome: "passed" }, ({ testCount }) => Result.succeed(DryRunPassed.make({ testCount }))), Match$1.exhaustive);
+const reasonOrDefault = (reason, fallback) => Match$1.value(reason).pipe(Match$1.when(void 0, () => fallback), Match$1.orElse((present) => present));
+const decide$11 = (command) => Match$1.value(command.status).pipe(Match$1.when("Error", () => Result.fail(DryRunError.make({
 	stage: "dryRun",
 	reason: reasonOrDefault(command.errorMessage, "Dry run error")
-}))), Match.when("Timeout", () => Result.fail(DryRunError.make({
+}))), Match$1.when("Timeout", () => Result.fail(DryRunError.make({
 	stage: "dryRun",
 	reason: reasonOrDefault(command.reason, "Initial test run timed out")
-}))), Match.when("Complete", () => decideComplete(command)), Match.exhaustive);
+}))), Match$1.when("Complete", () => decideComplete(command)), Match$1.exhaustive);
 const dryRun = Workflow.make({
 	command: DryRunCommand,
 	decision: S.Union([DryRunPassed, DryRunFailed]),
@@ -5101,14 +5157,14 @@ const failedTestSummariesOf = (tests) => tests.filter((test) => test.status ===
 	name: test.name,
 	failureMessage: test.failureMessage
 }));
-const decide$10 = (command) => Match.value(command.dryRunResult).pipe(Match.discriminator("status")("complete", (complete) => Result.succeed(DryRunObservedComplete.make({
+const decide$10 = (command) => Match$1.value(command.dryRunResult).pipe(Match$1.discriminator("status")("complete", (complete) => Result.succeed(DryRunObservedComplete.make({
 	testCount: complete.tests.length,
 	failedTestCount: complete.tests.filter((test) => test.status === "failed").length,
 	failedTests: failedTestSummariesOf(complete.tests)
-}))), Match.discriminator("status")("error", (failed) => Result.succeed(DryRunObservedFailed.make({ errorMessage: failed.errorMessage }))), Match.discriminator("status")("timeout", (timedOut) => Result.succeed(DryRunObservedTimedOut.make(Option$1.match(Option$1.fromNullishOr(timedOut.reason), {
+}))), Match$1.discriminator("status")("error", (failed) => Result.succeed(DryRunObservedFailed.make({ errorMessage: failed.errorMessage }))), Match$1.discriminator("status")("timeout", (timedOut) => Result.succeed(DryRunObservedTimedOut.make(Option$1.match(Option$1.fromNullishOr(timedOut.reason), {
 	onNone: () => ({}),
 	onSome: (reason) => ({ reason })
-})))), Match.exhaustive);
+})))), Match$1.exhaustive);
 const interpretDryRunObservation = Workflow.make({
 	command: DryRunObservation,
 	decision: S.Union([
@@ -5124,7 +5180,7 @@ const interpretDryRunObservation = Workflow.make({
 const TypeId$8 = Symbol.for("~systemfsoftware/stryker-js/Sandbox");
 const SandboxHandle = Handle.make()(TypeId$8);
 SandboxHandle.is;
-const sandboxFileNameOf = (fileMap, fileName) => Match.value(fileMap.get(fileName)).pipe(Match.when(Predicate$1.isString, (sandboxFileName) => Result.succeed(sandboxFileName)), Match.orElse(() => Result.fail(StrykerError.make({ message: `Cannot find sandbox file for ${fileName}` }))));
+const sandboxFileNameOf = (fileMap, fileName) => Match$1.value(fileMap.get(fileName)).pipe(Match$1.when(Predicate$1.isString, (sandboxFileName) => Result.succeed(sandboxFileName)), Match$1.orElse(() => Result.fail(StrykerError.make({ message: `Cannot find sandbox file for ${fileName}` }))));
 const withoutLeadingSeparator = (suffix) => Boolean$1.match(suffix.startsWith("/"), {
 	onTrue: () => suffix.slice(1),
 	onFalse: () => suffix
@@ -5208,7 +5264,7 @@ var InterpretDryRunResultCommand = class extends S.TaggedClass()("InterpretDryRu
 const failedTestsOf = (tests) => tests.filter((test) => test.status === "failed");
 const countedTestsOf = (tests) => tests.filter((test) => test.status !== "skipped").length;
 const firstFailedTestOf = (failed) => Option$1.fromUndefinedOr(failed.at(0));
-const decide$9 = (command) => Match.value(command.dryRunResult).pipe(Match.discriminator("status")("complete", (complete) => {
+const decide$9 = (command) => Match$1.value(command.dryRunResult).pipe(Match$1.discriminator("status")("complete", (complete) => {
 	const failed = failedTestsOf(complete.tests);
 	const nrOfTests = countedTestsOf(complete.tests);
 	return Option$1.match(firstFailedTestOf(failed), {
@@ -5219,10 +5275,10 @@ const decide$9 = (command) => Match.value(command.dryRunResult).pipe(Match.discr
 			nrOfTests
 		}))
 	});
-}), Match.discriminator("status")("error", (errored) => Result.succeed(MutantRunErrored.make({ errorMessage: errored.errorMessage }))), Match.discriminator("status")("timeout", (timedOut) => Option$1.match(Option$1.fromUndefinedOr(timedOut.reason), {
+}), Match$1.discriminator("status")("error", (errored) => Result.succeed(MutantRunErrored.make({ errorMessage: errored.errorMessage }))), Match$1.discriminator("status")("timeout", (timedOut) => Option$1.match(Option$1.fromUndefinedOr(timedOut.reason), {
 	onNone: () => Result.succeed(MutantRunTimedOut.make({})),
 	onSome: (reason) => Result.succeed(MutantRunTimedOut.make({ reason }))
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const interpretDryRunResult = Workflow.make({
 	command: InterpretDryRunResultCommand,
 	decision: S.Union([
@@ -5266,7 +5322,7 @@ const invalidatesRunnerPool = dual(2, (status, reason) => status === "timeout" &
 const maxRetries = 2;
 const exhaustedMessage = (cause) => `Test runner crashed. Tried ${maxRetries} times to restart it without any luck. ${Cause.pretty(cause)}`;
 const withRetry = (inner) => {
-	const attempt = (run, onExhausted) => run.pipe(Effect$1.tapError((error) => Match.value(error).pipe(Match.when(S.is(OutOfMemoryError), (outOfMemory) => Effect$1.logInfo(`Test runner process [${outOfMemory.pid}] ran out of memory. That usually means the tests leak memory. Stryker restarts the process and carries on, but the run is slower for it.`)), Match.orElse(() => Effect$1.void))), Effect$1.retry({ times: maxRetries }), Effect$1.catchCause((cause) => Effect$1.succeed(onExhausted(exhaustedMessage(cause)))));
+	const attempt = (run, onExhausted) => run.pipe(Effect$1.tapError((error) => Match$1.value(error).pipe(Match$1.when(S.is(OutOfMemoryError), (outOfMemory) => Effect$1.logInfo(`Test runner process [${outOfMemory.pid}] ran out of memory. That usually means the tests leak memory. Stryker restarts the process and carries on, but the run is slower for it.`)), Match$1.orElse(() => Effect$1.void))), Effect$1.retry({ times: maxRetries }), Effect$1.catchCause((cause) => Effect$1.succeed(onExhausted(exhaustedMessage(cause)))));
 	return make$1({
 		...inner,
 		dryRun: (options) => attempt(inner.dryRun(options), (errorMessage) => ({
@@ -5279,7 +5335,7 @@ const withRetry = (inner) => {
 		}))
 	});
 };
-const withMaxReuse = dual(2, (options, retire) => (inner) => Match.value(options.maxTestRunnerReuse).pipe(Match.when((restartAfter) => restartAfter <= 0, () => Effect$1.succeed(inner)), Match.orElse(Effect$1.fn("stryker.testRunner.withMaxReuse")(function* (restartAfter) {
+const withMaxReuse = dual(2, (options, retire) => (inner) => Match$1.value(options.maxTestRunnerReuse).pipe(Match$1.when((restartAfter) => restartAfter <= 0, () => Effect$1.succeed(inner)), Match$1.orElse(Effect$1.fn("stryker.testRunner.withMaxReuse")(function* (restartAfter) {
 	const runs = yield* Ref.make(0);
 	return make$1({
 		...inner,
@@ -5300,7 +5356,7 @@ const nextEnvironmentState = (requested) => Boolean$1.match(requested, {
 	onFalse: () => "loaded"
 });
 const reloadEnvironmentDecision = (requested, current, canReload) => canReload && stateNeedsReload(requested, current);
-const stateNeedsReload = (requested, current) => Match.value(requested).pipe(Match.when(true, () => current !== "pristine"), Match.orElse(() => current === "loaded-static-mutant"));
+const stateNeedsReload = (requested, current) => Match$1.value(requested).pipe(Match$1.when(true, () => current !== "pristine"), Match$1.orElse(() => current === "loaded-static-mutant"));
 const retireDecision = (current, canReload) => !canReload && current === "loaded-static-mutant";
 const reloadPlanOf = (requested, current, canReload) => ({
 	reloadEnvironment: reloadEnvironmentDecision(requested, current, canReload),
@@ -5341,7 +5397,7 @@ const ALL_TESTS_ID = TestRunner_exports.TestId.make("all");
 const ALL_TESTS_NAME = "All tests";
 const isCommandRunner = (name) => typeof name === "string" && name.toLowerCase() === "command";
 const commandRunnerCapabilities = { reloadEnvironment: true };
-const resultFromExit = (exitCode, output, timeSpentMs) => Match.value(exitCode).pipe(Match.when(0, () => ({
+const resultFromExit = (exitCode, output, timeSpentMs) => Match$1.value(exitCode).pipe(Match$1.when(0, () => ({
 	status: "complete",
 	tests: [{
 		id: ALL_TESTS_ID,
@@ -5349,7 +5405,7 @@ const resultFromExit = (exitCode, output, timeSpentMs) => Match.value(exitCode).
 		status: "success",
 		timeSpentMs
 	}]
-})), Match.orElse(() => ({
+})), Match$1.orElse(() => ({
 	status: "complete",
 	tests: [{
 		id: ALL_TESTS_ID,
@@ -5359,14 +5415,14 @@ const resultFromExit = (exitCode, output, timeSpentMs) => Match.value(exitCode).
 		timeSpentMs
 	}]
 })));
-const mutantActivation = (activeMutantId) => Match.value(activeMutantId).pipe(Match.when(Predicate$1.isString, (id) => ({
+const mutantActivation = (activeMutantId) => Match$1.value(activeMutantId).pipe(Match$1.when(Predicate$1.isString, (id) => ({
 	env: { [Mutant_exports.InstrumenterContext.ACTIVE_MUTANT_ENV_VARIABLE]: id },
 	extendEnv: true
-})), Match.orElse(() => void 0));
-const spawnResult = (outcome, elapsed) => Match.value(outcome).pipe(Match.tag("Failure", (failed) => ({
+})), Match$1.orElse(() => void 0));
+const spawnResult = (outcome, elapsed) => Match$1.value(outcome).pipe(Match$1.tag("Failure", (failed) => ({
 	status: "error",
 	errorMessage: String(failed.cause)
-})), Match.tag("Success", (exited) => resultFromExit(exited.value.exitCode, exited.value.output, elapsed)), Match.exhaustive);
+})), Match$1.tag("Success", (exited) => resultFromExit(exited.value.exitCode, exited.value.output, elapsed)), Match$1.exhaustive);
 const runCommand = Effect$1.fn("stryker.command_runner.run")(function* (config, activeMutantId) {
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const startedAt = yield* Clock.currentTimeMillis;
@@ -5417,16 +5473,16 @@ const vmTestRunnerConfig = () => ({
 	plugin: vmRunnerPluginUrl(),
 	options: { ...vmRunnerOptions }
 });
-const testRunnerConfigOf = (configured) => Match.value(configured).pipe(Match.when(isVmRunner, vmTestRunnerConfig), Match.orElse((unchanged) => unchanged));
+const testRunnerConfigOf = (configured) => Match$1.value(configured).pipe(Match$1.when(isVmRunner, vmTestRunnerConfig), Match$1.orElse((unchanged) => unchanged));
 //#endregion
 //#region src/TestRunner.blueprint.ts
 const TypeId$5 = Symbol.for("~systemfsoftware/stryker-js/TestRunner");
-const toRunnerBootFailure = (runnerName) => (error) => Match.value(error).pipe(Match.tag("WorkerBootTimeoutError", (timeout) => TestRunner_exports.TestRunnerFailed.make({
+const toRunnerBootFailure = (runnerName) => (error) => Match$1.value(error).pipe(Match$1.tag("WorkerBootTimeoutError", (timeout) => TestRunner_exports.TestRunnerFailed.make({
 	runnerName,
 	phase: "init",
 	cause: `Worker ${timeout.pid} did not accept the RPC connection before its boot window closed; its stderr above carries the reason`
-})), Match.tag("ChildProcessCrashedError", (crashed) => crashed), Match.tag("OutOfMemoryError", (outOfMemory) => outOfMemory), Match.exhaustive);
-const toRunnerFailure = (runnerName, phase) => (error) => Match.value(error).pipe(Match.tag("TestRunnerFailed", (e) => e), Match.orElse((e) => TestRunner_exports.TestRunnerFailed.make({
+})), Match$1.tag("ChildProcessCrashedError", (crashed) => crashed), Match$1.tag("OutOfMemoryError", (outOfMemory) => outOfMemory), Match$1.exhaustive);
+const toRunnerFailure = (runnerName, phase) => (error) => Match$1.value(error).pipe(Match$1.tag("TestRunnerFailed", (e) => e), Match$1.orElse((e) => TestRunner_exports.TestRunnerFailed.make({
 	runnerName,
 	phase,
 	cause: e.message
@@ -5448,8 +5504,8 @@ const scopedOf = Effect$1.fnUntraced(function* (params) {
 		...params.options,
 		testRunner: testRunnerConfigOf(params.options.testRunner)
 	};
-	const runnerName = Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
-	const execArgv = Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => Match.value(runner.nodeArgs).pipe(Match.when(Match.undefined, () => options.testRunnerNodeArgs), Match.orElse((args) => args))), Match.orElse(() => options.testRunnerNodeArgs));
+	const runnerName = Match$1.value(options.testRunner).pipe(Match$1.when(Options_exports.isCustomTestRunner, (runner) => runner.plugin), Match$1.orElse((name) => name));
+	const execArgv = Match$1.value(options.testRunner).pipe(Match$1.when(Options_exports.isCustomTestRunner, (runner) => Match$1.value(runner.nodeArgs).pipe(Match$1.when(Match$1.undefined, () => options.testRunnerNodeArgs), Match$1.orElse((args) => args))), Match$1.orElse(() => options.testRunnerNodeArgs));
 	const client = yield* makeWorkerClient({
 		rpcs: Plugin_exports.TestRunnerRpcs,
 		options,
@@ -5476,7 +5532,7 @@ const TestRunners = Blueprint.make()(TypeId$5).steps({
 });
 const makeChildProcessTestRunner = (params) => TestRunners.of(params).scoped;
 const commandRunnerEffect = (context) => ChildProcessSpawner.ChildProcessSpawner.pipe(Effect$1.map((spawner) => commandRunner(context, spawner).pipe(withTimeout, withRetry)));
-const inProcessRunner = (context) => Match.value(context.options.testRunner).pipe(Match.when(isCommandRunner, () => Option$1.some(commandRunnerEffect(context))), Match.orElse(() => Option$1.none()));
+const inProcessRunner = (context) => Match$1.value(context.options.testRunner).pipe(Match$1.when(isCommandRunner, () => Option$1.some(commandRunnerEffect(context))), Match$1.orElse(() => Option$1.none()));
 const decorateChildRunner = Effect$1.fnUntraced(function* (context, childProcessRunner) {
 	const base = yield* childProcessRunner;
 	const timed = withTimeout(base);
@@ -5597,7 +5653,11 @@ var WorkerSpawnResolved = class extends S.TaggedClass()("WorkerSpawnResolved", {
 var WorkerSpawnMissing = class extends S.TaggedError()("WorkerSpawnMissing", {
 	reason: S.String,
 	descriptor: S.String
-}) {};
+}) {
+	get message() {
+		return `${this.reason} (${this.descriptor})`;
+	}
+};
 var WorkerSpawnCommand = class extends S.TaggedClass()("WorkerSpawnCommand", {
 	sources: S.Array(PluginSourceSchema),
 	kind: Plugin_exports.WorkerPluginKind,
@@ -5605,8 +5665,8 @@ var WorkerSpawnCommand = class extends S.TaggedClass()("WorkerSpawnCommand", {
 }) {
 	static [Workflow.InstrumentationBrand] = { kind: "stryker.plugin.kind" };
 };
-const labelOfKind = (kind) => Match.value(kind).pipe(Match.when("TestRunner", () => "test runner"), Match.when("Checker", () => "checker"), Match.when("Reporter", () => "reporter"), Match.exhaustive);
-const kindIs = (kind) => (source) => Match.value(source.kind).pipe(Match.when(kind, () => true), Match.orElse(() => false));
+const labelOfKind = (kind) => Match$1.value(kind).pipe(Match$1.when("TestRunner", () => "test runner"), Match$1.when("Checker", () => "checker"), Match$1.when("Reporter", () => "reporter"), Match$1.exhaustive);
+const kindIs = (kind) => (source) => Match$1.value(source.kind).pipe(Match$1.when(kind, () => true), Match$1.orElse(() => false));
 const workerSourceOf = (sources, kind, matches) => Arr.findFirst(Arr.filter(sources, kindIs(kind)), matches);
 const resolvedSpawnOf = (command, matches, label) => Option$1.match(workerSourceOf(command.sources, command.kind, matches), {
 	onSome: (worker) => Result.succeed(WorkerSpawnResolved.make({
@@ -5622,7 +5682,7 @@ const resolvedSpawnOf = (command, matches, label) => Option$1.match(workerSource
 		}));
 	}
 });
-const decide$8 = (command) => Match.value(command.configured).pipe(Match.tag("ConfiguredPluginName", (configured) => resolvedSpawnOf(command, (worker) => worker.name.toLowerCase() === configured.name.toLowerCase(), configured.name)), Match.tag("ConfiguredPluginModulePath", (configured) => resolvedSpawnOf(command, (worker) => worker.modulePath === configured.modulePath, configured.modulePath)), Match.exhaustive);
+const decide$8 = (command) => Match$1.value(command.configured).pipe(Match$1.tag("ConfiguredPluginName", (configured) => resolvedSpawnOf(command, (worker) => worker.name.toLowerCase() === configured.name.toLowerCase(), configured.name)), Match$1.tag("ConfiguredPluginModulePath", (configured) => resolvedSpawnOf(command, (worker) => worker.modulePath === configured.modulePath, configured.modulePath)), Match$1.exhaustive);
 const resolveConfiguredPlugin = Workflow.make({
 	command: WorkerSpawnCommand,
 	decision: WorkerSpawnResolved,
@@ -5632,7 +5692,7 @@ const resolveConfiguredPlugin = Workflow.make({
 //#endregion
 //#region src/run/dry-run.cell.ts
 const sandboxPathsOf = (sandbox, fileNames) => Result.all(fileNames.map((fileName) => sandboxFileFor(sandbox, fileName)));
-const configuredPluginOf$1 = (configured) => Match.value(testRunnerConfigOf(configured)).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
+const configuredPluginOf$1 = (configured) => Match$1.value(testRunnerConfigOf(configured)).pipe(Match$1.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match$1.orElse((name) => ConfiguredPluginName.make({ name })));
 const workerSpawnOf = (stage, loaded, kind, configured) => Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
 	sources: loaded.pluginSources,
 	kind,
@@ -5660,14 +5720,14 @@ const resolveDryRunFiles = Effect$1.fn("stryker.dry_run.resolve_files")(function
 		cause
 	})));
 });
-const dryRunCommandOfDecision = (decision, allowEmpty) => Match.value(decision).pipe(Match.tag("DryRunObservedComplete", ({ testCount, failedTestCount, failedTests }) => ({
+const dryRunCommandOfDecision = (decision, allowEmpty) => Match$1.value(decision).pipe(Match$1.tag("DryRunObservedComplete", ({ testCount, failedTestCount, failedTests }) => ({
 	_tag: "DryRunCommand",
 	status: "Complete",
 	testCount,
 	failedTestCount,
 	failedTests,
 	allowEmpty
-})), Match.tag("DryRunObservedFailed", ({ errorMessage }) => ({
+})), Match$1.tag("DryRunObservedFailed", ({ errorMessage }) => ({
 	_tag: "DryRunCommand",
 	status: "Error",
 	testCount: 0,
@@ -5675,7 +5735,7 @@ const dryRunCommandOfDecision = (decision, allowEmpty) => Match.value(decision).
 	failedTests: [],
 	allowEmpty,
 	errorMessage
-})), Match.tag("DryRunObservedTimedOut", ({ reason }) => ({
+})), Match$1.tag("DryRunObservedTimedOut", ({ reason }) => ({
 	_tag: "DryRunCommand",
 	status: "Timeout",
 	testCount: 0,
@@ -5686,13 +5746,13 @@ const dryRunCommandOfDecision = (decision, allowEmpty) => Match.value(decision).
 		onNone: () => ({}),
 		onSome: (present) => ({ reason: present })
 	})
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const totalTestTime = (tests) => tests.reduce((total, test) => total + test.timeSpentMs, 0);
 const overheadMillisOf = (grossMillis, tests) => Math.max(0, grossMillis - totalTestTime(tests));
-const withOriginalFileName = (test, prev) => Match.value(test.fileName).pipe(Match.when(Predicate$1.isString, (fileName) => ({
+const withOriginalFileName = (test, prev) => Match$1.value(test.fileName).pipe(Match$1.when(Predicate$1.isString, (fileName) => ({
 	...test,
 	fileName: originalFileFor(prev.sandbox, fileName)
-})), Match.orElse(() => test));
+})), Match$1.orElse(() => test));
 const withOriginalFileNames = (tests, prev) => tests.map((test) => withOriginalFileName(test, prev));
 const testsByIdOf = (result) => MutableHashMap.fromIterable(result.tests.map((test) => [test.id, test]));
 const coveredMutantIdsOf = (coverage) => Object.entries(coverage).filter(([, count]) => count > 0).map(([mutantId]) => mutantId);
@@ -5720,7 +5780,7 @@ const testCoverageFrom = (result) => {
 		})
 	};
 };
-const announceDryRunOutcome = (tests, prev, gross, overheadMillis) => Match.value(tests.length).pipe(Match.when(0, () => Effect$1.logInfo("No tests were found")), Match.orElse(() => Effect$1.logInfo(`Initial test run succeeded. Ran ${tests.length} tests in ${Duration.format(gross)} (net ${totalTestTime(tests)} ms, overhead ${overheadMillis} ms).`).pipe(Effect$1.andThen(Effect$1.when(Effect$1.logInfo("Note: running the dry-run only. No mutations will be tested."), Effect$1.succeed(prev.options.dryRunOnly))))));
+const announceDryRunOutcome = (tests, prev, gross, overheadMillis) => Match$1.value(tests.length).pipe(Match$1.when(0, () => Effect$1.logInfo("No tests were found")), Match$1.orElse(() => Effect$1.logInfo(`Initial test run succeeded. Ran ${tests.length} tests in ${Duration.format(gross)} (net ${totalTestTime(tests)} ms, overhead ${overheadMillis} ms).`).pipe(Effect$1.andThen(Effect$1.when(Effect$1.logInfo("Note: running the dry-run only. No mutations will be tested."), Effect$1.succeed(prev.options.dryRunOnly))))));
 const completeDryRunResultOf = Effect$1.fn("stryker.dry_run.complete")(function* (raw, rawResult) {
 	const tests = withOriginalFileNames(rawResult.tests, raw.prev);
 	const dryRunResult = {
@@ -5746,13 +5806,13 @@ const completeDryRunResultOf = Effect$1.fn("stryker.dry_run.complete")(function*
 		timeOverhead: Duration.millis(overheadMillis)
 	};
 });
-const completeDryRunPassed = (raw) => Match.value(raw.rawResult).pipe(Match.discriminator("status")("complete", (rawResult) => completeDryRunResultOf(raw, rawResult)), Match.discriminator("status")("error", () => Effect$1.fail(StageError.make({
+const completeDryRunPassed = (raw) => Match$1.value(raw.rawResult).pipe(Match$1.discriminator("status")("complete", (rawResult) => completeDryRunResultOf(raw, rawResult)), Match$1.discriminator("status")("error", () => Effect$1.fail(StageError.make({
 	stage: "dryRun",
 	reason: "Unexpected dry-run status after decision"
-}))), Match.discriminator("status")("timeout", () => Effect$1.fail(StageError.make({
+}))), Match$1.discriminator("status")("timeout", () => Effect$1.fail(StageError.make({
 	stage: "dryRun",
 	reason: "Unexpected dry-run status after decision"
-}))), Match.exhaustive);
+}))), Match$1.exhaustive);
 const readDryRun = Effect$1.fnUntraced(function* (command) {
 	yield* Scope.Scope;
 	const idGenerator = yield* IdGenerator;
@@ -5803,7 +5863,7 @@ const readDryRun = Effect$1.fnUntraced(function* (command) {
 			}))),
 			gross
 		};
-	})).pipe(Effect$1.mapError((cause) => Match.value({ cause }).pipe(Match.when({ cause: (candidate) => S.is(StageError)(candidate) }, ({ cause }) => cause), Match.orElse(({ cause }) => StageError.make({
+	})).pipe(Effect$1.mapError((cause) => Match$1.value({ cause }).pipe(Match$1.when({ cause: (candidate) => S.is(StageError)(candidate) }, ({ cause }) => cause), Match$1.orElse(({ cause }) => StageError.make({
 		stage: "dryRun",
 		reason: "Dry run failed to start test runner",
 		cause
@@ -5893,14 +5953,14 @@ var EphemeralInstrument = class extends S.TaggedClass()("EphemeralInstrument", {
 }) {
 	[InstrumentDecisionTypeId] = InstrumentDecisionTypeId;
 };
-const decide$7 = (command) => Match.value(command.inPlace).pipe(Match.when(true, () => Result.succeed(InPlaceInstrument.make({
+const decide$7 = (command) => Match$1.value(command.inPlace).pipe(Match$1.when(true, () => Result.succeed(InPlaceInstrument.make({
 	workingDirectoryHint: "inPlace",
 	backupDirectoryHint: "backup",
 	fileCount: command.fileCount
-}))), Match.when(false, () => Result.succeed(EphemeralInstrument.make({
+}))), Match$1.when(false, () => Result.succeed(EphemeralInstrument.make({
 	workingDirectoryHint: "temp",
 	fileCount: command.fileCount
-}))), Match.exhaustive);
+}))), Match$1.exhaustive);
 const planInstrumentation = Workflow.make({
 	command: InstrumentCommand,
 	decision: S.Union([InPlaceInstrument, EphemeralInstrument]),
@@ -6144,7 +6204,7 @@ const matchesGlob = (matcher, allowHiddenFiles, resolvedFileName) => Boolean.mat
 		onFalse: () => Option$1.exists(regexpOf(matcher), (regexp) => regexp.test(resolvedFileName))
 	})
 });
-const matcherMatchesResolved = (resolvedPattern, allowHiddenFiles, resolvedFileName) => Match.value(expressionOf(resolvedPattern, false)).pipe(Match.withReturnType(), Match.tag("GlobMatcher", (matcher) => matchesGlob(matcher, allowHiddenFiles, resolvedFileName)), Match.tag("GlobUnmatchable", () => false), Match.exhaustive);
+const matcherMatchesResolved = (resolvedPattern, allowHiddenFiles, resolvedFileName) => Match$1.value(expressionOf(resolvedPattern, false)).pipe(Match$1.withReturnType(), Match$1.tag("GlobMatcher", (matcher) => matchesGlob(matcher, allowHiddenFiles, resolvedFileName)), Match$1.tag("GlobUnmatchable", () => false), Match$1.exhaustive);
 const hasHiddenSegment = (fileName) => fileName.split("/").some((entry) => entry.startsWith("."));
 var FileMatchCommand = class extends S.TaggedClass()("FileMatchCommand", {
 	resolvedPattern: S.Union([S.Boolean, S.String]),
@@ -6174,7 +6234,7 @@ const admitFileMatch = Workflow.make({
 const DEFAULT_GLOB = "**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}";
 const matchesFile = dual(3, (matcher, pathService, fileName) => {
 	const resolvedFileName = pathService.resolve(fileName).replace(/\\/g, "/");
-	const resolvedPattern = Match.value(matcher.pattern).pipe(Match.withReturnType(), Match.when(Match.string, (value) => pathService.resolve(value).replace(/\\/g, "/")), Match.when(true, () => DEFAULT_GLOB), Match.orElse(() => false));
+	const resolvedPattern = Match$1.value(matcher.pattern).pipe(Match$1.withReturnType(), Match$1.when(Match$1.string, (value) => pathService.resolve(value).replace(/\\/g, "/")), Match$1.when(true, () => DEFAULT_GLOB), Match$1.orElse(() => false));
 	return Option$1.exists(Result.getSuccess(admitFileMatch(FileMatchCommand.make({
 		resolvedPattern,
 		allowHiddenFiles: matcher.allowHiddenFiles,
@@ -6220,7 +6280,7 @@ const mergeUpdatedFile = (project, updated) => {
 		onSome: () => MutableHashMap.set(project.filesToMutate, updated.name, updated)
 	});
 };
-const updateOf = (updated) => Match.value(updated).pipe(Match.when(void 0, () => void 0), Match.when(Option$1.isOption, (option) => Option$1.getOrUndefined(option)), Match.orElse((file) => file));
+const updateOf = (updated) => Match$1.value(updated).pipe(Match$1.when(void 0, () => void 0), Match$1.when(Option$1.isOption, (option) => Option$1.getOrUndefined(option)), Match$1.orElse((file) => file));
 const mergeUpdatedInto = (project) => (updated) => {
 	const file = updateOf(updated);
 	Option$1.match(Option$1.fromUndefinedOr(file), {
@@ -6256,7 +6316,7 @@ const parseJsonText = (jsonText) => Effect$1.try({
 const tsConfigShapeOf = (parsed) => Option$1.filter(Option$1.some(parsed), Schema.is(TsConfigSchema));
 const parseTsConfig = (fileName, jsonText) => Effect$1.flatMap(parseJsonText(jsonText), (parsed) => Effect$1.fromOption(tsConfigShapeOf(parsed), () => `parsed to ${JSON.stringify(parsed)}, which does not match the tsconfig shape this package consumes`));
 const makeTSConfigPreprocessor = (options, basePath) => {
-	const rewriteReferenceOrKeep = (reference, tsconfigFileName, pathService) => Match.value(tryRewriteReference(reference, tsconfigFileName, pathService, basePath)).pipe(Match.when(Predicate.isString, (rewritten) => rewritten), Match.orElse(() => reference));
+	const rewriteReferenceOrKeep = (reference, tsconfigFileName, pathService) => Match$1.value(tryRewriteReference(reference, tsconfigFileName, pathService, basePath)).pipe(Match$1.when(Predicate.isString, (rewritten) => rewritten), Match$1.orElse(() => reference));
 	const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
 	const rewriteFileArrayProperty = (config, tsconfigFileName, prop, pathService) => {
 		const value = config[prop];
@@ -6281,7 +6341,7 @@ const makeTSConfigPreprocessor = (options, basePath) => {
 			onSuccess: (config) => Effect$1.all([rewriteExtends(config, tsconfigFileName, pathService, project), rewriteProjectReferences(config, tsconfigFileName, pathService, project)], { discard: true }).pipe(Effect$1.flatMap(() => rewriteFileArrayProperties(config, tsconfigFile, tsconfigFileName, pathService)))
 		}))
 	}));
-	const rewriteExtendsEntry = (config, extend, tsconfigFileName, pathService, project) => Match.value(tryRewriteReference(extend, tsconfigFileName, pathService, basePath)).pipe(Match.when(Predicate.isString, (rewritten) => Effect$1.succeed(rewritten)), Match.orElse(() => rewriteTSConfigFile(project, pathService.resolve(pathService.dirname(tsconfigFileName), extend), pathService).pipe(Effect$1.as(extend))));
+	const rewriteExtendsEntry = (config, extend, tsconfigFileName, pathService, project) => Match$1.value(tryRewriteReference(extend, tsconfigFileName, pathService, basePath)).pipe(Match$1.when(Predicate.isString, (rewritten) => Effect$1.succeed(rewritten)), Match$1.orElse(() => rewriteTSConfigFile(project, pathService.resolve(pathService.dirname(tsconfigFileName), extend), pathService).pipe(Effect$1.as(extend))));
 	const rewriteSingleExtends = (config, extend, tsconfigFileName, pathService, project) => Effect$1.flatMap(rewriteExtendsEntry(config, extend, tsconfigFileName, pathService, project), (rewritten) => {
 		config.extends = rewritten;
 		return Effect$1.void;
@@ -6290,15 +6350,15 @@ const makeTSConfigPreprocessor = (options, basePath) => {
 		config.extends = rewritten;
 		return Effect$1.void;
 	}));
-	const rewriteExtends = (config, tsconfigFileName, pathService, project) => Match.value(config.extends).pipe(Match.when(Predicate.isString, (extend) => rewriteSingleExtends(config, extend, tsconfigFileName, pathService, project)), Match.when(Schema.is(ExtendsArraySchema), (extendEntries) => rewriteExtendsArray(config, extendEntries, tsconfigFileName, pathService, project)), Match.orElse(() => Effect$1.void));
+	const rewriteExtends = (config, tsconfigFileName, pathService, project) => Match$1.value(config.extends).pipe(Match$1.when(Predicate.isString, (extend) => rewriteSingleExtends(config, extend, tsconfigFileName, pathService, project)), Match$1.when(Schema.is(ExtendsArraySchema), (extendEntries) => rewriteExtendsArray(config, extendEntries, tsconfigFileName, pathService, project)), Match$1.orElse(() => Effect$1.void));
 	const referencedTsConfigPath = (referencePath) => Boolean.match(referencePath.endsWith(".json"), {
 		onTrue: () => referencePath,
 		onFalse: () => `${referencePath}/tsconfig.json`
 	});
-	const rewriteReference = (ref, originTSConfigFileName, pathService, project) => Match.value(tryRewriteReference(ref.path, originTSConfigFileName, pathService, basePath)).pipe(Match.when(Predicate.isString, (rewritten) => {
+	const rewriteReference = (ref, originTSConfigFileName, pathService, project) => Match$1.value(tryRewriteReference(ref.path, originTSConfigFileName, pathService, basePath)).pipe(Match$1.when(Predicate.isString, (rewritten) => {
 		ref.path = rewritten;
 		return Effect$1.void;
-	}), Match.orElse(() => rewriteTSConfigFile(project, pathService.resolve(pathService.dirname(originTSConfigFileName), referencedTsConfigPath(ref.path)), pathService)));
+	}), Match$1.orElse(() => rewriteTSConfigFile(project, pathService.resolve(pathService.dirname(originTSConfigFileName), referencedTsConfigPath(ref.path)), pathService)));
 	const rewriteProjectReferences = (config, originTSConfigFileName, pathService, project) => Option$1.match(Option$1.fromUndefinedOr(config.references), {
 		onNone: () => Effect$1.void,
 		onSome: (references) => Effect$1.forEach(references, (ref) => rewriteReference(ref, originTSConfigFileName, pathService, project)).pipe(Effect$1.asVoid)
@@ -6328,7 +6388,7 @@ const directoryChain = (from, pathService) => Boolean.match(pathService.dirname(
 });
 const binDirectoriesFrom = (from, pathService) => directoryChain(pathService.resolve(from), pathService).map((directory) => pathService.join(directory, "node_modules", ".bin"));
 const inheritedPath = () => Config.String("PATH").pipe(Effect$1.option, Effect$1.map((value) => Option$1.getOrUndefined(value) ?? ""));
-const failOnBuildFailure = (command, result) => Match.value(result.exitCode).pipe(Match.when((exitCode) => exitCode !== 0, (exitCode) => Effect$1.fail(StrykerError.make({ message: `Build command "${command}" failed with exit code ${String(exitCode)}.\n${result.stderr}` }))), Match.orElse(() => Effect$1.void));
+const failOnBuildFailure = (command, result) => Match$1.value(result.exitCode).pipe(Match$1.when((exitCode) => exitCode !== 0, (exitCode) => Effect$1.fail(StrykerError.make({ message: `Build command "${command}" failed with exit code ${String(exitCode)}.\n${result.stderr}` }))), Match$1.orElse(() => Effect$1.void));
 const runBuildCommandIn = Effect$1.fn("stryker.sandbox.build.run")(function* (command, workingDirectory) {
 	const pathService = yield* Path.Path;
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
@@ -6358,7 +6418,7 @@ const runBuildCommandIn = Effect$1.fn("stryker.sandbox.build.run")(function* (co
 	})));
 	yield* failOnBuildFailure(command, result);
 });
-const directoryRole = (dir, walk) => Match.value(walk.path.basename(dir)).pipe(Match.when((name) => name === walk.tempDirName, () => "skipped"), Match.when((name) => name === "node_modules", () => "nodeModules"), Match.orElse(() => "searchable"));
+const directoryRole = (dir, walk) => Match$1.value(walk.path.basename(dir)).pipe(Match$1.when((name) => name === walk.tempDirName, () => "skipped"), Match$1.when((name) => name === "node_modules", () => "nodeModules"), Match$1.orElse(() => "searchable"));
 const childDirectoriesOf = (dir, walk) => Effect$1.flatMap(walk.fs.readDirectory(walk.path.join(walk.basePath, dir)).pipe(Effect$1.orElseSucceed(() => [])), (entries) => Effect$1.map(Effect$1.forEach(entries, (entry) => {
 	const child = walk.path.join(dir, entry);
 	return Effect$1.map(walk.fs.stat(walk.path.join(walk.basePath, child)).pipe(Effect$1.map((info) => info.type), Effect$1.orElseSucceed(() => "Unknown")), (statType) => Boolean.match(statType === "Directory", {
@@ -6366,13 +6426,13 @@ const childDirectoriesOf = (dir, walk) => Effect$1.flatMap(walk.fs.readDirectory
 		onFalse: () => Option$1.none()
 	}));
 }, { concurrency: 1 }), (children) => children.filter(Option$1.isSome).map((some) => some.value)));
-const walkStep = (dir, walk) => Match.value(directoryRole(dir, walk)).pipe(Match.when("nodeModules", () => Effect$1.succeed({
+const walkStep = (dir, walk) => Match$1.value(directoryRole(dir, walk)).pipe(Match$1.when("nodeModules", () => Effect$1.succeed({
 	emit: [dir],
 	children: []
-})), Match.when("skipped", () => Effect$1.succeed({
+})), Match$1.when("skipped", () => Effect$1.succeed({
 	emit: [],
 	children: []
-})), Match.orElse(() => Effect$1.map(childDirectoriesOf(dir, walk), (children) => ({
+})), Match$1.orElse(() => Effect$1.map(childDirectoriesOf(dir, walk), (children) => ({
 	emit: [],
 	children
 }))));
@@ -6440,7 +6500,7 @@ const restoreFromBackup = Effect$1.fn("stryker.sandbox.restore_original")(functi
 });
 const restoreOriginalFiles = (workingDirectory, backupDirectory, basePath) => Effect$1.addFinalizer(() => restoreFromBackup(backupDirectory, workingDirectory, basePath).pipe(Effect$1.orDie));
 const isNonEmptyString = (value) => value !== void 0 && value !== "";
-const runConfiguredBuild = (options, workingDirectory) => Match.value(options.buildCommand).pipe(Match.when(isNonEmptyString, (command) => Effect$1.logInfo(`Running build command "${command}" in "${workingDirectory}".`).pipe(Effect$1.andThen(() => runBuildCommandIn(command, workingDirectory)))), Match.orElse(() => Effect$1.void));
+const runConfiguredBuild = (options, workingDirectory) => Match$1.value(options.buildCommand).pipe(Match$1.when(isNonEmptyString, (command) => Effect$1.logInfo(`Running build command "${command}" in "${workingDirectory}".`).pipe(Effect$1.andThen(() => runBuildCommandIn(command, workingDirectory)))), Match$1.orElse(() => Effect$1.void));
 const linksNodeModules = (options) => Boolean.match(options.symlinkNodeModules, {
 	onTrue: () => !options.inPlace,
 	onFalse: () => false
@@ -6552,11 +6612,11 @@ const claimedReasonOf = (extension, claimants) => `No loaded framework claims "$
 const unclaimedReasonOf = (extension) => `No loaded framework claims "${extension}". No installed package declares it as a framework plugin: install the framework plugin that claims this file type and add it to "plugins" to instrument it.`;
 const explainedOf = (command) => {
 	const claimants = claimantsOf(command);
-	return Match.value(claimants.length > 0).pipe(Match.when(true, () => FileSkipExplained.make({
+	return Match$1.value(claimants.length > 0).pipe(Match$1.when(true, () => FileSkipExplained.make({
 		extension: command.extension,
 		reason: claimedReasonOf(command.extension, claimants),
 		ownerPackage: Option$1.getOrNull(Option$1.fromUndefinedOr(claimants.at(0)))
-	})), Match.orElse(() => FileSkipExplained.make({
+	})), Match$1.orElse(() => FileSkipExplained.make({
 		extension: command.extension,
 		reason: unclaimedReasonOf(command.extension),
 		ownerPackage: null
@@ -6577,7 +6637,7 @@ const explainFileSkip = Workflow.make({
 	command: ExplainFileSkipCommand,
 	decision: FileSkipDecision,
 	error: S.Never,
-	decide: (command) => Match.value(skipKnownOrUnknownOf(explainedOf(command))).pipe(Match.tag("SkipKnownExplained", (known) => Result.succeed(known)), Match.tag("SkipUnknownExplained", (unknown) => Result.succeed(unknown)), Match.exhaustive)
+	decide: (command) => Match$1.value(skipKnownOrUnknownOf(explainedOf(command))).pipe(Match$1.tag("SkipKnownExplained", (known) => Result.succeed(known)), Match$1.tag("SkipUnknownExplained", (unknown) => Result.succeed(unknown)), Match$1.exhaustive)
 });
 //#endregion
 //#region src/run/instrument.cell.ts
@@ -6738,18 +6798,18 @@ var MutationTestDryRunOnly = class extends S.TaggedClass()("MutationTestDryRunOn
 var MutationTestNoTests = class extends S.TaggedClass()("MutationTestNoTests", {}) {
 	[MutationTestDecisionTypeId] = MutationTestDecisionTypeId;
 };
-const decide$6 = (command) => Match.value({
+const decide$6 = (command) => Match$1.value({
 	invalid: command.testCount < 0,
 	dryRunOnly: command.dryRunOnly,
 	isZero: command.isZero,
 	allowEmpty: command.allowEmpty
-}).pipe(Match.when({ invalid: true }, () => Result.fail(MutationTestError.make({
+}).pipe(Match$1.when({ invalid: true }, () => Result.fail(MutationTestError.make({
 	stage: "mutationTest",
 	reason: "Invalid test count"
-}))), Match.when({ dryRunOnly: true }, () => Result.succeed(MutationTestDryRunOnly.make({}))), Match.when({
+}))), Match$1.when({ dryRunOnly: true }, () => Result.succeed(MutationTestDryRunOnly.make({}))), Match$1.when({
 	isZero: true,
 	allowEmpty: true
-}, () => Result.succeed(MutationTestNoTests.make({}))), Match.orElse(() => Result.succeed(MutationTestProceed.make({}))));
+}, () => Result.succeed(MutationTestNoTests.make({}))), Match$1.orElse(() => Result.succeed(MutationTestProceed.make({}))));
 const admitMutationTest = Workflow.make({
 	command: MutationTestCommand,
 	decision: S.Union([
@@ -6811,20 +6871,20 @@ const TypeId$3 = Symbol.for("~systemfsoftware/stryker-js/CheckerPool");
 const CheckerPoolHandle = Handle.make()(TypeId$3);
 CheckerPoolHandle.is;
 const makeCheckerPoolHandle = (pool) => CheckerPoolHandle.make({}, pool);
-const isCheckerCrash = (error) => Match.value(error).pipe(Match.tag("ChildProcessCrashedError", "OutOfMemoryError", () => true), Match.orElse(() => false));
-const checkerBreachToStageError = (error) => Match.value(error).pipe(Match.tag("CheckerFailed", (failed) => StageError.make({
+const isCheckerCrash = (error) => Match$1.value(error).pipe(Match$1.tag("ChildProcessCrashedError", "OutOfMemoryError", () => true), Match$1.orElse(() => false));
+const checkerBreachToStageError = (error) => Match$1.value(error).pipe(Match$1.tag("CheckerFailed", (failed) => StageError.make({
 	stage: "mutationTest",
 	reason: failed.cause,
 	cause: failed
-})), Match.tag("CheckerAnsweredUnrequested", (breach) => StageError.make({
+})), Match$1.tag("CheckerAnsweredUnrequested", (breach) => StageError.make({
 	stage: "mutationTest",
 	reason: `Checker "${breach.checkerName}" answered about mutants it was not asked about (${breach.phase} phase): ${breach.unrequestedIds.join(", ")}`,
 	cause: breach
-})), Match.tag("CheckerSkippedRequested", (breach) => StageError.make({
+})), Match$1.tag("CheckerSkippedRequested", (breach) => StageError.make({
 	stage: "mutationTest",
 	reason: `Checker "${breach.checkerName}" skipped requested mutants (${breach.phase} phase): ${breach.missingIds.join(", ")}`,
 	cause: breach
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const invalidateSlot$1 = (pool, slot, error) => Effect$1.flatMap(Pool.invalidate(pool, slot), () => Effect$1.fail(error));
 const onCheckerSlot = (pool, checkerIndex, run) => Pool.use(pool, (slot) => Option$1.match(Option$1.fromUndefinedOr(slot[checkerIndex]), {
 	onNone: () => Effect$1.die(/* @__PURE__ */ new Error(`checker slot has no entry at index ${checkerIndex}`)),
@@ -6890,7 +6950,7 @@ const checkerProcessCrashes = Metric.counter("stryker.checker.process_crashes",
 	incremental: true
 });
 const TEMP_DIR_PREFIX = "stryker-checker-";
-const nodeArgsOf = (options) => Match.value(options.checkers[0]?.nodeArgs).pipe(Match.when(Match.undefined, () => options.checkerNodeArgs), Match.orElse((args) => args));
+const nodeArgsOf = (options) => Match$1.value(options.checkers[0]?.nodeArgs).pipe(Match$1.when(Match$1.undefined, () => options.checkerNodeArgs), Match$1.orElse((args) => args));
 const serviceOf = (handle) => ({
 	check: (checkerName, mutants) => check(handle, checkerName, mutants),
 	group: (checkerName, mutants) => group(handle, checkerName, mutants)
@@ -6903,7 +6963,7 @@ const acquire$2 = Effect$1.fnUntraced(function* (spec) {
 		workingDirectory: spec.workingDirectory,
 		execArgv: [...nodeArgsOf(spec.options)],
 		tempDirPrefix: TEMP_DIR_PREFIX
-	}).pipe(Effect$1.mapError((error) => Match.value(error).pipe(Match.tag("ChildProcessCrashedError", "OutOfMemoryError", (crash) => crash), Match.tag("WorkerBootTimeoutError", () => connectionCrashed(`Checker worker failed to start: its boot window closed before it accepted the RPC connection`)), Match.exhaustive)), Effect$1.tapError(() => Metric.update(checkerProcessCrashes, 1)));
+	}).pipe(Effect$1.mapError((error) => Match$1.value(error).pipe(Match$1.tag("ChildProcessCrashedError", "OutOfMemoryError", (crash) => crash), Match$1.tag("WorkerBootTimeoutError", () => connectionCrashed(`Checker worker failed to start: its boot window closed before it accepted the RPC connection`)), Match$1.exhaustive)), Effect$1.tapError(() => Metric.update(checkerProcessCrashes, 1)));
 	return serviceOf(makeCheckerHandle(client));
 });
 const Checkers = Blueprint.make()(TypeId$2).steps({
@@ -7232,8 +7292,16 @@ var PlannedEarlyResultMutant = class extends S.TaggedClass()("PlannedEarlyResult
 }) {
 	[MutantPlanTypeId] = MutantPlanTypeId;
 };
-var CoveredMutantHitCountMissing = class extends S.TaggedError()("CoveredMutantHitCountMissing", { missingIds: S.Array(S.String) }) {};
-var MutantTimeoutNotFinite = class extends S.TaggedError()("MutantTimeoutNotFinite", { mutantId: Mutant_exports.MutantId }) {};
+var CoveredMutantHitCountMissing = class extends S.TaggedError()("CoveredMutantHitCountMissing", { missingIds: S.Array(S.String) }) {
+	get message() {
+		return `Hit count missing for covered mutants: ${this.missingIds.join(", ")}`;
+	}
+};
+var MutantTimeoutNotFinite = class extends S.TaggedError()("MutantTimeoutNotFinite", { mutantId: Mutant_exports.MutantId }) {
+	get message() {
+		return `Computed test timeout for mutant ${this.mutantId} is not finite`;
+	}
+};
 const firstDefined$1 = (first, second) => Option$1.getOrElse(Option$1.fromNullishOr(first), () => second);
 const staticField = (isStatic) => Option$1.match(Option$1.fromUndefinedOr(isStatic), {
 	onNone: () => ({}),
@@ -7457,7 +7525,7 @@ const earlyResultPlanOf = (mutant, early) => ({
 		coveredBy: early.coveredBy
 	})
 });
-const decide$1 = (command) => Match.value(command.plan).pipe(Match.tag("PlannedRunMutant", (run) => Result.succeed(MutantRunPlanMaterialized.make({ plan: runPlanOf(command.mutant, run) }))), Match.tag("PlannedEarlyResultMutant", (early) => Result.succeed(MutantEarlyResultPlanMaterialized.make({ plan: earlyResultPlanOf(command.mutant, early) }))), Match.exhaustive);
+const decide$1 = (command) => Match$1.value(command.plan).pipe(Match$1.tag("PlannedRunMutant", (run) => Result.succeed(MutantRunPlanMaterialized.make({ plan: runPlanOf(command.mutant, run) }))), Match$1.tag("PlannedEarlyResultMutant", (early) => Result.succeed(MutantEarlyResultPlanMaterialized.make({ plan: earlyResultPlanOf(command.mutant, early) }))), Match$1.exhaustive);
 const materializeMutantPlans = Workflow.make({
 	command: MaterializeMutantPlanCommand,
 	decision: S.Union([MutantRunPlanMaterialized, MutantEarlyResultPlanMaterialized]),
@@ -7521,13 +7589,13 @@ const readPlanCommand = Effect$1.fn("stryker.mutation_test.plan.read")(function*
 		mutantsById: mutantsByIdOf(input.mutants)
 	};
 });
-const plannedPlanOf = (mutant, decision) => Match.value(decision).pipe(Match.tag("PlannedRunMutant", (run) => PlannedRunMutant.make({
+const plannedPlanOf = (mutant, decision) => Match$1.value(decision).pipe(Match$1.tag("PlannedRunMutant", (run) => PlannedRunMutant.make({
 	...run,
 	mutantId: mutant.id
-})), Match.tag("PlannedEarlyResultMutant", (early) => PlannedEarlyResultMutant.make({
+})), Match$1.tag("PlannedEarlyResultMutant", (early) => PlannedEarlyResultMutant.make({
 	...early,
 	mutantId: mutant.id
-})), Match.exhaustive);
+})), Match$1.exhaustive);
 const materializeDecision = Effect$1.fnUntraced(function* (decision, command) {
 	const mutant = yield* Option$1.match(Record$1.get(command.mutantsById, decision.mutantId), {
 		onNone: () => Effect$1.die(UnknownPlannedMutant.make({
@@ -7621,7 +7689,7 @@ const reportingInputOf = (input) => ({
 	reporterStage: input.prev.reporterStage,
 	formatRegistry: input.prev.formatRegistry
 });
-const reasonOf = (result) => Match.value(result).pipe(Match.when({ status: "timeout" }, (timedOut) => timedOut.reason), Match.orElse(() => void 0));
+const reasonOf = (result) => Match$1.value(result).pipe(Match$1.when({ status: "timeout" }, (timedOut) => timedOut.reason), Match$1.orElse(() => void 0));
 const invalidateSlot = (pool, slot, error) => Effect$1.flatMap(Pool.invalidate(pool, slot), () => Effect$1.fail(error));
 const preparedStreamableOf = Effect$1.fnUntraced(function* (context, result) {
 	return yield* Option$1.match(Option$1.filter(Option$1.some(result.status), isMutantStatus), {
@@ -7731,7 +7799,7 @@ const runOnePlan = (input) => mutantRunCell.run(input);
 //#region src/run/test-runner-pool.blueprint.ts
 const TypeId = Symbol.for("~systemfsoftware/stryker-js/TestRunnerPoolBlueprint");
 const IDLE_TIME_TO_LIVE = Duration.minutes(1);
-const configuredPluginOf = (configured) => Match.value(testRunnerConfigOf(configured)).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
+const configuredPluginOf = (configured) => Match$1.value(testRunnerConfigOf(configured)).pipe(Match$1.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match$1.orElse((name) => ConfiguredPluginName.make({ name })));
 const testRunnerWorkerSpawnOf = (loaded, configured) => Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
 	sources: loaded.pluginSources,
 	kind: "TestRunner",
@@ -7895,7 +7963,7 @@ const proceedPipeline = Effect$1.fnUntraced(function* (raw) {
 	yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
 	return outcomeResult;
 });
-const mapMutationTestCause = (cause) => Match.value({ cause }).pipe(Match.when({ cause: (candidate) => S.is(StageError)(candidate) }, ({ cause }) => cause), Match.orElse(({ cause }) => StageError.make({
+const mapMutationTestCause = (cause) => Match$1.value({ cause }).pipe(Match$1.when({ cause: (candidate) => S.is(StageError)(candidate) }, ({ cause }) => cause), Match$1.orElse(({ cause }) => StageError.make({
 	stage: "mutationTest",
 	reason: "Mutation testing failed",
 	cause
@@ -8158,16 +8226,16 @@ const isArray = (value) => Array.isArray(value);
 const isMapRecord = (value) => Predicate$1.isObject(value);
 const subpathOf = (specifier) => {
 	const segments = specifier.split("/");
-	const nameSegments = Match.value(specifier.startsWith("@")).pipe(Match.when(true, () => 2), Match.orElse(() => 1));
+	const nameSegments = Match$1.value(specifier.startsWith("@")).pipe(Match$1.when(true, () => 2), Match$1.orElse(() => 1));
 	return segments.slice(nameSegments).join("/");
 };
-const exportKeyOf = (subpath) => Match.value(subpath.length === 0).pipe(Match.when(true, () => "."), Match.orElse(() => `./${subpath}`));
+const exportKeyOf = (subpath) => Match$1.value(subpath.length === 0).pipe(Match$1.when(true, () => "."), Match$1.orElse(() => `./${subpath}`));
 const checkedTargetOf = (target, relative) => Option$1.match(Option$1.some(target).pipe(Option$1.filter((candidate) => candidate.includes("*"))), {
 	onSome: () => Wildcard.make({}),
 	onNone: () => relative(target)
 });
-const stringTargetOf = (target) => checkedTargetOf(target, () => Match.value(target.startsWith("./")).pipe(Match.when(true, () => Selected.make({ target })), Match.orElse(() => NotRelative.make({ target }))));
-const fileTargetOf = (target) => checkedTargetOf(target, () => Match.value(target.startsWith("/")).pipe(Match.when(true, () => NotRelative.make({ target })), Match.orElse(() => Selected.make({ target }))));
+const stringTargetOf = (target) => checkedTargetOf(target, () => Match$1.value(target.startsWith("./")).pipe(Match$1.when(true, () => Selected.make({ target })), Match$1.orElse(() => NotRelative.make({ target }))));
+const fileTargetOf = (target) => checkedTargetOf(target, () => Match$1.value(target.startsWith("/")).pipe(Match$1.when(true, () => NotRelative.make({ target })), Match$1.orElse(() => Selected.make({ target }))));
 const arrayTargetOf = (elements) => Option$1.match(Option$1.fromUndefinedOr(elements.at(0)), {
 	onNone: () => Nullish.make({}),
 	onSome: (first) => targetOfValue(first)
@@ -8179,18 +8247,18 @@ const conditionTargetOf = (conditions) => Option$1.match(Option$1.fromUndefinedO
 	onNone: () => Nullish.make({}),
 	onSome: (found) => found
 });
-const targetOfValue = (value) => Match.value(value).pipe(Match.when(isString, (target) => stringTargetOf(target)), Match.when(isArray, (elements) => arrayTargetOf(elements)), Match.when(isMapRecord, (map) => conditionTargetOf(map)), Match.orElse(() => Nullish.make({})));
-const matchedOf = (selection, key) => Match.value(selection).pipe(Match.tag("Selected", () => Match.value(key).pipe(Match.when(".", () => selection), Match.orElse(() => Unmatched.make({ key })))), Match.orElse(() => selection));
+const targetOfValue = (value) => Match$1.value(value).pipe(Match$1.when(isString, (target) => stringTargetOf(target)), Match$1.when(isArray, (elements) => arrayTargetOf(elements)), Match$1.when(isMapRecord, (map) => conditionTargetOf(map)), Match$1.orElse(() => Nullish.make({})));
+const matchedOf = (selection, key) => Match$1.value(selection).pipe(Match$1.tag("Selected", () => Match$1.value(key).pipe(Match$1.when(".", () => selection), Match$1.orElse(() => Unmatched.make({ key })))), Match$1.orElse(() => selection));
 const isSubpathMap = (map) => Object.keys(map).some((key) => key.startsWith("."));
-const mappedTargetOf = (map, key) => Match.value(isSubpathMap(map)).pipe(Match.when(true, () => Option$1.match(Option$1.fromUndefinedOr(map[key]), {
+const mappedTargetOf = (map, key) => Match$1.value(isSubpathMap(map)).pipe(Match$1.when(true, () => Option$1.match(Option$1.fromUndefinedOr(map[key]), {
 	onNone: () => Unmatched.make({ key }),
 	onSome: (target) => targetOfValue(target)
-})), Match.orElse(() => matchedOf(conditionTargetOf(map), key)));
+})), Match$1.orElse(() => matchedOf(conditionTargetOf(map), key)));
 const declaredTargetOf = (exports, key) => Option$1.match(Option$1.fromUndefinedOr(exports), {
 	onNone: () => Nullish.make({}),
 	onSome: (value) => targetOfKey(value, key)
 });
-const targetOfKey = (value, key) => Match.value(value).pipe(Match.when(isMapRecord, (map) => mappedTargetOf(map, key)), Match.orElse(() => matchedOf(targetOfValue(value), key)));
+const targetOfKey = (value, key) => Match$1.value(value).pipe(Match$1.when(isMapRecord, (map) => mappedTargetOf(map, key)), Match$1.orElse(() => matchedOf(targetOfValue(value), key)));
 const declaredEntryOf = (manifest) => Option$1.match(Option$1.fromNullishOr(manifest.module), {
 	onSome: (entry) => checkedTargetOf(entry, fileTargetOf),
 	onNone: () => Option$1.match(Option$1.fromNullishOr(manifest.main), {
@@ -8210,10 +8278,10 @@ const selectPackageEntry = Workflow.make({
 	command: SelectPackageEntryCommand,
 	decision: PackageEntryDecision,
 	error: S.Never,
-	decide: (command) => Match.value(selectionOf(command)).pipe(Match.tag("Selected", ({ target }) => Result.succeed(PackageEntrySelected.make({
+	decide: (command) => Match$1.value(selectionOf(command)).pipe(Match$1.tag("Selected", ({ target }) => Result.succeed(PackageEntrySelected.make({
 		specifier: command.specifier,
 		entry: target
-	}))), Match.tag("Undeclared", () => Result.succeed(unresolvedOf(command.specifier, `the package declares no "exports", "module", or "main" entry`))), Match.tag("Unmatched", ({ key }) => Result.succeed(unresolvedOf(command.specifier, `the package does not export "${key}"`))), Match.tag("Wildcard", () => Result.succeed(unresolvedOf(command.specifier, "the package declares a wildcard export, which this host does not resolve"))), Match.tag("Nullish", () => Result.succeed(unresolvedOf(command.specifier, "the matching package export resolves to null"))), Match.tag("NotRelative", ({ target }) => Result.succeed(unresolvedOf(command.specifier, `the package export "${target}" is not a relative path`))), Match.exhaustive)
+	}))), Match$1.tag("Undeclared", () => Result.succeed(unresolvedOf(command.specifier, `the package declares no "exports", "module", or "main" entry`))), Match$1.tag("Unmatched", ({ key }) => Result.succeed(unresolvedOf(command.specifier, `the package does not export "${key}"`))), Match$1.tag("Wildcard", () => Result.succeed(unresolvedOf(command.specifier, "the package declares a wildcard export, which this host does not resolve"))), Match$1.tag("Nullish", () => Result.succeed(unresolvedOf(command.specifier, "the matching package export resolves to null"))), Match$1.tag("NotRelative", ({ target }) => Result.succeed(unresolvedOf(command.specifier, `the package export "${target}" is not a relative path`))), Match$1.exhaustive)
 });
 //#endregion
 //#region src/plugin-loader.service.ts
@@ -8235,11 +8303,11 @@ const buildPluginLoadPlan = (entries) => {
 			return Option$1.some(plugins);
 		}
 	})), HashMap.empty());
-	const pluginSources = winningDeclarations.map((declaration) => Match.value(declaration.plugin).pipe(Match.when((plugin) => plugin.kind === "Evaluator", (evaluator) => ({
+	const pluginSources = winningDeclarations.map((declaration) => Match$1.value(declaration.plugin).pipe(Match$1.when((plugin) => plugin.kind === "Evaluator", (evaluator) => ({
 		kind: "Evaluator",
 		name: evaluator.name,
 		modulePath: declaration.moduleName
-	})), Match.orElse((worker) => ({
+	})), Match$1.orElse((worker) => ({
 		kind: worker.kind,
 		name: worker.name,
 		modulePath: declaration.moduleName,
@@ -8276,9 +8344,9 @@ const importFailure = (descriptor, crash) => PluginLoadRefusedError.make({
 	}
 });
 const failPluginLoad = (descriptor, error) => Effect$1.logWarning(`Error during loading "${descriptor}" plugin`).pipe(Effect$1.annotateLogs("cause", error), Effect$1.andThen(() => Effect$1.fail(error)));
-const modulePluginContributions = (module) => Match.value(Predicate$1.hasProperty(module, "strykerPlugins")).pipe(Match.when(true, () => S.decodeUnknownResult(PluginModuleSchema)(module).pipe(Result.map((pluginModule) => pluginModule.strykerPlugins))), Match.orElse(() => Result.succeed(void 0)));
-const moduleIgnorers = (module) => Match.value(Predicate$1.hasProperty(module, "strykerIgnorers")).pipe(Match.when(true, () => S.decodeUnknownResult(IgnorerModuleSchema)(module).pipe(Result.map((ignorerModule) => ignorerModule.strykerIgnorers))), Match.orElse(() => Result.succeed(void 0)));
-const moduleFrameworks = (module) => Match.value(Predicate$1.hasProperty(module, "strykerFrameworks")).pipe(Match.when(true, () => S.decodeUnknownResult(FrameworkModuleSchema)(module).pipe(Result.map((frameworkModule) => [...frameworkModule.strykerFrameworks]))), Match.orElse(() => Result.succeed(void 0)));
+const modulePluginContributions = (module) => Match$1.value(Predicate$1.hasProperty(module, "strykerPlugins")).pipe(Match$1.when(true, () => S.decodeUnknownResult(PluginModuleSchema)(module).pipe(Result.map((pluginModule) => pluginModule.strykerPlugins))), Match$1.orElse(() => Result.succeed(void 0)));
+const moduleIgnorers = (module) => Match$1.value(Predicate$1.hasProperty(module, "strykerIgnorers")).pipe(Match$1.when(true, () => S.decodeUnknownResult(IgnorerModuleSchema)(module).pipe(Result.map((ignorerModule) => ignorerModule.strykerIgnorers))), Match$1.orElse(() => Result.succeed(void 0)));
+const moduleFrameworks = (module) => Match$1.value(Predicate$1.hasProperty(module, "strykerFrameworks")).pipe(Match$1.when(true, () => S.decodeUnknownResult(FrameworkModuleSchema)(module).pipe(Result.map((frameworkModule) => [...frameworkModule.strykerFrameworks]))), Match$1.orElse(() => Result.succeed(void 0)));
 const hasValidationSchemaContribution = (module) => S.is(SchemaValidationContributionSchema)(module);
 const moduleSchemaContribution = (module) => Option$1.getOrUndefined(Option$1.map(Option$1.liftPredicate(hasValidationSchemaContribution)(module), (guarded) => guarded.strykerValidationSchema));
 const pluginContributionsOf = (module) => Result.flatMap(moduleIgnorers(module), (ignorers) => Result.flatMap(moduleFrameworks(module), (frameworks) => Result.map(modulePluginContributions(module), (plugins) => ({
@@ -8293,34 +8361,34 @@ const hasContribution = (contributions) => [
 	contributions.frameworks,
 	contributions.schemaContribution
 ].some((contribution) => contribution !== void 0);
-const moduleFrameworkRefusalError = (descriptor, refusal) => Match.value(refusal.reason).pipe(Match.when("PeerMissing", () => PluginLoadRefusedError.make({
+const moduleFrameworkRefusalError = (descriptor, refusal) => Match$1.value(refusal.reason).pipe(Match$1.when("PeerMissing", () => PluginLoadRefusedError.make({
 	descriptor,
 	reason: {
 		_tag: "PeerMissing",
 		peer: refusal.peer
 	}
-})), Match.when("PeerVersionUnsupported", () => PluginLoadRefusedError.make({
+})), Match$1.when("PeerVersionUnsupported", () => PluginLoadRefusedError.make({
 	descriptor,
 	reason: {
 		_tag: "PeerVersionUnsupported",
 		peer: refusal.peer,
 		detail: refusal.detail
 	}
-})), Match.when("PeerUnrecognized", () => PluginLoadRefusedError.make({
+})), Match$1.when("PeerUnrecognized", () => PluginLoadRefusedError.make({
 	descriptor,
 	reason: {
 		_tag: "PeerUnrecognized",
 		peer: refusal.peer
 	}
-})), Match.exhaustive);
-const frameworkRefusalsOf = (descriptor, contributions) => Effect$1.forEach(contributions, (contribution) => Match.value(contribution).pipe(Match.when({ kind: "FrameworkRefusal" }, (refusal) => Effect$1.fail(moduleFrameworkRefusalError(descriptor, refusal))), Match.when({ kind: "Framework" }, (framework) => Effect$1.succeed(framework)), Match.exhaustive));
+})), Match$1.exhaustive);
+const frameworkRefusalsOf = (descriptor, contributions) => Effect$1.forEach(contributions, (contribution) => Match$1.value(contribution).pipe(Match$1.when({ kind: "FrameworkRefusal" }, (refusal) => Effect$1.fail(moduleFrameworkRefusalError(descriptor, refusal))), Match$1.when({ kind: "Framework" }, (framework) => Effect$1.succeed(framework)), Match$1.exhaustive));
 const warnUndescribedPluginModule = (descriptor) => Effect$1.logWarning(`Module "${descriptor}" did not contribute a StrykerJS plugin. It didn't export a "strykerPlugins", "strykerIgnorers", "strykerFrameworks", or "strykerValidationSchema".`).pipe(Effect$1.as(void 0));
 const describeLoadedPlugin = (descriptor, module) => Result.match(pluginContributionsOf(module), {
 	onFailure: (cause) => Effect$1.as(failPluginLoad(descriptor, invalidContribution(descriptor, cause)), Option$1.none()),
-	onSuccess: (contributions) => Match.value(hasContribution(contributions)).pipe(Match.when(true, () => Effect$1.map(frameworkRefusalsOf(descriptor, contributions.frameworks ?? []), (frameworks) => Option$1.some({
+	onSuccess: (contributions) => Match$1.value(hasContribution(contributions)).pipe(Match$1.when(true, () => Effect$1.map(frameworkRefusalsOf(descriptor, contributions.frameworks ?? []), (frameworks) => Option$1.some({
 		...contributions,
 		frameworks
-	}))), Match.orElse(() => Effect$1.as(warnUndescribedPluginModule(descriptor), Option$1.none())))
+	}))), Match$1.orElse(() => Effect$1.as(warnUndescribedPluginModule(descriptor), Option$1.none())))
 });
 const loadPlugin = Effect$1.fn("stryker.plugin_load.load_plugin")(function* (descriptor, entrypoint) {
 	yield* Effect$1.logDebug(`Loading plugin ${descriptor}`);
@@ -8339,7 +8407,7 @@ const parseAndDecodeManifest = S.decodeUnknownResult(S.fromJsonString(PackageMan
 const selectManifestFields = (specifier, fields) => Effect$1.flatMap(Effect$1.fromResult(selectPackageEntry(SelectPackageEntryCommand.make({
 	specifier,
 	manifest: fields
-}))), (decision) => Match.value(decision).pipe(Match.tag("PackageEntrySelected", (selected) => Effect$1.succeed(selected.entry)), Match.tag("PackageEntryUnresolved", (unresolved) => Effect$1.fail(importFailure(specifier, { cause: new Error(unresolved.reason) }))), Match.exhaustive));
+}))), (decision) => Match$1.value(decision).pipe(Match$1.tag("PackageEntrySelected", (selected) => Effect$1.succeed(selected.entry)), Match$1.tag("PackageEntryUnresolved", (unresolved) => Effect$1.fail(importFailure(specifier, { cause: new Error(unresolved.reason) }))), Match$1.exhaustive));
 const parsedManifestOf = (specifier, text) => Result.match(parseAndDecodeManifest(text), {
 	onFailure: () => Effect$1.fail(manifestRefusalOf(specifier)),
 	onSuccess: (fields) => selectManifestFields(specifier, fields)
@@ -8404,7 +8472,7 @@ const pluginUrlsFromOptions = (options) => [
 	...options.plugins,
 	...options.appendPlugins,
 	...options.ignorers,
-	...Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => [runner.plugin]), Match.when(isVmRunner, () => [vmRunnerPluginUrl()]), Match.orElse(() => [])),
+	...Match$1.value(options.testRunner).pipe(Match$1.when(Options_exports.isCustomTestRunner, (runner) => [runner.plugin]), Match$1.when(isVmRunner, () => [vmRunnerPluginUrl()]), Match$1.orElse(() => [])),
 	...options.checkers.map((checker) => checker.plugin)
 ];
 //#endregion
@@ -8471,8 +8539,8 @@ var KeepTempDirCommand = class extends S.TaggedClass()("KeepTempDirCommand", {
 }) {
 	static [Workflow.InstrumentationBrand] = {};
 };
-const keepOf = (failed) => Match.value(failed).pipe(Match.when(true, () => TempDirKept.make({})), Match.when(false, () => TempDirRemoved.make({})), Match.exhaustive, Result.succeed);
-const decide = (command) => Match.value(command.cleanTempDir).pipe(Match.tag("KeepTempDirAlways", () => Result.succeed(TempDirRemoved.make({}))), Match.tag("KeepTempDirOnFailure", (option) => keepOf(option.failed)), Match.exhaustive);
+const keepOf = (failed) => Match$1.value(failed).pipe(Match$1.when(true, () => TempDirKept.make({})), Match$1.when(false, () => TempDirRemoved.make({})), Match$1.exhaustive, Result.succeed);
+const decide = (command) => Match$1.value(command.cleanTempDir).pipe(Match$1.tag("KeepTempDirAlways", () => Result.succeed(TempDirRemoved.make({}))), Match$1.tag("KeepTempDirOnFailure", (option) => keepOf(option.failed)), Match$1.exhaustive);
 const keepTempDir = Workflow.make({
 	command: KeepTempDirCommand,
 	decision: S.Union([TempDirKept, TempDirRemoved]),
@@ -8482,12 +8550,12 @@ const keepTempDir = Workflow.make({
 //#endregion
 //#region src/Sandbox.service.ts
 const keepTempDirCommand = (exit, cleanTempDir) => KeepTempDirCommand.make({
-	cleanTempDir: Match.value(cleanTempDir).pipe(Match.when("always", () => KeepTempDirAlways.make({})), Match.orElse((onFailure) => KeepTempDirOnFailure.make({ failed: onFailure }))),
+	cleanTempDir: Match$1.value(cleanTempDir).pipe(Match$1.when("always", () => KeepTempDirAlways.make({})), Match$1.orElse((onFailure) => KeepTempDirOnFailure.make({ failed: onFailure }))),
 	failed: Exit.isFailure(exit)
 });
 const removesTempDir = (exit, cleanTempDir) => Result.match(keepTempDir(keepTempDirCommand(exit, cleanTempDir)), {
 	onFailure: () => false,
-	onSuccess: (decision) => Match.value(decision).pipe(Match.tag("TempDirRemoved", () => true), Match.tag("TempDirKept", () => false), Match.exhaustive)
+	onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("TempDirRemoved", () => true), Match$1.tag("TempDirKept", () => false), Match$1.exhaustive)
 });
 const removeEmptyParentDirectory = Effect$1.fn("stryker.sandbox.remove_empty_parent")(function* (parent, fs) {
 	const siblings = yield* fs.readDirectory(parent);
@@ -8580,7 +8648,7 @@ const planPrepare = Workflow.make({
 	command: PrepareDecoded,
 	decision: S.Union([HumanReporters$1, MachineReporters$1]),
 	error: S.Never,
-	decide: (decoded) => Match.value(decoded.mode).pipe(Match.when("human", () => Result.succeed(HumanReporters$1.make({ reporters: decoded.reporters }))), Match.when("machine", () => Result.succeed(MachineReporters$1.make({ reporters: decoded.reporters }))), Match.exhaustive)
+	decide: (decoded) => Match$1.value(decoded.mode).pipe(Match$1.when("human", () => Result.succeed(HumanReporters$1.make({ reporters: decoded.reporters }))), Match$1.when("machine", () => Result.succeed(MachineReporters$1.make({ reporters: decoded.reporters }))), Match$1.exhaustive)
 });
 //#endregion
 //#region src/run/plan-reporters.workflow.ts
@@ -8620,15 +8688,15 @@ const planReporters = Workflow.make({
 	command: ReporterPlanCommand,
 	decision: ReporterPlanDecision,
 	error: S.Never,
-	decide: (command) => Match.value(command.mode).pipe(Match.when("human", () => Result.succeed(HumanReporters.make({ reporters: [...humanReportersFrom(command.configured)] }))), Match.when("machine", () => Result.succeed(MachineReporters.make({ reporters: [...machineReportersFrom(command.configured)] }))), Match.exhaustive)
+	decide: (command) => Match$1.value(command.mode).pipe(Match$1.when("human", () => Result.succeed(HumanReporters.make({ reporters: [...humanReportersFrom(command.configured)] }))), Match$1.when("machine", () => Result.succeed(MachineReporters.make({ reporters: [...machineReportersFrom(command.configured)] }))), Match$1.exhaustive)
 });
 //#endregion
 //#region src/run/prepare.cell.ts
 const announceSummary = Effect$1.fn("stryker.prepare.announce-summary")(function* (input) {
-	yield* Match.value(input.env.resolvedMode.mode).pipe(Match.when("human", () => Boolean.match(input.env.allowConsoleColors, {
+	yield* Match$1.value(input.env.resolvedMode.mode).pipe(Match$1.when("human", () => Boolean.match(input.env.allowConsoleColors, {
 		onTrue: () => Console.log(`${AnsiCode.fields.green.literal}${input.summary}${AnsiCode.fields.reset.literal}`),
 		onFalse: () => Console.log(input.summary)
-	})), Match.orElse(() => Effect$1.logInfo(input.summary)));
+	})), Match$1.orElse(() => Effect$1.logInfo(input.summary)));
 });
 const NO_PLUGIN_DESCRIPTORS = [];
 const schemaPropertiesOf = (document) => Option$1.getOrElse(Option$1.fromNullishOr(document.properties), () => ({}));
@@ -8762,7 +8830,7 @@ const prepareCell = Sandwich.named("stryker.prepare")(readPrepare).decide(planPr
 });
 //#endregion
 //#region src/run/run-stages.cell.ts
-const configReadReasonOf = (cause) => Match.value(cause).pipe(Match.tag("ConfigError", (refused) => refused.message), Match.orElse(() => "Failed to read config"));
+const configReadReasonOf = (cause) => Match$1.value(cause).pipe(Match$1.tag("ConfigError", (refused) => refused.message), Match$1.orElse(() => "Failed to read config"));
 const mutationTestCell = Cell.andThen(Cell.andThen(Cell.andThen(Cell.mapError(loadConfigCell, (cause) => StageError.make({
 	stage: "prepare",
 	reason: configReadReasonOf(cause),