@systemfsoftware/stryker-js 5.0.0 → 6.0.0

package/dist/src-Bzh7ykDp.mjs

@@ -1,4724 +0,0 @@
-import { $ as PrepareError, D as layer, L as StrykerError, O as makeConcurrency, R as ALWAYS_IGNORE, T as IdGenerator, V as ConfigError, _ as validateOptions, a as loadPlugins, b as makeChildProcessTestRunner, et as StageError, h as readConfig, k as ChildProcessCrashedError, n as resolvePluginWorkerEntry, t as missingWorkerEntry, u as forkCoreSchema, v as buildTestRunner, w as makeWorkerClient, x as nodePlatformLayer, z as MUTATION_RANGE_REGEX } from "./plugin-worker-entry-DNu0SHO8.mjs";
-import { n as ansi, t as makeBuiltinReporterFactories } from "./builtin-reporters-wAuKFSsd.mjs";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import * as Stdio from "effect/Stdio";
-import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
-import { CheckerRpcs, DryRunCompleted, ExitClass, ExitClass as ExitClass$1, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterFailed, ReporterRpcs, StrykerOptionsSchema, TraceContextReference, formatTraceparent } from "@systemfsoftware/stryker-js-plugin-interface";
-import * as Clock from "effect/Clock";
-import * as Config from "effect/Config";
-import * as Context from "effect/Context";
-import * as DateTime from "effect/DateTime";
-import * as Fiber from "effect/Fiber";
-import * as Layer from "effect/Layer";
-import * as Match from "effect/Match";
-import * as Option from "effect/Option";
-import * as Queue from "effect/Queue";
-import * as Result from "effect/Result";
-import * as S from "effect/Schema";
-import * as Stream from "effect/Stream";
-import * as CliError from "effect/unstable/cli/CliError";
-import * as Runtime from "effect/Runtime";
-import { LocationSchema, Mutant, MutantStatusSchema, errorToString, normalizeFileName } from "@systemfsoftware/stryker-js-instrumenter/mutants";
-import * as Arr from "effect/Array";
-import "effect/Cause";
-import * as Console from "effect/Console";
-import * as Exit from "effect/Exit";
-import * as Formatter from "effect/Formatter";
-import * as Predicate from "effect/Predicate";
-import * as Scope from "effect/Scope";
-import * as Duration from "effect/Duration";
-import * as MutableHashMap from "effect/MutableHashMap";
-import * as MutableHashSet from "effect/MutableHashSet";
-import { Schema } from "effect";
-import * as HashMap from "effect/HashMap";
-import * as HashSet from "effect/HashSet";
-import { Minimatch, minimatch } from "minimatch";
-import { encodeWorkerOptions, partsOfEffectSpan } from "@systemfsoftware/stryker-js-plugin-runtime";
-import * as Ref from "effect/Ref";
-import * as ChildProcess from "effect/unstable/process/ChildProcess";
-import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
-import * as Data from "effect/Data";
-import { disableTypeChecks, instrument } from "@systemfsoftware/stryker-js-instrumenter";
-import * as Equivalence from "effect/Equivalence";
-import * as Pool from "effect/Pool";
-import * as Semaphore from "effect/Semaphore";
-import { randomBytes } from "@noble/hashes/utils.js";
-import { makeHtmlReporter } from "@systemfsoftware/stryker-js-html-reporter";
-//#region src/classify-run-outcome.workflow.ts
-var RunOutcomeCommand = class extends S.TaggedClass()("RunOutcomeCommand", {
-	succeeded: S.Boolean,
-	interrupted: S.Boolean,
-	helpErrorCount: S.optional(S.Finite),
-	cliError: S.Boolean,
-	unrecognized: S.optional(S.String),
-	survivorsReason: S.optional(S.Literals(["no-report", "mismatch"])),
-	survivorsDiagnostic: S.optional(S.String),
-	schemaError: S.Boolean,
-	successExitClass: S.optional(ExitClass),
-	highestExitClass: S.optional(ExitClass),
-	configDetail: S.optional(S.String),
-	diagnostic: S.optional(S.String)
-}) {};
-S.TaggedError()("RunExit", { code: S.Finite }), Runtime.errorExitCode;
-const CONFIG_CODE = 2;
-const classCode = (exitClass) => Match.value(exitClass).pipe(Match.when("VerdictFail", () => 1), Match.when("ConfigError", () => CONFIG_CODE), Match.when("RuntimeError", () => 3), Match.when("InternalError", () => 4), Match.exhaustive);
-const RunOutcomeTypeId = Symbol.for("@systemfsoftware/stryker-js/RunOutcome");
-var RunOk = class extends S.TaggedClass()("RunOk", { help: S.Boolean }) {
-	[RunOutcomeTypeId] = RunOutcomeTypeId;
-};
-var RunInterrupted = class extends S.TaggedError()("RunInterrupted", { code: S.Finite }) {
-	[RunOutcomeTypeId] = RunOutcomeTypeId;
-};
-var RunParseFailed = class extends S.TaggedClass()("RunParseFailed", { unrecognized: S.optional(S.String) }) {
-	[RunOutcomeTypeId] = RunOutcomeTypeId;
-};
-var RunSurvivorsRejected = class extends S.TaggedClass()("RunSurvivorsRejected", {
-	reason: S.Literals(["no-report", "mismatch"]),
-	diagnostic: S.optional(S.String)
-}) {
-	[RunOutcomeTypeId] = RunOutcomeTypeId;
-};
-var RunConfigFailed = class extends S.TaggedClass()("RunConfigFailed", { detail: S.optional(S.String) }) {
-	[RunOutcomeTypeId] = RunOutcomeTypeId;
-};
-var RunFailed$1 = class extends S.TaggedClass()("RunFailed", {
-	code: S.Finite,
-	diagnostic: S.optional(S.String)
-}) {
-	[RunOutcomeTypeId] = RunOutcomeTypeId;
-};
-const isSucceeded = (command) => command.succeeded;
-const isHelpRun = (command) => command.helpErrorCount !== void 0;
-const isSurvivorsRun = (command) => command.survivorsReason !== void 0;
-const isHighestClassed = (command) => command.highestExitClass !== void 0;
-const succeededOutcome = (command) => Option.match(Option.fromUndefinedOr(command.successExitClass), {
-	onNone: () => RunOk.make({ help: false }),
-	onSome: (exitClass) => RunFailed$1.make({
-		code: classCode(exitClass),
-		diagnostic: command.diagnostic
-	})
-});
-const helpOutcome = (command) => Match.value(command.helpErrorCount > 0).pipe(Match.when(true, () => RunParseFailed.make({ unrecognized: command.unrecognized })), Match.orElse(() => RunOk.make({ help: true })));
-const parseFailedOutcome = (command) => RunParseFailed.make({ unrecognized: command.unrecognized });
-const survivorsRejectedOutcome = (command) => RunSurvivorsRejected.make({
-	reason: command.survivorsReason,
-	diagnostic: command.survivorsDiagnostic
-});
-const configFailedOutcome = (command) => RunConfigFailed.make({ detail: command.configDetail });
-const classedOutcome = (command) => Match.value(command.highestExitClass).pipe(Match.when("ConfigError", () => RunConfigFailed.make({ detail: command.configDetail })), Match.orElse((exitClass) => RunFailed$1.make({
-	code: classCode(exitClass),
-	diagnostic: command.diagnostic
-})));
-const genericFailureOutcome = (command) => RunFailed$1.make({
-	code: 1,
-	diagnostic: command.diagnostic
-});
-function classify(command) {
-	return Match.value(command).pipe(Match.when(isSucceeded, succeededOutcome), Match.when((interrupted) => interrupted.interrupted, () => RunInterrupted.make({ code: 130 })), Match.when(isHelpRun, helpOutcome), Match.when((cliError) => cliError.cliError, parseFailedOutcome), Match.when(isSurvivorsRun, survivorsRejectedOutcome), Match.when((schemaError) => schemaError.schemaError, configFailedOutcome), Match.when(isHighestClassed, classedOutcome), Match.orElse(genericFailureOutcome));
-}
-Workflow.make(RunOutcomeCommand, (command) => Match.value(classify(command)).pipe(Match.tag("RunInterrupted", (error) => Result.fail(error)), Match.when((outcome) => !S.is(RunInterrupted)(outcome), (decision) => Result.succeed(decision)), Match.exhaustive));
-//#endregion
-//#region src/config-defaults.ts
-const isNonNullObject = (value) => typeof value === "object" && value !== null;
-const isArrayValue = (value) => Array.isArray(value);
-const freezeArrayValue = (value) => Object.freeze(value.map(deepFreeze));
-const freezeMapEntry = ([entryKey, entryValue]) => [deepFreeze(entryKey), deepFreeze(entryValue)];
-const freezeMapValue = (value) => Object.freeze(new Map([...value.entries()].map(freezeMapEntry)));
-const freezeSetValue = (value) => Object.freeze(new Set([...value.values()].map(deepFreeze)));
-const freezeRegExpValue = (value) => Object.freeze(value);
-const freezeRecordValue = (value) => Object.freeze(Object.entries(value).reduce((frozen, [property, propertyValue]) => {
-	frozen[property] = deepFreeze(propertyValue);
-	return frozen;
-}, {}));
-function deepFreeze(target) {
-	return Match.value(target).pipe(Match.when(isArrayValue, freezeArrayValue), Match.when((value) => value instanceof Map, freezeMapValue), Match.when((value) => value instanceof RegExp, freezeRegExpValue), Match.when((value) => value instanceof Set, freezeSetValue), Match.when(isNonNullObject, freezeRecordValue), Match.orElse(() => target));
-}
-const optionsPath = (...path) => path.join(".");
-const SUPPORTED_CONFIG_FILE_EXTENSIONS = [
-	".ts",
-	".mts",
-	".js",
-	".mjs"
-];
-const configFileNames = (extensions) => extensions.map((extension) => `stryker.config${extension}`);
-const SUPPORTED_CONFIG_FILE_NAMES = Object.freeze(configFileNames(SUPPORTED_CONFIG_FILE_EXTENSIONS));
-const RELATIVE_SPECIFIER_PREFIXES = [
-	"/",
-	"./",
-	"../",
-	"file://"
-];
-function isModuleSpecifier(value) {
-	return RELATIVE_SPECIFIER_PREFIXES.every((prefix) => value.startsWith(prefix) === false);
-}
-const CONFIG_SYNTAX_HELP = `
-Example of how a config file should look:
-/**
-  * @type {import('@systemfsoftware/stryker-js-plugin-interface').StrykerOptions}
-  */
-export default {
-  mutate: ['src/**/*.js'],
-  testRunner: 'vitest',
-  reporters: ['progress', 'clear-text', 'html'],
-  concurrency: 4
-};
-See https://stryker-mutator.io/docs/stryker-js/config-file for more information.`.trim();
-const createDefaultOptions = S.decodeEffect(StrykerOptionsSchema)({}).pipe(Effect.orDie);
-const defaultOptions = Effect.map(createDefaultOptions, (opts) => deepFreeze(opts));
-const scopedUnserializable = (scope) => (description) => ({
-	...description,
-	path: [scope, ...description.path]
-});
-const describeUnserializableChild = (child, scope) => Match.value(findUnserializables(child)).pipe(Match.when(void 0, () => []), Match.orElse((descriptions) => descriptions.map(scopedUnserializable(scope))));
-const collectUnserializables = (groups) => {
-	const found = groups.flat();
-	if (found.length > 0) return found;
-};
-const describeUnserializableArray = (value) => collectUnserializables(value.map((child, index) => describeUnserializableChild(child, index.toString())));
-const describeUnserializableRecord = (value) => collectUnserializables(Object.entries(value).map(([key, child]) => describeUnserializableChild(child, key)));
-const isPlainObjectValue = (value) => !Array.isArray(value) && value.constructor === Object;
-const classNameOf = (value) => Match.value(value.constructor).pipe(Match.when(Match.defined, (ctor) => ctor.name), Match.orElse(() => "Object"));
-const describeUnserializableInstance = (value) => [{
-	path: [],
-	reason: `Value is an instance of "${classNameOf(value)}", this detail will get lost in translation during serialization`
-}];
-const describeUnserializableObject = (value) => Match.value(value).pipe(Match.when(isArrayValue, describeUnserializableArray), Match.when(isPlainObjectValue, describeUnserializableRecord), Match.orElse(describeUnserializableInstance));
-const NON_JSON_PRIMITIVE_TYPES = [
-	"bigint",
-	"function",
-	"symbol"
-];
-const isNonJsonPrimitive = (value) => NON_JSON_PRIMITIVE_TYPES.includes(typeof value);
-const describeNonJsonPrimitive = (value) => [{
-	path: [],
-	reason: `Primitive type "${typeof value}" has no JSON representation`
-}];
-const describeNumber = (value) => {
-	if (isFinite(value)) return void 0;
-	return [{
-		reason: `Number value \`${value}\` has no JSON representation`,
-		path: []
-	}];
-};
-function findUnserializables(thing) {
-	return Match.value(thing).pipe(Match.when((value) => typeof value === "number", describeNumber), Match.when(isNonJsonPrimitive, describeNonJsonPrimitive), Match.when(isNonNullObject, describeUnserializableObject), Match.orElse(() => void 0));
-}
-function isWarningEnabled(warningType, warningOptions) {
-	if (typeof warningOptions === "boolean") return warningOptions;
-	else return warningOptions[warningType] === true;
-}
-//#endregion
-//#region src/admit-survivors-run.workflow.ts
-const MutantShape = S.Struct({
-	id: S.String,
-	fileName: S.String,
-	mutatorName: S.String,
-	replacement: S.String,
-	location: S.Struct({
-		start: S.Struct({
-			line: S.Finite,
-			column: S.Finite
-		}),
-		end: S.Struct({
-			line: S.Finite,
-			column: S.Finite
-		})
-	})
-});
-S.Struct({
-	config: S.optional(S.Record(S.String, S.Unknown)),
-	framework: S.optional(S.Struct({ version: S.optional(S.String) })),
-	files: S.Record(S.String, S.Struct({
-		source: S.String,
-		mutants: S.Array(S.Struct({
-			id: S.String,
-			mutatorName: S.String,
-			replacement: S.optional(S.String),
-			status: S.String,
-			location: S.Struct({
-				start: S.Struct({
-					line: S.Finite,
-					column: S.Finite
-				}),
-				end: S.Struct({
-					line: S.Finite,
-					column: S.Finite
-				})
-			})
-		}))
-	}))
-});
-const isArray = Array.isArray;
-const { entries: objectEntries, fromEntries: objectFromEntries, keys: objectKeys } = Object;
-const stringify = JSON.stringify;
-const SURVIVORS_RUN_FIRST_REMEDIATION = "run a full `stryker run` first, then re-run with --survivors";
-const SURVIVORS_BOOKKEEPING_KEYS = ["survivorsPriorReport"];
-function stripSurvivorsKeys(config) {
-	return objectFromEntries(objectEntries(config).filter(([key]) => !SURVIVORS_BOOKKEEPING_KEYS.includes(key)));
-}
-function wasProducedBySurvivorsRun(priorReport) {
-	return Option.exists(Option.liftPredicate(priorReport.config, Match.record), (config) => SURVIVORS_BOOKKEEPING_KEYS.some((bookkeeping) => bookkeeping in config));
-}
-function serializeSurvivorsHashInput(input) {
-	return stringify(sortKeys(input));
-}
-function sortKeys(value) {
-	return Match.value(value).pipe(Match.when(isArray, (many) => many.map((member) => sortKeys(member))), Match.when(Match.record, (named) => objectFromEntries(objectKeys(named).sort().map((key) => [key, sortKeys(named[key])]))), Match.orElse((leaf) => leaf));
-}
-var PriorReportFacts = class extends S.Class("PriorReportFacts")({
-	config: S.Record(S.String, S.Unknown),
-	frameworkVersion: S.UndefinedOr(S.String)
-}) {};
-var AdmitSurvivorsRunCommand = class extends S.Class("AdmitSurvivorsRunCommand")({
-	priorReport: S.UndefinedOr(PriorReportFacts),
-	currentConfig: S.Record(S.String, S.Unknown),
-	frameworkVersion: S.String,
-	sourceContentHashes: S.Record(S.String, S.String),
-	priorSourceHashes: S.Record(S.String, S.String),
-	priorSurvivors: S.Array(MutantShape)
-}) {};
-const NO_REPORT_DETAIL = "No prior mutation report found — a --survivors run needs the report of a previous run.";
-const SURVIVORS_RUN_SOURCE_DETAIL = "The prior mutation report was itself produced by a --survivors run, so it is not a valid input for another one.";
-const MISMATCH_DETAIL = "The prior mutation report does not match the current run (resolved options, framework version, or source content differ).";
-function hashesMatch(priorReport, input) {
-	return serializeSurvivorsHashInput({
-		resolvedOptions: stripSurvivorsKeys(priorReport.config),
-		frameworkVersion: priorReport.frameworkVersion,
-		sourceContentHashes: input.priorSourceHashes
-	}) === serializeSurvivorsHashInput({
-		resolvedOptions: stripSurvivorsKeys(input.currentConfig),
-		frameworkVersion: input.frameworkVersion,
-		sourceContentHashes: input.sourceContentHashes
-	});
-}
-const SurvivorsAdmissionTypeId = Symbol.for("@systemfsoftware/stryker-js/SurvivorsAdmission");
-var Admitted = class extends S.TaggedClass()("Admitted", { survivors: S.Array(MutantShape) }) {
-	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
-};
-var NoSurvivors = class extends S.TaggedClass()("NoSurvivors", {}) {
-	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
-};
-S.Union([Admitted, NoSurvivors]);
-var SurvivorsRejection = class extends S.TaggedError()("SurvivorsRejection", {
-	reason: S.Literals(["no-report", "mismatch"]),
-	remediation: S.String
-}) {
-	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
-};
-function reject(reason, detail) {
-	return Result.fail(SurvivorsRejection.make({
-		reason,
-		remediation: `${detail} ${SURVIVORS_RUN_FIRST_REMEDIATION}`
-	}));
-}
-/**
-* The closed set of admissions a command can name, before any of them is turned
-* into a decision. Deriving the variant first keeps the decision itself a total
-* dispatch over a type rather than a fallback over predicates.
-*/
-const PriorReportAbsentOutcome = S.TaggedStruct("PriorReportAbsent", {});
-const PriorReportIsSurvivorsRunOutcome = S.TaggedStruct("PriorReportIsSurvivorsRun", {});
-const NoSurvivorsFoundOutcome = S.TaggedStruct("NoSurvivorsFound", {});
-const PriorReportDriftedOutcome = S.TaggedStruct("PriorReportDrifted", {});
-const SurvivorsMatchOutcome = S.TaggedStruct("SurvivorsMatch", { survivors: S.Array(MutantShape) });
-S.Union([
-	PriorReportAbsentOutcome,
-	PriorReportIsSurvivorsRunOutcome,
-	NoSurvivorsFoundOutcome,
-	PriorReportDriftedOutcome,
-	SurvivorsMatchOutcome
-]);
-const ADMISSION_RULES = [
-	{
-		holds: (input) => input.priorReport === void 0,
-		outcome: PriorReportAbsentOutcome.make({})
-	},
-	{
-		holds: (input) => Option.exists(Option.fromUndefinedOr(input.priorReport), wasProducedBySurvivorsRun),
-		outcome: PriorReportIsSurvivorsRunOutcome.make({})
-	},
-	{
-		holds: (input) => input.priorSurvivors.length === 0,
-		outcome: NoSurvivorsFoundOutcome.make({})
-	},
-	{
-		holds: (input) => Option.exists(Option.fromUndefinedOr(input.priorReport), (facts) => !hashesMatch(facts, input)),
-		outcome: PriorReportDriftedOutcome.make({})
-	}
-];
-const admissionOutcomeOf = (input) => Option.getOrElse(Option.map(Arr.findFirst(ADMISSION_RULES, (rule) => rule.holds(input)), (rule) => rule.outcome), () => SurvivorsMatchOutcome.make({ survivors: input.priorSurvivors }));
-function decideAdmission(input) {
-	return Match.value(admissionOutcomeOf(input)).pipe(Match.tag("PriorReportAbsent", () => reject("no-report", NO_REPORT_DETAIL)), Match.tag("PriorReportIsSurvivorsRun", () => reject("mismatch", SURVIVORS_RUN_SOURCE_DETAIL)), Match.tag("NoSurvivorsFound", () => Result.succeed(NoSurvivors.make())), Match.tag("PriorReportDrifted", () => reject("mismatch", MISMATCH_DETAIL)), Match.tag("SurvivorsMatch", (matched) => Result.succeed(Admitted.make({ survivors: matched.survivors }))), Match.exhaustive);
-}
-Workflow.make(AdmitSurvivorsRunCommand, decideAdmission);
-//#endregion
-//#region src/exit-classification.ts
-const EXIT_CODE = {
-	VerdictFail: 1,
-	ConfigError: 2,
-	RuntimeError: 3,
-	InternalError: 4
-};
-function verdictExitClass(score, breakingThreshold) {
-	return Option.match(Option.all([Option.fromNullishOr(score), Option.fromNullishOr(breakingThreshold)]), {
-		onNone: () => null,
-		onSome: ([actual, threshold]) => Match.value(actual < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)
-	});
-}
-function resolveExitCode(pending, signal) {
-	return Match.value(signal).pipe(Match.when(null, () => Option.match(Option.fromNullishOr(highestExitClass(pending)), {
-		onNone: () => 0,
-		onSome: (highest) => EXIT_CODE[highest]
-	})), Match.orElse((present) => 128 + present));
-}
-function highestExitClass(pending) {
-	return [...pending].reduce((highest, candidate) => Option.match(Option.fromNullishOr(highest), {
-		onNone: () => candidate,
-		onSome: (current) => Match.value(EXIT_CODE[candidate] > EXIT_CODE[current]).pipe(Match.when(true, () => candidate), Match.when(false, () => current), Match.exhaustive)
-	}), null);
-}
-//#endregion
-//#region src/Envelope.ts
-function isExitClass(value) {
-	return S.is(ExitClass)(value);
-}
-Option.liftPredicate(isExitClass);
-Option.liftPredicate(Exit.isFailure);
-Option.liftPredicate(S.is(S.NonEmptyString));
-const PRIMITIVE_REFINEMENTS = [
-	Predicate.isString,
-	Predicate.isNumber,
-	Predicate.isBoolean,
-	Predicate.isBigInt,
-	Predicate.isSymbol
-];
-Predicate.some(PRIMITIVE_REFINEMENTS);
-const capturedConsoleChunks = [];
-const countByLabel = /* @__PURE__ */ new Map();
-const timeByLabel = /* @__PURE__ */ new Map();
-function inspectValue(value) {
-	if (typeof value === "string") return value;
-	return Formatter.format(value);
-}
-const PLACEHOLDER = /(%[sdijfopO%])/g;
-const PLACEHOLDER_PART = /^%[sdijfopO%]$/;
-function jsonArgumentText(argument) {
-	try {
-		return String(JSON.stringify(argument));
-	} catch {
-		return "[Circular]";
-	}
-}
-function placeholderText(placeholder, argument) {
-	return 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));
-}
-function appendLiteral(progress, literal) {
-	return {
-		args: progress.args,
-		cursor: progress.cursor,
-		text: progress.text + literal
-	};
-}
-function substitutePlaceholder(progress, placeholder) {
-	return Match.value(progress.cursor).pipe(Match.when((cursor) => cursor < progress.args.length, (cursor) => ({
-		args: progress.args,
-		cursor: cursor + 1,
-		text: progress.text + placeholderText(placeholder, progress.args[cursor])
-	})), Match.orElse(() => appendLiteral(progress, placeholder)));
-}
-function consumePlaceholder(progress, placeholder) {
-	return Match.value(placeholder).pipe(Match.when(Match.is("%%"), () => appendLiteral(progress, "%")), Match.orElse(() => substitutePlaceholder(progress, placeholder)));
-}
-function formatStep(progress, part) {
-	return Match.value(part).pipe(Match.when((candidate) => PLACEHOLDER_PART.test(candidate), (placeholder) => consumePlaceholder(progress, placeholder)), Match.orElse((literal) => appendLiteral(progress, literal)));
-}
-function formatTemplate(template, args) {
-	const progress = template.split(PLACEHOLDER).reduce(formatStep, {
-		args,
-		cursor: 0,
-		text: ""
-	});
-	const trailing = progress.args.slice(progress.cursor).map((argument) => ` ${inspectValue(argument)}`);
-	return progress.text + trailing.join("");
-}
-function isTextTemplate(args) {
-	return typeof args[0] === "string";
-}
-function formatArgs(args) {
-	return Match.value(args).pipe(Match.when(isTextTemplate, (values) => formatTemplate(values[0], values.slice(1))), Match.orElse((values) => values.map(inspectValue).join(" ")));
-}
-function captureSync(args) {
-	capturedConsoleChunks.push(formatArgs(args));
-}
-function captureAssert(condition, args) {
-	if (!condition) capturedConsoleChunks.push(`Assertion failed: ${formatArgs(args)}`);
-}
-const DEFAULT_CONSOLE_LABEL = "default";
-function consoleLabel(label) {
-	return Option.getOrElse(Option.fromNullishOr(label), () => DEFAULT_CONSOLE_LABEL);
-}
-function incrementCount(key) {
-	const next = Option.getOrElse(Option.fromNullishOr(countByLabel.get(key)), () => 0) + 1;
-	countByLabel.set(key, next);
-	return next;
-}
-function captureCount(label) {
-	const key = consoleLabel(label);
-	const next = incrementCount(key);
-	capturedConsoleChunks.push(`${key}: ${next}`);
-}
-function elapsedMs(started, nowNanos) {
-	return Number(nowNanos - started) / 1e6;
-}
-function captureTimeEnd(label, nowNanos) {
-	const key = consoleLabel(label);
-	const started = timeByLabel.get(key);
-	if (started !== void 0) {
-		timeByLabel.delete(key);
-		capturedConsoleChunks.push(`${key}: ${elapsedMs(started, nowNanos)}ms`);
-	}
-}
-function captureTimeLog(label, args, clock) {
-	const key = consoleLabel(label);
-	const started = timeByLabel.get(key);
-	if (started === void 0) return;
-	const elapsed = elapsedMs(started, clock.monotonicTimeNanosUnsafe());
-	const elapsedText = Match.value(args).pipe(Match.when((values) => values.length === 0, () => `${key}: ${elapsed}ms`), Match.orElse((values) => `${key}: ${elapsed}ms ${formatArgs(values)}`));
-	capturedConsoleChunks.push(elapsedText);
-}
-function captureTrace(args) {
-	capturedConsoleChunks.push(`Trace: ${formatArgs(args)}\n${(/* @__PURE__ */ new Error()).stack ?? ""}`);
-}
-const makeCapturingConsole = (clock) => ({
-	assert: (condition, ...args) => captureAssert(condition, args),
-	clear: () => {},
-	count: (label) => captureCount(label),
-	countReset: (label) => countByLabel.delete(consoleLabel(label)),
-	debug: (...args) => captureSync(args),
-	dir: (item, _options) => capturedConsoleChunks.push(Formatter.format(item)),
-	dirxml: (item) => capturedConsoleChunks.push(Formatter.format(item)),
-	error: (...args) => captureSync(args),
-	group: () => {},
-	groupCollapsed: () => {},
-	groupEnd: () => {},
-	info: (...args) => captureSync(args),
-	log: (...args) => captureSync(args),
-	table: (tabularData) => capturedConsoleChunks.push(Formatter.format(tabularData)),
-	time: (label) => timeByLabel.set(consoleLabel(label), clock.monotonicTimeNanosUnsafe()),
-	timeEnd: (label) => captureTimeEnd(label, clock.monotonicTimeNanosUnsafe()),
-	timeLog: (label, ...args) => captureTimeLog(label, args, clock),
-	trace: (...args) => captureTrace(args),
-	warn: (...args) => captureSync(args)
-});
-Layer.effect(Console.Console, Clock.clockWith((clock) => Effect.sync(() => {
-	resetCapturedConsole();
-	return makeCapturingConsole(clock);
-})));
-function resetCapturedConsole() {
-	capturedConsoleChunks.length = 0;
-	countByLabel.clear();
-	timeByLabel.clear();
-}
-//#endregion
-//#region src/resolve-output-mode.workflow.ts
-const TOOL_VARIABLES$1 = ["CLAUDECODE", "CODEX_SANDBOX"];
-var ResolveModeCommand = class extends S.TaggedClass()("ResolveModeCommand", {
-	stdoutIsTTY: S.Boolean,
-	text: S.optional(S.Boolean),
-	json: S.optional(S.Boolean),
-	envMode: S.optional(S.String),
-	agent: S.optional(S.String),
-	toolVars: S.optional(S.Record(S.String, S.String))
-}) {};
-const ResolveModeTypeId = Symbol.for("@systemfsoftware/stryker-js/ResolveMode");
-var ModeConflictError = class extends S.TaggedError()("ModeConflictError", {
-	option: S.String,
-	value: S.String,
-	expected: S.String
-}) {
-	[ResolveModeTypeId] = ResolveModeTypeId;
-};
-const ModeSignal$1 = S.Literals([
-	"flag",
-	"env",
-	"tty",
-	"agent",
-	"tool"
-]);
-var HumanOutput = class extends S.TaggedClass()("HumanOutput", {
-	signal: ModeSignal$1,
-	stdoutIsTTY: S.Boolean
-}) {
-	[ResolveModeTypeId] = ResolveModeTypeId;
-};
-var MachineOutput = class extends S.TaggedClass()("MachineOutput", {
-	signal: ModeSignal$1,
-	stdoutIsTTY: S.Boolean
-}) {
-	[ResolveModeTypeId] = ResolveModeTypeId;
-};
-const CONFLICT_EXPECTED = "the \"--format text\" and \"--json\" flags are mutually exclusive — use one or the other";
-const configured = (value) => Option.filter(Option.fromNullishOr(value), S.is(S.NonEmptyString));
-const modeFromEnv = (envMode, stdoutIsTTY) => Match.value(envMode).pipe(Match.when("machine", () => MachineOutput.make({
-	signal: "env",
-	stdoutIsTTY
-})), Match.orElse(() => HumanOutput.make({
-	signal: "env",
-	stdoutIsTTY
-})));
-const modeFromAgent = (command) => Option.match(configured(command.agent), {
-	onNone: () => modeFromTools(command),
-	onSome: () => MachineOutput.make({
-		signal: "agent",
-		stdoutIsTTY: true
-	})
-});
-const modeFromTools = (command) => Match.value(anyToolVariableSet(command.toolVars)).pipe(Match.when(true, () => MachineOutput.make({
-	signal: "tool",
-	stdoutIsTTY: true
-})), Match.orElse(() => HumanOutput.make({
-	signal: "tty",
-	stdoutIsTTY: true
-})));
-const anyToolVariableSet = (toolVars) => Option.match(Option.fromNullishOr(toolVars), {
-	onNone: () => false,
-	onSome: (named) => TOOL_VARIABLES$1.some((variable) => Option.isSome(configured(named[variable])))
-});
-const modeBelowEnv = (command) => Match.value(command.stdoutIsTTY).pipe(Match.when(false, () => MachineOutput.make({
-	signal: "tty",
-	stdoutIsTTY: false
-})), Match.orElse(() => modeFromAgent(command)));
-const modeFromEnvironment = (command) => Option.match(configured(command.envMode), {
-	onNone: () => modeBelowEnv(command),
-	onSome: (envMode) => modeFromEnv(envMode, command.stdoutIsTTY)
-});
-const decideMode = (command) => Match.value(command).pipe(Match.when({
-	text: true,
-	json: true
-}, () => Result.fail(ModeConflictError.make({
-	option: "json",
-	value: "text",
-	expected: CONFLICT_EXPECTED
-}))), Match.when({ text: true }, (texted) => Result.succeed(HumanOutput.make({
-	signal: "flag",
-	stdoutIsTTY: texted.stdoutIsTTY
-}))), Match.when({ json: true }, (jsoned) => Result.succeed(MachineOutput.make({
-	signal: "flag",
-	stdoutIsTTY: jsoned.stdoutIsTTY
-}))), Match.orElse((rest) => Result.succeed(modeFromEnvironment(rest))));
-const resolveOutputMode = Workflow.make(ResolveModeCommand, decideMode);
-//#endregion
-//#region src/RunEvent.schema.ts
-const RunPhase = S.Literals([
-	"prepare",
-	"instrument",
-	"dry-run",
-	"mutation-test"
-]);
-const OutputMode = S.Literals(["human", "machine"]);
-const ModeSignal = S.Literals([
-	"flag",
-	"env",
-	"tty",
-	"agent",
-	"tool"
-]);
-var RunStarted = class extends S.TaggedClass()("stream", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal
-}) {};
-var PhaseEntered = class extends S.TaggedClass()("phase", {
-	phase: RunPhase,
-	elapsedMs: S.Finite
-}) {};
-var PlanKnown = class extends S.TaggedClass()("plan", { total: S.Finite }) {};
-var RunMutantTested = class extends S.TaggedClass()("mutant", {
-	id: S.String,
-	status: MutantStatusSchema,
-	file: S.String,
-	location: LocationSchema,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	completed: S.Finite,
-	total: S.Finite
-}) {};
-var Heartbeat = class extends S.TaggedClass()("tick", {
-	elapsedMs: S.Finite,
-	completed: S.Finite,
-	total: S.NullOr(S.Finite)
-}) {};
-const VerdictThresholds = S.Struct({
-	high: S.Finite,
-	low: S.Finite,
-	break: S.NullOr(S.Finite)
-});
-const VerdictMutant = S.Struct({
-	id: S.String,
-	file: S.String,
-	location: LocationSchema,
-	mutator: S.String,
-	replacement: S.NullOr(S.String),
-	status: MutantStatusSchema
-});
-const VerdictCounts = S.Struct({
-	killed: S.Finite,
-	timeout: S.Finite,
-	survived: S.Finite,
-	noCoverage: S.Finite,
-	runtimeErrors: S.Finite,
-	compileErrors: S.Finite,
-	ignored: S.Finite,
-	pending: S.Finite
-});
-var VerdictReached = class extends S.TaggedClass()("verdict", {
-	schemaVersion: S.String,
-	runId: S.String,
-	mode: OutputMode,
-	signal: ModeSignal,
-	score: S.NullOr(S.Finite),
-	thresholds: VerdictThresholds,
-	reportFile: S.NullOr(S.String),
-	counts: VerdictCounts,
-	mutants: S.Array(VerdictMutant)
-}) {};
-var RunFailed = class extends S.TaggedClass()("error", {
-	schemaVersion: S.String,
-	code: S.Finite,
-	error: S.String,
-	remediation: S.String
-}) {};
-var HelpRendered = class extends S.TaggedClass()("help", {
-	schemaVersion: S.String,
-	code: S.Literals([0]),
-	help: S.String
-}) {};
-S.Union([
-	RunStarted,
-	PhaseEntered,
-	PlanKnown,
-	RunMutantTested,
-	Heartbeat,
-	VerdictReached,
-	RunFailed,
-	HelpRendered
-]);
-S.TaggedClass()("RunCommand", {
-	cliOptionsJson: S.String,
-	targetMutatePatterns: S.Array(S.String)
-});
-S.TaggedClass()("RunOutput", {
-	verdictJson: S.String,
-	exitCode: S.Finite
-});
-S.TaggedError()("RunDecodeError", { message: S.String });
-S.TaggedError()("RunReadError", { message: S.String });
-S.TaggedError()("RunWriteError", { message: S.String });
-S.TaggedClass()("PlanMutationRunCommand", {
-	configMutatePatterns: S.Array(S.String),
-	configMutatorNames: S.Array(S.String),
-	targetMutatePatterns: S.Array(S.String),
-	availableMutators: S.Array(S.String)
-});
-S.TaggedClass()("MutationRunPlan", {
-	mutatePatterns: S.Array(S.String),
-	mutatorNames: S.Array(S.String)
-});
-//#endregion
-//#region src/RunEvents.ts
-var RunEvents = class extends Context.Service()("@systemfsoftware/stryker-js/RunEvents") {};
-var RunIdentity = class extends Context.Service()("@systemfsoftware/stryker-js/RunEvents/RunIdentity") {};
-//#endregion
-//#region src/dry-run.workflow.ts
-var DryRunError = class extends S.TaggedError()("DryRunError", {
-	stage: S.Literals(["dryRun", "dryRunNoTests"]),
-	reason: S.String
-}) {};
-var DryRunCommand = class extends S.TaggedClass()("DryRunCommand", {
-	status: S.Literals([
-		"Complete",
-		"Error",
-		"Timeout"
-	]),
-	testCount: S.Finite,
-	failedTestCount: S.Finite,
-	allowEmpty: S.Boolean,
-	errorMessage: S.optional(S.String),
-	reason: S.optional(S.String)
-}) {};
-const DryRunDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/DryRunDecision");
-var DryRunPassed = class extends S.TaggedClass()("DryRunPassed", { testCount: S.Finite }) {
-	[DryRunDecisionTypeId] = DryRunDecisionTypeId;
-};
-var DryRunFailed = class extends S.TaggedClass()("DryRunFailed", {
-	testCount: S.Finite,
-	failedTestCount: S.Finite
-}) {
-	[DryRunDecisionTypeId] = DryRunDecisionTypeId;
-};
-const reasonOrDefault = (reason, fallback) => Option.getOrElse(() => fallback)(Option.fromUndefinedOr(reason));
-const hasFailedTests = (command) => command.failedTestCount > 0;
-const decideComplete = (command) => Match.value(command).pipe(Match.when({
-	testCount: 0,
-	allowEmpty: false
-}, () => Result.fail(DryRunError.make({
-	stage: "dryRunNoTests",
-	reason: "No tests were executed. Stryker will exit prematurely. Please check your configuration."
-}))), Match.when(hasFailedTests, () => Result.succeed(DryRunFailed.make({
-	testCount: command.testCount,
-	failedTestCount: command.failedTestCount
-}))), Match.orElse(() => Result.succeed(DryRunPassed.make({ testCount: command.testCount }))));
-const dryRun = Workflow.make(DryRunCommand, (command) => Match.value(command.status).pipe(Match.when("Error", () => Result.fail(DryRunError.make({
-	stage: "dryRun",
-	reason: reasonOrDefault(command.errorMessage, "Dry run error")
-}))), Match.when("Timeout", () => Result.fail(DryRunError.make({
-	stage: "dryRun",
-	reason: reasonOrDefault(command.reason, "Initial test run timed out")
-}))), Match.when("Complete", () => decideComplete(command)), Match.exhaustive));
-//#endregion
-//#region src/IncrementalDiff.paths.ts
-const REMEMBERED_REASON = "Remembered";
-const normalizeFileName$4 = (fileName) => fileName.replaceAll("\\", "/");
-const toRelativeNormalizedFileName = (fileName, basePath) => normalizeFileName$4(Match.value(fileName ?? "").pipe(Match.when((raw) => raw.startsWith(basePath), (raw) => raw.slice(basePath.length).replace(/^\/+/, "")), Match.orElse((raw) => raw)));
-//#endregion
-//#region src/IncrementalDiff.schema.ts
-const PositionSchema$1 = S.Struct({
-	line: S.Finite,
-	column: S.Finite
-});
-const PreviousLocationSchema = S.Struct({
-	start: PositionSchema$1,
-	end: PositionSchema$1
-});
-const PreviousMutantSchema = S.Struct({
-	mutatorName: S.String,
-	replacement: S.String,
-	location: PreviousLocationSchema,
-	status: S.String,
-	testsCompleted: S.optional(S.Finite),
-	coveredBy: S.optional(S.Array(S.String)),
-	killedBy: S.optional(S.Array(S.String))
-});
-const PreviousFileSchema = S.Struct({
-	source: S.optional(S.String),
-	mutants: S.optional(S.Array(PreviousMutantSchema))
-});
-const PreviousTestFileSchema = S.Struct({ source: S.optional(S.String) });
-const PreviousFilesSchema = S.Record(S.String, PreviousFileSchema);
-const PreviousTestFilesSchema = S.Record(S.String, PreviousTestFileSchema);
-const ZERO = 0;
-const firstDefined = (first, second) => Option.getOrElse(Option.fromNullishOr(first), () => second);
-const staticField = (isStatic) => Option.match(Option.fromUndefinedOr(isStatic), {
-	onNone: () => ({}),
-	onSome: (present) => ({ static: present })
-});
-const coveredByField = (coveredBy) => Option.match(Option.fromUndefinedOr(coveredBy), {
-	onNone: () => ({}),
-	onSome: (present) => ({ coveredBy: [...present] })
-});
-const testFilterField = (testFilter) => Option.match(Option.fromUndefinedOr(testFilter), {
-	onNone: () => ({}),
-	onSome: (present) => ({ testFilter: [...present] })
-});
-const staticCoverageCountOf = (staticCoverage, mutantId) => Option.getOrElse(Option.flatMap(Option.fromNullishOr(staticCoverage), (countsByMutantId) => Option.fromUndefinedOr(countsByMutantId[mutantId])), () => ZERO);
-const testsByIdOf = (result) => {
-	const testsById = MutableHashMap.empty();
-	for (const test of result.tests) MutableHashMap.set(testsById, test.id, test);
-	return testsById;
-};
-const addTestsForMutant = (testsByMutantId, mutantId, test) => {
-	const existing = MutableHashMap.get(testsByMutantId, mutantId);
-	const tests = Option.getOrElse(existing, () => MutableHashSet.empty());
-	MutableHashSet.add(tests, test);
-	if (Option.isNone(existing)) MutableHashMap.set(testsByMutantId, mutantId, tests);
-};
-const addTestCoverage = (testsByMutantId, test, coverage) => {
-	const coveredMutantIds = Object.entries(coverage).filter(([, count]) => count > ZERO).map(([mutantId]) => mutantId);
-	for (const mutantId of coveredMutantIds) addTestsForMutant(testsByMutantId, mutantId, test);
-};
-const testsByMutantIdOf = (mutantCoverage, testsById) => {
-	const testsByMutantId = MutableHashMap.empty();
-	for (const [testId, coverage] of Object.entries(mutantCoverage.perTest)) Option.match(MutableHashMap.get(testsById, testId), {
-		onNone: () => void 0,
-		onSome: (test) => addTestCoverage(testsByMutantId, test, coverage)
-	});
-	return testsByMutantId;
-};
-const addHits = (hitsByMutantId, coverage) => {
-	for (const [mutantId, count] of Object.entries(coverage)) {
-		const existing = Option.getOrElse(MutableHashMap.get(hitsByMutantId, mutantId), () => ZERO);
-		MutableHashMap.set(hitsByMutantId, mutantId, existing + count);
-	}
-};
-const hitsByMutantIdOf = (mutantCoverage) => {
-	const hitsByMutantId = MutableHashMap.empty();
-	const coverageByMutantId = [mutantCoverage.static, ...Object.values(mutantCoverage.perTest)];
-	for (const coverage of coverageByMutantId) addHits(hitsByMutantId, coverage);
-	return hitsByMutantId;
-};
-const testCoverageFrom = (result) => {
-	const testsById = testsByIdOf(result);
-	const mutantCoverage = Option.fromNullishOr(result.mutantCoverage);
-	return {
-		testsByMutantId: Option.match(mutantCoverage, {
-			onNone: () => MutableHashMap.empty(),
-			onSome: (coverage) => testsByMutantIdOf(coverage, testsById)
-		}),
-		testsById,
-		staticCoverage: Option.match(mutantCoverage, {
-			onNone: () => void 0,
-			onSome: (coverage) => coverage.static
-		}),
-		hitsByMutantId: Option.match(mutantCoverage, {
-			onNone: () => MutableHashMap.empty(),
-			onSome: (coverage) => hitsByMutantIdOf(coverage)
-		})
-	};
-};
-const calculateTotalTime = (testResults) => [...testResults].reduce((acc, test) => acc + test.timeSpentMs, 0);
-const toTestIds = (testResults) => {
-	const out = [];
-	for (const test of testResults) out.push(test.id);
-	return out;
-};
-const hasCoverageForPlan = (staticCoverage) => {
-	if (staticCoverage === void 0) return false;
-	return Object.keys(staticCoverage).length > 0;
-};
-const hasStaticCoverageForPlan = (staticCoverage, mutantId) => staticCoverageCountOf(staticCoverage, mutantId) > ZERO;
-const calculateTotalTimeForIds = (testIds, testTimeById) => testIds.reduce((acc, id) => {
-	const t = testTimeById[id];
-	if (t !== void 0) return acc + t;
-	return acc;
-}, 0);
-const getHitLimit = (hitCount) => {
-	if (hitCount === void 0) return;
-	return hitCount * 100;
-};
-const getMutantActivation = (testFilter) => {
-	if (testFilter !== void 0) return "runtime";
-	return "static";
-};
-const getCoveredBy = (mutant) => {
-	if (mutant.coveredBy === void 0) return;
-	return [...mutant.coveredBy];
-};
-const getTestFilter = (globalFilter) => {
-	if (globalFilter === void 0) return;
-	return [...globalFilter];
-};
-const toRunPlan = (mutant, command, netTime, testFilter, isStatic, coveredBy) => {
-	const timeout = command.options.timeoutFactor * netTime + command.options.timeoutMS + command.timeOverheadMS;
-	const hitLimit = getHitLimit(command.hitsByMutantId[mutant.id]);
-	const sandboxFileName = Option.getOrElse(Option.fromUndefinedOr(command.sandboxFileByName[mutant.fileName]), () => mutant.fileName);
-	const reloadEnvironment = Option.match(Option.fromUndefinedOr(testFilter), {
-		onNone: () => true,
-		onSome: () => isStatic !== false
-	});
-	return {
-		plan: "Run",
-		mutantId: mutant.id,
-		netTime,
-		runOptions: {
-			mutantActivation: getMutantActivation(testFilter),
-			timeout,
-			sandboxFileName,
-			disableBail: command.options.disableBail,
-			reloadEnvironment,
-			...testFilterField(testFilter),
-			...Option.match(Option.fromUndefinedOr(hitLimit), {
-				onNone: () => ({}),
-				onSome: (limit) => ({ hitLimit: limit })
-			})
-		},
-		...staticField(isStatic),
-		...coveredByField(coveredBy)
-	};
-};
-const toEarlyResultPlan = (mutant, isStatic, status, statusReason, coveredBy) => ({
-	plan: "EarlyResult",
-	mutantId: mutant.id,
-	status,
-	...Option.match(Option.fromUndefinedOr(firstDefined(statusReason, mutant.statusReason)), {
-		onNone: () => ({}),
-		onSome: (reason) => ({ statusReason: reason })
-	}),
-	...staticField(isStatic),
-	...coveredByField(coveredBy)
-});
-const planForStaticallyCovered = (mutant, command, isStatic) => {
-	const tests = Option.getOrElse(Option.fromUndefinedOr(command.testsByMutantId[mutant.id]), () => []);
-	const coveredBy = [...tests];
-	const ignoreStatic = command.options.ignoreStatic;
-	const useCovered = Match.value(isStatic).pipe(Match.when(false, () => true), Match.orElse(() => ignoreStatic && tests.length > ZERO));
-	return Match.value(useCovered).pipe(Match.when(true, () => toRunPlan(mutant, command, calculateTotalTimeForIds(tests, command.testTimeById), coveredBy, isStatic, coveredBy)), Match.orElse(() => Match.value(ignoreStatic).pipe(Match.when(true, () => toEarlyResultPlan(mutant, isStatic, "Ignored", "Static mutant (and \"ignoreStatic\" was enabled)", coveredBy)), Match.orElse(() => toRunPlan(mutant, command, command.timeSpentAllTests, getTestFilter(command.globalTestFilter), isStatic, coveredBy)))));
-};
-const decidePlanForMutant = (mutant, command) => {
-	const isStatic = hasStaticCoverageForPlan(command.staticCoverage, mutant.id);
-	return Option.match(Option.fromUndefinedOr(mutant.status), {
-		onSome: (status) => toEarlyResultPlan(mutant, isStatic, status, mutant.statusReason, getCoveredBy(mutant)),
-		onNone: () => Match.value(hasCoverageForPlan(command.staticCoverage)).pipe(Match.when(true, () => planForStaticallyCovered(mutant, command, isStatic)), Match.orElse(() => toRunPlan(mutant, command, command.timeSpentAllTests, getTestFilter(command.globalTestFilter), void 0, void 0)))
-	});
-};
-const planMutantTests = (command) => {
-	const plans = command.mutants.map((mutant) => decidePlanForMutant(mutant, command));
-	return {
-		plans,
-		totalNetTime: plans.reduce((acc, plan) => {
-			if (plan.plan === "Run") return acc + plan.netTime;
-			return acc;
-		}, 0)
-	};
-};
-const hitsRecordOf = (testCoverage) => {
-	const hitsByMutantId = {};
-	for (const [mutantId, hits] of testCoverage.hitsByMutantId) hitsByMutantId[mutantId] = hits;
-	return hitsByMutantId;
-};
-const testsByMutantIdRecordOf = (testCoverage) => {
-	const testsByMutantId = {};
-	for (const [mutantId, tests] of testCoverage.testsByMutantId) testsByMutantId[mutantId] = toTestIds(tests);
-	return testsByMutantId;
-};
-const testTimeRecordOf = (testCoverage) => {
-	const testTimeById = {};
-	for (const [id, result] of testCoverage.testsById) testTimeById[id] = result.timeSpentMs;
-	return testTimeById;
-};
-const coverageToCommand = (mutants, testCoverage, options, timeOverheadMS, globalTestFilter, sandboxFileByName) => ({
-	mutants: [...mutants],
-	timeOverheadMS,
-	timeSpentAllTests: calculateTotalTime(MutableHashMap.values(testCoverage.testsById)),
-	hitsByMutantId: hitsRecordOf(testCoverage),
-	testsByMutantId: testsByMutantIdRecordOf(testCoverage),
-	testTimeById: testTimeRecordOf(testCoverage),
-	options,
-	sandboxFileByName,
-	...Option.match(Option.fromUndefinedOr(testCoverage.staticCoverage), {
-		onNone: () => ({}),
-		onSome: (staticCoverage) => ({ staticCoverage })
-	}),
-	...testFilterField(globalTestFilter)
-});
-const materializeMutant = (original, decided) => {
-	const status = firstDefined(decided.status, original.status);
-	const statusReason = firstDefined(decided.statusReason, original.statusReason);
-	const isStatic = firstDefined(decided.static, original.static);
-	const coveredBy = firstDefined(decided.coveredBy, original.coveredBy);
-	return Mutant.make({
-		id: original.id,
-		fileName: original.fileName,
-		mutatorName: original.mutatorName,
-		replacement: original.replacement,
-		location: original.location,
-		...Option.match(Option.fromUndefinedOr(status), {
-			onNone: () => ({}),
-			onSome: (present) => ({ status: present })
-		}),
-		...Option.match(Option.fromUndefinedOr(statusReason), {
-			onNone: () => ({}),
-			onSome: (present) => ({ statusReason: present })
-		}),
-		...staticField(isStatic),
-		...coveredByField(coveredBy),
-		...Option.match(Option.fromUndefinedOr(original.testsCompleted), {
-			onNone: () => ({}),
-			onSome: (present) => ({ testsCompleted: present })
-		}),
-		...Option.match(Option.fromUndefinedOr(original.description), {
-			onNone: () => ({}),
-			onSome: (present) => ({ description: present })
-		})
-	});
-};
-const materializePlan = (plan, original) => {
-	if (plan.plan === "EarlyResult") return {
-		plan: "EarlyResult",
-		mutant: materializeMutant(original, plan)
-	};
-	const mutant = materializeMutant(original, plan);
-	return {
-		plan: "Run",
-		mutant,
-		netTime: plan.netTime,
-		runOptions: {
-			activeMutant: mutant,
-			mutantActivation: plan.runOptions.mutantActivation,
-			timeout: plan.runOptions.timeout,
-			sandboxFileName: plan.runOptions.sandboxFileName,
-			disableBail: plan.runOptions.disableBail,
-			reloadEnvironment: plan.runOptions.reloadEnvironment,
-			...testFilterField(plan.runOptions.testFilter),
-			...Option.match(Option.fromUndefinedOr(plan.runOptions.hitLimit), {
-				onNone: () => ({}),
-				onSome: (hitLimit) => ({ hitLimit })
-			})
-		}
-	};
-};
-const makeMutantTestPlanner = (command) => {
-	const { plans } = planMutantTests(command);
-	const byId = /* @__PURE__ */ new Map();
-	for (const mutant of command.mutants) byId.set(mutant.id, mutant);
-	return Effect.forEach(plans, (plan) => {
-		const original = byId.get(plan.mutantId);
-		if (original === void 0) return Effect.die(/* @__PURE__ */ new Error(`planner returned an unknown mutant id: ${plan.mutantId}`));
-		return Effect.succeed(materializePlan(plan, original));
-	});
-};
-const decidePlans = (mutants, testCoverage, options, timeOverheadMS, globalTestFilter, sandboxFileByName) => {
-	const command = coverageToCommand(mutants, testCoverage, options, timeOverheadMS, globalTestFilter, sandboxFileByName);
-	return makeMutantTestPlanner(command);
-};
-const REMEMBERED_STATUS = /* @__PURE__ */ new Set([
-	"Killed",
-	"Survived",
-	"Timeout",
-	"NoCoverage",
-	"Ignored"
-]);
-const normalizeDiffFileName = (fileName) => fileName.replaceAll("\\", "/");
-const toRelativeNormalized = (fileName, basePath) => {
-	const raw = Option.getOrElse(Option.fromUndefinedOr(fileName), () => "");
-	return Match.value(raw.startsWith(basePath)).pipe(Match.when(true, () => normalizeDiffFileName(raw.slice(basePath.length).replace(/^\/+/, ""))), Match.orElse(() => normalizeDiffFileName(raw)));
-};
-const mutantKeyOf = (mutatorName, replacement, start, end) => `${mutatorName}\u0000${replacement}\u0000${start.line}:${start.column}:${end.line}:${end.column}`;
-const currentMutantKey = (mutant) => mutantKeyOf(mutant.mutatorName, mutant.replacement, mutant.location.start, mutant.location.end);
-const previousMutantKey = (mutant) => mutantKeyOf(mutant.mutatorName, mutant.replacement, {
-	line: mutant.location.start.line - 1,
-	column: mutant.location.start.column - 1
-}, {
-	line: mutant.location.end.line - 1,
-	column: mutant.location.end.column - 1
-});
-const changedSourceFiles = (previousFiles, currentRelativeFiles) => Object.entries(previousFiles).filter(([name, previous]) => previous.source !== currentRelativeFiles[name]).map(([name]) => name);
-const changedTestFiles = (previousTestFiles, currentRelativeFiles, testIdsByRelativeFile) => Object.keys({
-	...previousTestFiles,
-	...testIdsByRelativeFile
-}).filter((name) => previousTestFiles[name]?.source !== currentRelativeFiles[name]);
-const NO_PREVIOUS_MUTANTS = [];
-const findRemembered = (previousFiles, file, key) => {
-	return Option.getOrElse(Option.flatMap(Option.fromUndefinedOr(previousFiles[file]), (record) => Option.fromUndefinedOr(record.mutants)), () => NO_PREVIOUS_MUTANTS).find((candidate) => previousMutantKey(candidate) === key);
-};
-const hasChangedCoverage = (mutantId, coveringTestFilesByMutantId, changedTests) => (coveringTestFilesByMutantId[mutantId] ?? []).some((file) => changedTests.includes(file));
-const isRememberable = (previous, mutant, input, file, changedFiles, changedTests) => Match.value(REMEMBERED_STATUS.has(previous.status)).pipe(Match.when(false, () => false), Match.orElse(() => Match.value(changedFiles.includes(file)).pipe(Match.when(true, () => false), Match.orElse(() => !hasChangedCoverage(mutant.id, input.coveringTestFilesByMutantId, changedTests)))));
-const decideForMutant = (mutant, input, changedFiles, changedTests) => {
-	const file = toRelativeNormalized(mutant.fileName, input.basePath);
-	const previous = findRemembered(input.previousFiles, file, currentMutantKey(mutant));
-	return Option.match(Option.filter(Option.fromUndefinedOr(previous), (candidate) => isRememberable(candidate, mutant, input, file, changedFiles, changedTests)), {
-		onNone: () => ({ kind: "run" }),
-		onSome: (present) => ({
-			kind: "remembered",
-			previous: present
-		})
-	});
-};
-const countBy = (files) => files.reduce((acc, file) => {
-	acc[file] = (acc[file] ?? 0) + 1;
-	return acc;
-}, {});
-const uniqueFiles = (files) => files.filter((file, index, all) => all.indexOf(file) === index);
-const countOf = (counts, file) => Option.getOrElse(Option.fromUndefinedOr(counts[file]), () => ZERO);
-const statisticsOf = (addedFiles, removedFiles) => {
-	const addedByFile = countBy(addedFiles);
-	const removedByFile = countBy(removedFiles);
-	const files = uniqueFiles([...Object.keys(addedByFile), ...Object.keys(removedByFile)]);
-	const changesByFile = {};
-	for (const file of files) changesByFile[file] = {
-		added: countOf(addedByFile, file),
-		removed: countOf(removedByFile, file)
-	};
-	return {
-		changesByFile,
-		total: files.reduce((acc, file) => ({
-			added: acc.added + countOf(addedByFile, file),
-			removed: acc.removed + countOf(removedByFile, file)
-		}), {
-			added: ZERO,
-			removed: ZERO
-		})
-	};
-};
-const testStatisticsOf = (previousTestFiles, testIdsByRelativeFile) => {
-	const added = Object.keys(testIdsByRelativeFile).filter((name) => previousTestFiles[name] === void 0);
-	const removed = Object.keys(previousTestFiles).filter((name) => testIdsByRelativeFile[name] === void 0);
-	return statisticsOf(added, removed);
-};
-const removedMutantFiles = (input, currentKeysByFile) => Object.entries(input.previousFiles).flatMap(([file, previous]) => {
-	const keys = currentKeysByFile[file];
-	return (previous.mutants ?? []).filter((candidate) => {
-		if (keys === void 0) return true;
-		return !keys.includes(previousMutantKey(candidate));
-	}).map(() => file);
-});
-const rememberedEntryOf = (mutant, previous) => ({
-	mutantId: mutant.id,
-	status: previous.status,
-	...Option.match(Option.fromUndefinedOr(previous.testsCompleted), {
-		onNone: () => ({}),
-		onSome: (testsCompleted) => ({ testsCompleted })
-	}),
-	...Option.match(Option.fromUndefinedOr(previous.coveredBy), {
-		onNone: () => ({}),
-		onSome: (coveredBy) => ({ coveredBy })
-	}),
-	...Option.match(Option.fromUndefinedOr(previous.killedBy), {
-		onNone: () => ({}),
-		onSome: (killedBy) => ({ killedBy })
-	})
-});
-const forcedDiff = (input) => {
-	const added = input.currentMutants.map((mutant) => toRelativeNormalizedFileName(mutant.fileName, input.basePath));
-	return {
-		mutants: [...input.currentMutants],
-		remembered: [],
-		mutantStatistics: statisticsOf(added, []),
-		testStatistics: testStatisticsOf(input.previousTestFiles, input.testIdsByRelativeFile)
-	};
-};
-const isRememberedEntry = (entry) => entry.decision.kind === "remembered";
-const splitMutants = (input, changedFiles, changedTests) => {
-	const decisions = input.currentMutants.map((mutant) => ({
-		mutant,
-		decision: decideForMutant(mutant, input, changedFiles, changedTests)
-	}));
-	const toRun = decisions.filter(({ decision }) => decision.kind === "run").map(({ mutant }) => mutant);
-	return {
-		toRun,
-		addedFiles: toRun.map((mutant) => toRelativeNormalizedFileName(mutant.fileName, input.basePath)),
-		remembered: decisions.filter(isRememberedEntry).map(({ mutant, decision }) => rememberedEntryOf(mutant, decision.previous))
-	};
-};
-const incrementalDiffOfChanges = (input) => {
-	const changedFiles = changedSourceFiles(input.previousFiles, input.currentRelativeFiles);
-	const changedTests = changedTestFiles(input.previousTestFiles, input.currentRelativeFiles, input.testIdsByRelativeFile);
-	const { toRun, addedFiles, remembered } = splitMutants(input, changedFiles, changedTests);
-	const currentKeysByFile = input.currentMutants.reduce((acc, mutant) => {
-		const file = toRelativeNormalizedFileName(mutant.fileName, input.basePath);
-		acc[file] = [...acc[file] ?? [], currentMutantKey(mutant)];
-		return acc;
-	}, {});
-	const removedFiles = removedMutantFiles(input, currentKeysByFile);
-	return {
-		mutants: toRun,
-		remembered,
-		mutantStatistics: statisticsOf(addedFiles, removedFiles),
-		testStatistics: testStatisticsOf(input.previousTestFiles, input.testIdsByRelativeFile)
-	};
-};
-const computeIncrementalDiff = (input) => Match.value(input.force).pipe(Match.when(true, () => forcedDiff(input)), Match.orElse(() => incrementalDiffOfChanges(input)));
-const previousFilesOf = (rawReport) => Match.value(rawReport).pipe(Match.when(Predicate.isObject, (report) => Option.getOrElse(Option.filter(Option.fromUndefinedOr(report["files"]), S.is(PreviousFilesSchema)), () => ({}))), Match.orElse(() => ({})));
-const previousTestFilesOf = (rawReport) => Match.value(rawReport).pipe(Match.when(Predicate.isObject, (report) => Option.getOrElse(Option.filter(Option.fromUndefinedOr(report["testFiles"]), S.is(PreviousTestFilesSchema)), () => ({}))), Match.orElse(() => ({})));
-const hasTestFileName = (result) => result.fileName !== void 0;
-const testIdsByRelativeFile = (testCoverage, basePath) => {
-	const byFile = {};
-	const located = [...MutableHashMap.values(testCoverage.testsById)].filter(hasTestFileName);
-	for (const result of located) {
-		const file = toRelativeNormalizedFileName(result.fileName, basePath);
-		const ids = Option.getOrElse(Option.fromUndefinedOr(byFile[file]), () => []);
-		ids.push(result.id);
-		byFile[file] = ids;
-	}
-	return byFile;
-};
-const coveredTestFiles = (tests, basePath) => {
-	const byFile = {};
-	const located = [...tests].filter(hasTestFileName);
-	for (const test of located) byFile[toRelativeNormalizedFileName(test.fileName, basePath)] = true;
-	return Object.keys(byFile);
-};
-const coveringTestFilesByMutantId = (testCoverage, basePath) => {
-	const byMutant = {};
-	for (const [mutantId, tests] of testCoverage.testsByMutantId) byMutant[mutantId] = coveredTestFiles(tests, basePath);
-	return byMutant;
-};
-const incrementalDiff = (input) => {
-	const output = computeIncrementalDiff({
-		basePath: input.basePath,
-		currentMutants: [...input.currentMutants],
-		previousFiles: previousFilesOf(input.incrementalReport),
-		previousTestFiles: previousTestFilesOf(input.incrementalReport),
-		currentRelativeFiles: input.currentRelativeFiles,
-		testIdsByRelativeFile: testIdsByRelativeFile(input.testCoverage, input.basePath),
-		coveringTestFilesByMutantId: coveringTestFilesByMutantId(input.testCoverage, input.basePath),
-		force: input.force ?? false
-	});
-	return {
-		mutants: output.mutants,
-		remembered: output.remembered,
-		mutantStatistics: {
-			changesByFile: MutableHashMap.fromIterable(Object.entries(output.mutantStatistics.changesByFile)),
-			total: output.mutantStatistics.total
-		},
-		testStatistics: {
-			changesByFile: MutableHashMap.fromIterable(Object.entries(output.testStatistics.changesByFile)),
-			total: output.testStatistics.total
-		}
-	};
-};
-const ReporterStageTypeId = Symbol.for("@systemfsoftware/stryker-js/ReporterStage");
-const carriesAttachments = (stage) => "attachments" in stage;
-const makeReporterStage = (attachments) => {
-	return {
-		[ReporterStageTypeId]: ReporterStageTypeId,
-		attachments
-	};
-};
-const stageAttachments = (stage) => {
-	if (!carriesAttachments(stage)) throw new Error("not a reporter stage constructed by attachReporterFactories");
-	return stage.attachments;
-};
-const isTerminalReportEvent = (event) => S.is(MutationTestReportReady)(event);
-const availableReporters = (available) => {
-	if (available.length === 0) return "(none)";
-	return available.join(", ");
-};
-const unknownReporterMessage = (unknown, available) => {
-	const quoted = unknown.map((name) => `"${name}"`).join(", ");
-	const candidates = availableReporters(available);
-	if (unknown.length > 1) return `Unknown reporters ${quoted}. Available reporters: ${candidates}.`;
-	return `Unknown reporter ${quoted}. Available reporters: ${candidates}.`;
-};
-const validateReporterNames = (configured, available) => {
-	const known = HashSet.fromIterable(available.map((name) => name.toLowerCase()));
-	const unknown = configured.filter((name) => !HashSet.has(known, name.toLowerCase()));
-	if (unknown.length === 0) return Effect.void;
-	return Effect.fail(ConfigError.make({ message: unknownReporterMessage(unknown, available) }));
-};
-const acquireReporterIterator = (events) => Effect.acquireRelease(Effect.sync(() => events[Symbol.asyncIterator]()), (iterator) => Effect.promise(() => Promise.resolve(iterator.return?.()).then(() => void 0)).pipe(Effect.ignore));
-const markDetachedEffect = (ports) => Effect.gen(function* () {
-	if (ports.latch.state === "terminal") return;
-	ports.latch.state = "detached";
-	yield* Queue.shutdown(ports.queue);
-	yield* Queue.shutdown(ports.inbox);
-});
-const pumpEmitter = (ports) => Stream.fromQueue(ports.inbox).pipe(Stream.runForEach((event) => Effect.asVoid(Queue.offer(ports.queue, event))), Effect.ensuring(Effect.asVoid(Queue.end(ports.queue))));
-const closedIteratorResult = {
-	done: true,
-	value: void 0
-};
-const declaresTerminalReport = (result) => {
-	if (result.done !== true) return isTerminalReportEvent(result.value);
-	return false;
-};
-const closeIterator = (iterator, value) => {
-	const finish = iterator.return?.bind(iterator);
-	return Match.value(finish).pipe(Match.when(void 0, () => Promise.resolve(closedIteratorResult)), Match.orElse((close) => close(value)));
-};
-const attachReporterFactories = (inputs, options, init) => Effect.forEach(inputs, (input) => Effect.gen(function* () {
-	const inbox = yield* Queue.bounded(256);
-	const queue = yield* Queue.bounded(256);
-	const latch = { state: "streaming" };
-	const events = Stream.toAsyncIterable(Stream.fromQueue(queue));
-	const iterator = yield* acquireReporterIterator(events);
-	const ports = {
-		inbox,
-		queue,
-		latch
-	};
-	const singleUse = { [Symbol.asyncIterator]: () => {
-		const observe = (result) => {
-			if (declaresTerminalReport(result)) latch.state = "terminal";
-			return result;
-		};
-		return {
-			next: () => iterator.next().then(observe),
-			return: (value) => closeIterator(iterator, value)
-		};
-	} };
-	const consumer = Effect.flatten(Effect.try({
-		try: () => input.factory(options, init)(singleUse),
-		catch: (reason) => new Data.Error(`Reporter "${input.name}" factory threw: ${String(reason)}`)
-	})).pipe(Effect.ensuring(markDetachedEffect(ports)));
-	const consumerFiber = yield* Effect.forkScoped(consumer);
-	const emitter = yield* Effect.forkScoped(pumpEmitter(ports));
-	return {
-		name: input.name,
-		inbox,
-		queue,
-		latch,
-		emitter,
-		consumer: consumerFiber
-	};
-})).pipe(Effect.map(makeReporterStage));
-const REPORTER_EVENT_BATCH_BOUND = 128;
-const workerStreamErrorOf = (cause) => ReporterFailed.make({
-	reporterName: "worker",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-});
-const reporterInitPayload = (init) => ({
-	...traceparentInit(init.traceparent),
-	...tracestateInit(init.tracestate)
-});
-const reporterWorkerFactory = (client) => (_options, init) => (events) => client.init(reporterInitPayload(init)).pipe(Effect.andThen(Stream.runForEach(Stream.grouped(Stream.fromAsyncIterable(events, workerStreamErrorOf), 128), (batch) => client.onEventBatch([...batch]))), Effect.andThen(client.flush()), Effect.mapError((cause) => ReporterFailed.make({
-	reporterName: "worker",
-	event: "mutationTestReportReady",
-	cause: errorToString(cause)
-})));
-const spawnReporterWorker = (params) => Effect.gen(function* () {
-	const optionsJson = yield* encodeWorkerOptions(params.options);
-	return yield* makeWorkerClient({
-		rpcs: ReporterRpcs,
-		entrypoint: params.entrypoint,
-		workingDirectory: params.projectBasePath,
-		execArgv: [...params.execArgv],
-		optionsJson,
-		tempDirPrefix: params.tempDirPrefix
-	});
-});
-const warnEventDropped = (attachment) => Effect.gen(function* () {
-	if (attachment.latch.state === "detached") return;
-	yield* Effect.logWarning(`Reporter "${attachment.name}" stream closed before an event could be delivered.`);
-});
-const REPORTER_STALL_TIMEOUT = Duration.seconds(30);
-const detachStalledReporter = (attachment) => Effect.logWarning(`Reporter "${attachment.name}" did not drain its events for ${Duration.toSeconds(REPORTER_STALL_TIMEOUT)} seconds and was detached; exit code unchanged.`).pipe(Effect.andThen(() => markDetachedEffect({
-	inbox: attachment.inbox,
-	queue: attachment.queue,
-	latch: attachment.latch
-})));
-const offerToInbox = (attachment, event) => Effect.gen(function* () {
-	const offered = yield* Queue.offer(attachment.inbox, event).pipe(Effect.timeoutOption(REPORTER_STALL_TIMEOUT));
-	return yield* Option.match(offered, {
-		onNone: () => detachStalledReporter(attachment),
-		onSome: (accepted) => Match.value(accepted).pipe(Match.when(true, () => Effect.void), Match.orElse(() => warnEventDropped(attachment)))
-	});
-});
-const deliverReporterEvent = (attachment, event) => Effect.gen(function* () {
-	if (attachment.latch.state === "detached") return;
-	yield* offerToInbox(attachment, event);
-});
-const offerReporterEvent = (stage, event) => Effect.forEach(stageAttachments(stage), (attachment) => deliverReporterEvent(attachment, event), { discard: true });
-const offerTerminalReport = (stage, report, metrics) => offerReporterEvent(stage, MutationTestReportReady.make({
-	report,
-	metrics
-}));
-const terminalDrainClass = (summary) => {
-	if (summary.terminalFailed.length > 0) return "RuntimeError";
-	return null;
-};
-const settleFailedAttachment = (attachment, cause) => Effect.gen(function* () {
-	if (attachment.latch.state === "terminal") {
-		yield* Effect.logError(`Reporter "${attachment.name}" failed while draining the terminal report.`).pipe(Effect.annotateLogs("cause", cause));
-		return {
-			kind: "terminal-failed",
-			name: attachment.name
-		};
-	}
-	yield* Effect.logWarning(`Reporter "${attachment.name}" failed before the terminal report and was detached; exit code unchanged.`).pipe(Effect.annotateLogs("cause", cause));
-	return {
-		kind: "detached",
-		name: attachment.name
-	};
-});
-const settleAttachment = (attachment) => Effect.gen(function* () {
-	const settled = yield* Effect.exit(Fiber.join(attachment.consumer)).pipe(Effect.timeoutOption(REPORTER_STALL_TIMEOUT));
-	return yield* Option.match(settled, {
-		onNone: () => Effect.logWarning(`Reporter "${attachment.name}" did not finish draining for ${Duration.toSeconds(REPORTER_STALL_TIMEOUT)} seconds and was detached; exit code unchanged.`).pipe(Effect.as({
-			kind: "detached",
-			name: attachment.name
-		})),
-		onSome: (exit) => Exit.match(exit, {
-			onSuccess: () => Effect.succeed({
-				kind: "completed",
-				name: attachment.name
-			}),
-			onFailure: (cause) => settleFailedAttachment(attachment, cause)
-		})
-	});
-});
-const failedReporterNames = (outcome) => {
-	if (outcome.kind === "terminal-failed") return [outcome.name];
-	return [];
-};
-const closeReporterStage = (stage) => Effect.gen(function* () {
-	const attachments = stageAttachments(stage);
-	yield* Effect.forEach(attachments, (attachment) => Queue.end(attachment.inbox), { discard: true });
-	yield* Effect.forEach(attachments, (attachment) => Effect.exit(Fiber.join(attachment.emitter)), { discard: true });
-	return { terminalFailed: (yield* Effect.forEach(attachments, settleAttachment, { concurrency: "unbounded" })).flatMap((outcome) => failedReporterNames(outcome)) };
-});
-const traceparentInit = (traceparent) => {
-	if (traceparent === void 0) return {};
-	return { traceparent };
-};
-const tracestateInit = (tracestate) => {
-	if (tracestate === void 0) return {};
-	return { tracestate };
-};
-const hasTraceFields = (init) => {
-	if (init.traceparent !== void 0) return true;
-	return init.tracestate !== void 0;
-};
-const initFromPhaseSpan = (span) => {
-	if (span === void 0) return void 0;
-	const parts = partsOfEffectSpan(span);
-	return {
-		traceparent: formatTraceparent(parts),
-		...tracestateInit(parts.traceState)
-	};
-};
-const environmentTraceInit = () => Effect.gen(function* () {
-	const traceparent = yield* Config.string("TRACEPARENT").pipe(Effect.option);
-	const tracestate = yield* Config.string("TRACESTATE").pipe(Effect.option);
-	return {
-		...traceparentInit(Option.getOrUndefined(traceparent)),
-		...tracestateInit(Option.getOrUndefined(tracestate))
-	};
-});
-const initFromEnvironment = () => Effect.map(environmentTraceInit(), (init) => {
-	if (!hasTraceFields(init)) return void 0;
-	return init;
-});
-const currentReporterInit = (span) => Effect.gen(function* () {
-	const fromEnvironment = yield* initFromEnvironment();
-	const current = Option.getOrUndefined(yield* Effect.currentSpan.pipe(Effect.option));
-	return [
-		initFromPhaseSpan(span),
-		initFromPhaseSpan(current),
-		fromEnvironment
-	].find(Predicate.isNotUndefined) ?? {};
-});
-const withPhaseSpan = (spanName, attributes, effect) => Effect.useSpan(spanName, { attributes }, (span) => effect(span).pipe(Effect.provideService(TraceContextReference, Option.some(partsOfEffectSpan(span)))));
-//#endregion
-//#region src/run/RunEnvironment.ts
-var RunEnvironment = class extends Context.Service()("@systemfsoftware/stryker-js/run/RunEnvironment") {};
-//#endregion
-//#region src/run/dry-run.cell.ts
-function buildDryRunFiles(prev) {
-	const files = [...MutableHashMap.keys(prev.project.filesToMutate)].map((name) => prev.sandbox.sandboxFileFor(name));
-	let testFiles;
-	if (prev.project.testFiles.length > 0) testFiles = prev.project.testFiles.map((file) => prev.sandbox.sandboxFileFor(file));
-	return {
-		files,
-		testFiles
-	};
-}
-const isCompleteDryRun = (result) => result.status === "complete";
-const isFailedDryRun = (result) => result.status === "error";
-const decodeCompleteDryRun = (result, allowEmpty) => Result.succeed(DryRunCommand.make({
-	status: "Complete",
-	testCount: result.tests.length,
-	failedTestCount: result.tests.filter((test) => test.status === "failed").length,
-	allowEmpty
-}));
-const decodeFailedDryRun = (result, allowEmpty) => Result.succeed(DryRunCommand.make({
-	status: "Error",
-	testCount: 0,
-	failedTestCount: 0,
-	allowEmpty,
-	errorMessage: result.errorMessage
-}));
-const decodeTimedOutDryRun = (result, allowEmpty) => Result.succeed(DryRunCommand.make({
-	status: "Timeout",
-	testCount: 0,
-	failedTestCount: 0,
-	allowEmpty,
-	...result.reason !== void 0 && { reason: result.reason }
-}));
-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.isString, (fileName) => ({
-	...test,
-	fileName: prev.sandbox.originalFileFor(fileName)
-})), Match.orElse(() => test));
-const withOriginalFileNames = (tests, prev) => tests.map((test) => withOriginalFileName(test, prev));
-const announceDryRunOutcome = (tests, prev, gross, overheadMillis) => Match.value(tests.length).pipe(Match.when(0, () => Effect.logInfo("No tests were found")), Match.orElse(() => Effect.logInfo(`Initial test run succeeded. Ran ${tests.length} tests in ${Duration.format(gross)} (net ${totalTestTime(tests)} ms, overhead ${overheadMillis} ms).`).pipe(Effect.andThen(Effect.when(Effect.logInfo("Note: running the dry-run only. No mutations will be tested."), Effect.succeed(prev.options.dryRunOnly))))));
-const completeDryRunPassed = (raw) => Effect.gen(function* () {
-	const prevDone = raw.prev;
-	const rawResult = raw.rawResult;
-	if (rawResult.status !== "complete") return yield* StageError.make({
-		stage: "dryRun",
-		reason: "Unexpected dry-run status after decision"
-	});
-	const tests = withOriginalFileNames(rawResult.tests, prevDone);
-	const dryRunResult = {
-		...rawResult,
-		tests,
-		status: "complete"
-	};
-	const overheadMillis = overheadMillisOf(Duration.toMillis(raw.gross), tests);
-	yield* offerReporterEvent(prevDone.reporterStage, DryRunCompleted.make({
-		timing: {
-			net: totalTestTime(tests),
-			overhead: overheadMillis
-		},
-		capabilities: { reloadEnvironment: raw.capabilities.reloadEnvironment },
-		testCount: tests.length,
-		tests: [...dryRunResult.tests]
-	})).pipe(Effect.ignoreCause);
-	yield* announceDryRunOutcome(tests, prevDone, raw.gross, overheadMillis);
-	return {
-		...prevDone,
-		dryRunResult,
-		testCoverage: testCoverageFrom(dryRunResult),
-		timeOverhead: Duration.millis(overheadMillis)
-	};
-});
-const dryRunCell = Cell.layer({
-	read: (command) => Effect.gen(function* () {
-		yield* Scope.Scope;
-		const idGenerator = yield* IdGenerator;
-		const { files, testFiles } = buildDryRunFiles(command);
-		const dryRunTimeout = command.options.dryRunTimeoutMinutes * 60 * 1e3;
-		yield* Effect.logInfo("Starting dry run");
-		const { rawResult, capabilities, gross } = yield* Effect.scoped(Effect.gen(function* () {
-			const childRunnerEffect = Effect.suspend(() => resolvePluginWorkerEntry({
-				loaded: command.loadedPlugins,
-				kind: "TestRunner",
-				name: command.options.testRunner
-			}).pipe(Effect.mapError(missingWorkerEntry("dryRun", "test runner", command.options.testRunner)), Effect.flatMap((runnerEntry) => makeChildProcessTestRunner({
-				options: command.options,
-				fileDescriptions: command.project.fileDescriptions,
-				sandboxWorkingDirectory: command.sandbox.workingDirectory,
-				workerEntrypoint: runnerEntry.entrypoint,
-				idGenerator
-			}))));
-			const runner = yield* buildTestRunner({
-				options: command.options,
-				fileDescriptions: command.project.fileDescriptions,
-				sandboxWorkingDirectory: command.sandbox.workingDirectory,
-				idGenerator,
-				retire: Effect.void,
-				testFiles: testFiles ?? []
-			}, childRunnerEffect);
-			const extra = Option.match(Option.fromUndefinedOr(testFiles), {
-				onNone: () => ({}),
-				onSome: (files) => ({ testFiles: files })
-			});
-			const timed = yield* Effect.timed(runner.dryRun({
-				timeout: dryRunTimeout,
-				coverageAnalysis: command.options.coverageAnalysis,
-				disableBail: command.options.disableBail,
-				files,
-				...extra
-			}).pipe(Effect.mapError((cause) => StageError.make({
-				stage: "dryRun",
-				reason: "Dry run failed",
-				cause
-			}))));
-			const gross = timed[0];
-			return {
-				rawResult: timed[1],
-				capabilities: yield* runner.capabilities.pipe(Effect.mapError((cause) => StageError.make({
-					stage: "dryRun",
-					reason: "Failed to get test runner capabilities",
-					cause
-				}))),
-				gross
-			};
-		})).pipe(Effect.mapError((cause) => {
-			if (S.is(StageError)(cause)) return cause;
-			return StageError.make({
-				stage: "dryRun",
-				reason: "Dry run failed to start test runner",
-				cause
-			});
-		}));
-		return {
-			prev: command,
-			rawResult,
-			capabilities,
-			gross
-		};
-	}),
-	decode: (raw) => Match.value(raw.rawResult).pipe(Match.when(isCompleteDryRun, (complete) => decodeCompleteDryRun(complete, raw.prev.options.allowEmpty)), Match.when(isFailedDryRun, (failed) => decodeFailedDryRun(failed, raw.prev.options.allowEmpty)), Match.orElse((timedOut) => decodeTimedOutDryRun(timedOut, raw.prev.options.allowEmpty))),
-	decide: dryRun,
-	encode: (outcome) => outcome,
-	write: (outcome, raw) => withPhaseSpan("dryRun", {}, () => Effect.gen(function* () {
-		const env = yield* RunEnvironment;
-		const now = yield* Clock.currentTimeMillis;
-		const queue = yield* RunEvents;
-		yield* Queue.offer(queue, PhaseEntered.make({
-			phase: "dry-run",
-			elapsedMs: now - env.runStartedAt
-		}));
-		const out = outcome;
-		if (Result.isFailure(out)) {
-			const err = out.failure;
-			return yield* StageError.make({
-				stage: err.stage,
-				reason: err.reason,
-				cause: err
-			});
-		}
-		return yield* Match.value(out.success).pipe(Match.tag("DryRunFailed", (decision) => Effect.fail(StageError.make({
-			stage: "dryRun",
-			reason: "There were failed tests in the initial test run.",
-			cause: decision
-		}))), Match.tag("DryRunPassed", () => completeDryRunPassed(raw)), Match.exhaustive);
-	}))
-});
-//#endregion
-//#region src/plan-instrumentation.workflow.ts
-var InstrumentError = class extends S.TaggedError()("InstrumentError", {
-	stage: S.Literal("instrument"),
-	reason: S.String
-}) {};
-var InstrumentCommand = class extends S.TaggedClass()("InstrumentCommand", {
-	fileCount: S.Finite,
-	inPlace: S.Boolean,
-	pluginCount: S.Finite
-}) {};
-const InstrumentDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/InstrumentDecision");
-var InPlaceInstrument = class extends S.TaggedClass()("InPlaceInstrument", {
-	workingDirectoryHint: S.String,
-	backupDirectoryHint: S.String,
-	fileCount: S.Finite
-}) {
-	[InstrumentDecisionTypeId] = InstrumentDecisionTypeId;
-};
-var EphemeralInstrument = class extends S.TaggedClass()("EphemeralInstrument", {
-	workingDirectoryHint: S.String,
-	fileCount: S.Finite
-}) {
-	[InstrumentDecisionTypeId] = InstrumentDecisionTypeId;
-};
-const planInstrumentation = Workflow.make(InstrumentCommand, (command) => Match.value(command).pipe(Match.when({ fileCount: 0 }, () => Result.fail(InstrumentError.make({
-	stage: "instrument",
-	reason: "No files to instrument."
-}))), Match.when({ inPlace: true }, () => Result.succeed(InPlaceInstrument.make({
-	workingDirectoryHint: "inPlace",
-	backupDirectoryHint: "backup",
-	fileCount: command.fileCount
-}))), Match.orElse(() => Result.succeed(EphemeralInstrument.make({
-	workingDirectoryHint: "temp",
-	fileCount: command.fileCount
-})))));
-//#endregion
-//#region src/IncrementalReport.schema.ts
-const PositionSchema = S.Struct({
-	line: S.Finite,
-	column: S.Finite
-});
-const LocationSchema$1 = S.Struct({
-	start: PositionSchema,
-	end: PositionSchema
-});
-const OpenEndLocationSchema = S.Struct({
-	start: PositionSchema,
-	end: S.optional(PositionSchema)
-});
-const MutantResultLikeSchema = S.Struct({
-	id: S.String,
-	mutatorName: S.String,
-	replacement: S.String,
-	location: LocationSchema$1,
-	status: S.Literals([
-		"Killed",
-		"Survived",
-		"NoCoverage",
-		"Timeout",
-		"CompileError",
-		"RuntimeError",
-		"Ignored",
-		"Pending"
-	]),
-	killedBy: S.optional(S.Array(S.String)),
-	coveredBy: S.optional(S.Array(S.String)),
-	static: S.optional(S.Boolean),
-	statusReason: S.optional(S.String),
-	testsCompleted: S.optional(S.Finite),
-	description: S.optional(S.String),
-	duration: S.optional(S.Finite)
-});
-const FileResultLikeSchema = S.Struct({
-	language: S.String,
-	source: S.String,
-	mutants: S.Array(MutantResultLikeSchema)
-});
-const TestDefinitionLikeSchema = S.Struct({
-	id: S.String,
-	name: S.String,
-	location: S.optional(OpenEndLocationSchema)
-});
-const TestFileLikeSchema = S.Struct({
-	source: S.optional(S.String),
-	tests: S.Array(TestDefinitionLikeSchema)
-});
-const ThresholdsLikeSchema = S.Struct({
-	high: S.Finite,
-	low: S.Finite
-});
-const IncrementalReportSchema = S.StructWithRest(S.Struct({
-	schemaVersion: S.String,
-	thresholds: ThresholdsLikeSchema,
-	files: S.Record(S.String, FileResultLikeSchema),
-	testFiles: S.optional(S.Record(S.String, TestFileLikeSchema))
-}), [S.Record(S.String, S.Unknown)]);
-var IncrementalReportError = class extends S.TaggedError()("IncrementalReportError", { message: S.String }) {};
-//#endregion
-//#region src/Project.ts
-const DEFAULT_GLOB$1 = "**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}";
-const normalizeFileName$3 = (fileName) => fileName.replace(/\\/g, "/");
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function consumeDoubleStar(pattern, index) {
-	if (pattern[index + 2] === "/") return {
-		consumed: 3,
-		output: "(?:.*\\/)?"
-	};
-	return {
-		consumed: 2,
-		output: ".*"
-	};
-}
-function consumeStar(pattern, index) {
-	if (pattern[index + 1] === "*") return consumeDoubleStar(pattern, index);
-	return {
-		consumed: 1,
-		output: "[^/]*"
-	};
-}
-function consumeBrace(pattern, index) {
-	const close = pattern.indexOf("}", index);
-	if (close === -1) return {
-		consumed: 1,
-		output: "\\{"
-	};
-	const escaped = pattern.slice(index + 1, close).split(",").map((part) => escapeRegExp(part));
-	return {
-		consumed: close - index + 1,
-		output: `(${escaped.join("|")})`
-	};
-}
-function consumeCharClass(pattern, index) {
-	const close = pattern.indexOf("]", index);
-	if (close === -1) return {
-		consumed: 1,
-		output: "\\["
-	};
-	return {
-		consumed: close - index + 1,
-		output: pattern.slice(index, close + 1)
-	};
-}
-function consumeGlobChar(pattern, index) {
-	const char = pattern[index];
-	return Match.value(char).pipe(Match.when("*", () => consumeStar(pattern, index)), Match.when("?", () => ({
-		consumed: 1,
-		output: "[^/]"
-	})), Match.when("{", () => consumeBrace(pattern, index)), Match.when("[", () => consumeCharClass(pattern, index)), Match.orElse(() => ({
-		consumed: 1,
-		output: escapeRegExp(Option.getOrElse(Option.fromUndefinedOr(char), () => ""))
-	})));
-}
-function globToRegExp(pattern) {
-	let index = 0;
-	let acc = "";
-	while (index < pattern.length) {
-		const step = consumeGlobChar(pattern, index);
-		acc += step.output;
-		index += step.consumed;
-	}
-	return new RegExp(`^${acc}$`);
-}
-function resolveAgainstBase(basePath, pattern) {
-	const normalized = normalizeFileName$3(pattern);
-	const base = trimTrailingSlashes(normalizeFileName$3(basePath));
-	return Match.value(normalized.startsWith("/")).pipe(Match.when(true, () => normalized), Match.orElse(() => Match.value(normalized.startsWith("./")).pipe(Match.when(true, () => `${base}/${normalized.slice(2)}`), Match.orElse(() => `${base}/${normalized}`))));
-}
-function trimTrailingSlashes(value) {
-	const trimmed = value.replace(/\/+$/, "");
-	return Match.value(trimmed.length === 0).pipe(Match.when(true, () => value.slice(0, 1)), Match.orElse(() => trimmed));
-}
-function globPatternOf(pattern) {
-	if (typeof pattern === "boolean") return Match.value(pattern).pipe(Match.when(true, () => DEFAULT_GLOB$1), Match.orElse(() => void 0));
-	return normalizeFileName$3(pattern);
-}
-function hasHiddenSegment(fileName, base) {
-	return Match.value(fileName.startsWith(base)).pipe(Match.when(true, () => fileName.slice(base.length)), Match.orElse(() => fileName)).split("/").some((segment) => segment.startsWith("."));
-}
-const isExcludedHiddenFile = (normalizedFile, base, allowHiddenFiles, patternHasDot) => Match.value(allowHiddenFiles).pipe(Match.when(true, () => false), Match.orElse(() => Match.value(hasHiddenSegment(normalizedFile, base)).pipe(Match.when(false, () => false), Match.orElse(() => !patternHasDot))));
-function createPureMatcher(pattern, allowHiddenFiles, basePath) {
-	const relative = globPatternOf(pattern);
-	if (relative === void 0) return () => false;
-	const regex = globToRegExp(resolveAgainstBase(basePath, relative));
-	const patternHasDot = relative.includes(".");
-	const base = `${trimTrailingSlashes(normalizeFileName$3(basePath))}/`;
-	return (fileName) => {
-		const normalizedFile = normalizeFileName$3(fileName);
-		return Match.value(isExcludedHiddenFile(normalizedFile, base, allowHiddenFiles, patternHasDot)).pipe(Match.when(true, () => false), Match.orElse(() => regex.test(normalizedFile)));
-	};
-}
-const rangeListOf = (mutate) => Option.filter(Option.fromUndefinedOr(mutate), Array.isArray);
-function unionPair(first, second) {
-	const ranges = Option.all([rangeListOf(first.mutate), rangeListOf(second.mutate)]);
-	return Option.match(ranges, {
-		onSome: ([firstRanges, secondRanges]) => ({ mutate: [...secondRanges, ...firstRanges] }),
-		onNone: () => Match.value(second.mutate).pipe(Match.when(true, () => ({ mutate: true })), Match.orElse(() => Match.value(first.mutate).pipe(Match.when(false, () => ({ mutate: second.mutate })), Match.orElse(() => ({ mutate: first.mutate })))))
-	});
-}
-function unionFileDescriptions(first, second) {
-	return Option.match(Option.fromUndefinedOr(second), {
-		onNone: () => first,
-		onSome: (defined) => unionPair(first, defined)
-	});
-}
-function overlapOf(firstRange, secondRange) {
-	const startLine = Math.max(firstRange.start.line, secondRange.start.line);
-	const endLine = Math.min(firstRange.end.line, secondRange.end.line);
-	const startColumn = Match.value(firstRange.start.line === startLine).pipe(Match.when(true, () => firstRange.start.column), Match.orElse(() => secondRange.start.column));
-	const endColumn = Match.value(firstRange.end.line === endLine).pipe(Match.when(true, () => firstRange.end.column), Match.orElse(() => secondRange.end.column));
-	return Match.value(startLine > endLine).pipe(Match.when(true, () => void 0), Match.orElse(() => ({
-		start: {
-			line: startLine,
-			column: startColumn
-		},
-		end: {
-			line: endLine,
-			column: endColumn
-		}
-	})));
-}
-const isLocation = (value) => value !== void 0;
-function overlapRanges(firstRanges, secondRanges) {
-	return firstRanges.flatMap((firstRange) => secondRanges.map((secondRange) => overlapOf(firstRange, secondRange))).filter(isLocation);
-}
-function intersectFileDescriptions(first, second) {
-	const ranges = Option.all([rangeListOf(first.mutate), rangeListOf(second.mutate)]);
-	return Option.match(ranges, {
-		onSome: ([firstRanges, secondRanges]) => ({ mutate: overlapRanges(firstRanges, secondRanges) }),
-		onNone: () => Match.value(first.mutate).pipe(Match.when(true, () => second), Match.orElse(() => Match.value(second.mutate).pipe(Match.when(true, () => first), Match.orElse(() => ({ mutate: false })))))
-	});
-}
-const rangeGroup = (match, index, fallback) => Option.getOrElse(Option.fromUndefinedOr(match[index]), () => fallback);
-function mutationRangeOf(mutatePattern) {
-	const match = MUTATION_RANGE_REGEX.exec(mutatePattern);
-	if (match === null) return;
-	const startLine = Number(rangeGroup(match, 3, "1"));
-	const startColumn = Number(rangeGroup(match, 4, "0"));
-	const endLine = Number(rangeGroup(match, 5, "1"));
-	const endColumn = Number(rangeGroup(match, 6, String(Number.MAX_SAFE_INTEGER)));
-	return {
-		pattern: rangeGroup(match, 1, mutatePattern),
-		mutate: [{
-			start: {
-				line: startLine - 1,
-				column: startColumn
-			},
-			end: {
-				line: endLine - 1,
-				column: endColumn
-			}
-		}]
-	};
-}
-function describeMatchingFiles(fileNames, pattern, mutate, basePath) {
-	const matches = createPureMatcher(pattern, false, basePath);
-	const entries = Array.from(fileNames).filter((fileName) => matches(fileName)).map((fileName) => [fileName, { mutate }]);
-	return HashMap.fromIterable(entries);
-}
-function filterMutatePatternPure(fileNames, mutatePattern, basePath) {
-	const range = Option.fromUndefinedOr(mutationRangeOf(mutatePattern));
-	return describeMatchingFiles(fileNames, Option.getOrElse(Option.map(range, (found) => found.pattern), () => mutatePattern), Option.getOrElse(Option.map(range, (found) => found.mutate), () => true), basePath);
-}
-function resolveFileDescriptionsPure(inputFileNames, mutatePatterns, targetMutatePatterns, basePath) {
-	const initial = HashMap.fromIterable(inputFileNames.map((name) => [name, { mutate: false }]));
-	const afterMutate = mutatePatterns.reduce((acc, pattern) => {
-		if (pattern.startsWith("!")) {
-			const withoutBang = pattern.substring(1);
-			const files = filterMutatePatternPure(HashMap.keys(acc), withoutBang, basePath);
-			return Array.from(HashMap.keys(files)).reduce((inner, fileName) => HashMap.set(inner, fileName, { mutate: false }), acc);
-		}
-		const files = filterMutatePatternPure(inputFileNames, pattern, basePath);
-		return HashMap.reduce(files, acc, (inner, file, fileName) => {
-			const existingOpt = HashMap.get(inner, fileName);
-			if (Option.isSome(existingOpt)) {
-				const existing = existingOpt.value;
-				return HashMap.set(inner, fileName, unionFileDescriptions(file, existing));
-			}
-			return HashMap.set(inner, fileName, unionFileDescriptions(file, void 0));
-		});
-	}, initial);
-	if (targetMutatePatterns !== void 0) {
-		const seen = targetMutatePatterns.reduce((acc, pattern) => {
-			const files = filterMutatePatternPure(HashMap.keys(afterMutate), pattern, basePath);
-			return HashMap.reduce(files, acc, (inner, description, fileName) => Option.match(HashMap.get(afterMutate, fileName), {
-				onNone: () => inner,
-				onSome: (current) => {
-					const intersected = intersectFileDescriptions(current, description);
-					const prevSeen = Option.getOrElse(HashMap.get(inner, fileName), () => void 0);
-					return HashMap.set(inner, fileName, unionFileDescriptions(intersected, prevSeen));
-				}
-			}));
-		}, HashMap.empty());
-		const final = HashMap.reduce(afterMutate, HashMap.empty(), (acc, _description, fileName) => {
-			const seenOpt = HashMap.get(seen, fileName);
-			if (Option.isSome(seenOpt)) {
-				const seenValue = seenOpt.value;
-				return HashMap.set(acc, fileName, seenValue);
-			}
-			return HashMap.set(acc, fileName, { mutate: false });
-		});
-		return Object.fromEntries(final);
-	}
-	return Object.fromEntries(afterMutate);
-}
-function resolveTestFilesPure(inputFileNames, testFilePatterns, basePath) {
-	if (testFilePatterns.length === 0) return [];
-	const allMatched = testFilePatterns.flatMap((pattern) => {
-		const matches = createPureMatcher(pattern, false, basePath);
-		return inputFileNames.filter((fileName) => matches(fileName));
-	});
-	return Array.from(HashSet.fromIterable(allMatched));
-}
-const selectFiles = (input) => ({
-	fileDescriptions: resolveFileDescriptionsPure(input.inputFileNames, input.mutatePatterns, input.targetMutatePatterns, input.basePath),
-	testFiles: resolveTestFilesPure(input.inputFileNames, input.testFilePatterns, input.basePath)
-});
-const toPosition = (position) => ({
-	line: position.line,
-	column: position.column
-});
-const toLocation = (location) => ({
-	start: toPosition(location.start),
-	end: toPosition(location.end)
-});
-const toOpenEndLocation = (location) => Option.match(Option.fromUndefinedOr(location.end), {
-	onNone: () => ({ start: toPosition(location.start) }),
-	onSome: (end) => ({
-		start: toPosition(location.start),
-		end: toPosition(end)
-	})
-});
-const withMappedMutantLocations = (report) => Object.fromEntries(Object.entries(report.files).map(([fileName, file]) => [fileName, {
-	...file,
-	mutants: file.mutants.map((mutant) => ({
-		...mutant,
-		location: toLocation(mutant.location)
-	}))
-}]));
-const withMappedTestLocations = (testFiles) => Object.fromEntries(Object.entries(testFiles).map(([fileName, file]) => [fileName, {
-	...file,
-	tests: file.tests.map((test) => Option.match(Option.fromUndefinedOr(test.location), {
-		onNone: () => ({ ...test }),
-		onSome: (location) => ({
-			...test,
-			location: toOpenEndLocation(location)
-		})
-	}))
-}]));
-const reshape = (decoded) => Option.match(Option.fromUndefinedOr(decoded.testFiles), {
-	onNone: () => ({
-		...decoded,
-		files: withMappedMutantLocations(decoded)
-	}),
-	onSome: (testFiles) => ({
-		...decoded,
-		files: withMappedMutantLocations(decoded),
-		testFiles: withMappedTestLocations(testFiles)
-	})
-});
-const decodeIncrementalReport = (raw) => Result.match(S.decodeUnknownResult(IncrementalReportSchema)(raw), {
-	onFailure: () => Result.fail(IncrementalReportError.make({ message: "The incremental report is not a mutation testing report; delete it or re-run without --incremental." })),
-	onSuccess: (decoded) => Result.succeed(reshape(decoded))
-});
-const parseJson = (text) => JSON.parse(text);
-const stringArrayEquivalence = Equivalence.Array(Equivalence.String);
-function makeProjectFile(name, mutate, content, originalContent) {
-	return {
-		name,
-		mutate,
-		content,
-		originalContent
-	};
-}
-function withContent(file, content) {
-	return {
-		...file,
-		content
-	};
-}
-function hasChanges(file) {
-	return file.content !== void 0 && file.content !== file.originalContent;
-}
-function toInstrumenterFile(file) {
-	return Effect.gen(function* () {
-		return {
-			content: yield* readContent(file),
-			mutate: file.mutate,
-			name: file.name
-		};
-	});
-}
-function readContent(file) {
-	const inMemory = Option.orElse(Option.fromUndefinedOr(file.content), () => Option.fromUndefinedOr(file.originalContent));
-	return Option.match(inMemory, {
-		onSome: (content) => Effect.succeed(content),
-		onNone: () => Effect.gen(function* () {
-			return yield* (yield* FileSystem.FileSystem).readFileString(file.name);
-		})
-	});
-}
-function readOriginal(file) {
-	return Effect.gen(function* () {
-		return yield* (yield* FileSystem.FileSystem).readFileString(file.name);
-	});
-}
-function writeInPlace(file) {
-	const content = Option.filter(Option.fromUndefinedOr(file.content), () => hasChanges(file));
-	return Option.match(content, {
-		onNone: () => Effect.void,
-		onSome: (text) => Effect.gen(function* () {
-			yield* (yield* FileSystem.FileSystem).writeFileString(file.name, text);
-		})
-	});
-}
-function writeToSandbox(file, sandboxDir, basePath) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const path = yield* Path.Path;
-		const relative = path.relative(basePath, file.name);
-		const targetFileName = path.join(sandboxDir, relative);
-		yield* fs.makeDirectory(path.dirname(targetFileName), { recursive: true });
-		const content = yield* readContent(file);
-		yield* fs.writeFileString(targetFileName, content);
-		return targetFileName;
-	});
-}
-function backupTo(file, backupDir, basePath) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const path = yield* Path.Path;
-		const relative = path.relative(basePath, file.name);
-		const backupFileName = path.join(backupDir, relative);
-		yield* fs.makeDirectory(path.dirname(backupFileName), { recursive: true });
-		const content = yield* readContent(file);
-		yield* fs.writeFileString(backupFileName, content);
-		return backupFileName;
-	});
-}
-function addProjectFile(files, filesToMutate, name, desc) {
-	const file = makeProjectFile(name, desc.mutate);
-	MutableHashMap.set(files, name, file);
-	Match.value(desc.mutate === false).pipe(Match.when(true, () => void 0), Match.orElse(() => MutableHashMap.set(filesToMutate, name, file)));
-}
-function makeProject(fileDescriptions, incrementalReport, testFiles = []) {
-	const files = MutableHashMap.empty();
-	const filesToMutate = MutableHashMap.empty();
-	Object.entries(fileDescriptions).forEach(([name, desc]) => addProjectFile(files, filesToMutate, name, desc));
-	return {
-		fileDescriptions,
-		incrementalReport,
-		testFiles,
-		files,
-		filesToMutate
-	};
-}
-function withFile(project, file) {
-	const files = MutableHashMap.fromIterable(project.files);
-	MutableHashMap.set(files, file.name, file);
-	const filesToMutate = MutableHashMap.fromIterable(project.filesToMutate);
-	if (file.mutate !== false) MutableHashMap.set(filesToMutate, file.name, file);
-	else MutableHashMap.remove(filesToMutate, file.name);
-	return {
-		...project,
-		files,
-		filesToMutate
-	};
-}
-function withInstrumentedFiles(project, instrumented) {
-	let next = project;
-	for (const { name, content } of instrumented) Option.match(MutableHashMap.get(next.files, name), {
-		onNone: () => void 0,
-		onSome: (existing) => {
-			next = withFile(next, withContent(existing, content));
-		}
-	});
-	return next;
-}
-const applyIgnoreRule = (included, negate, matches) => Match.value(negate).pipe(Match.when(included, () => included), Match.orElse(() => Match.value(matches()).pipe(Match.when(true, () => negate), Match.orElse(() => included))));
-function resolveInputFileNames(ignoreRules, basePath) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const pathService = yield* Path.Path;
-		const ignoreMatchers = ignoreRules.map((pattern) => new Minimatch(pattern, {
-			dot: true,
-			flipNegate: true,
-			nocase: true
-		}));
-		const matchesDirectoryPartially = (entryPath, rule) => rule.match(`/${entryPath}`, true) || rule.match(entryPath, true);
-		const matchesFile = (entryName, entryPath, rule) => [
-			entryName,
-			entryPath,
-			`/${entryPath}`
-		].some((candidate) => rule.match(candidate));
-		const matchesDirectoryTail = (entryPath, rule) => [rule.match(`/${entryPath}/`), rule.match(`${entryPath}/`)].some((matched) => matched);
-		const matchesNegatedDirectory = (entryPath, rule) => rule.negate && matchesDirectoryPartially(entryPath, rule);
-		const matchesDirectory = (entryName, entryPath, rule) => [
-			matchesFile(entryName, entryPath, rule),
-			matchesDirectoryTail(entryPath, rule),
-			matchesNegatedDirectory(entryPath, rule)
-		].some((matched) => matched);
-		const isIncluded = (name, entryPath, isDirectory) => ignoreMatchers.reduce((included, rule) => applyIgnoreRule(included, rule.negate, () => Match.value(isDirectory).pipe(Match.when(true, () => matchesDirectory(name, entryPath, rule)), Match.orElse(() => matchesFile(name, entryPath, rule)))), true);
-		const crawlDir = (dir, rootDir) => Effect.gen(function* () {
-			const entries = yield* fs.readDirectory(dir);
-			const relativeName = pathService.relative(rootDir, dir);
-			const filtered = (yield* Effect.forEach(entries, (name) => Effect.gen(function* () {
-				const full = pathService.join(dir, name);
-				return {
-					name,
-					full,
-					isDirectory: yield* fs.stat(full).pipe(Effect.map((info) => info.type === "Directory"), Effect.orElseSucceed(() => false)),
-					entryPath: `${(() => {
-						if (relativeName.length > 0) return `${relativeName}/`;
-						return "";
-					})()}${name}`
-				};
-			}), { concurrency: 256 })).filter(({ name, entryPath, isDirectory }) => isIncluded(name, entryPath, isDirectory));
-			return (yield* Effect.forEach(filtered, (entry) => {
-				if (entry.isDirectory) return crawlDir(entry.full, rootDir);
-				return Effect.succeed([entry.full]);
-			}, { concurrency: 256 })).flat();
-		});
-		return yield* crawlDir(basePath, basePath);
-	});
-}
-function parseIncrementalReport(contents) {
-	return Option.match(Option.fromUndefinedOr(contents), {
-		onNone: () => Effect.succeedNone,
-		onSome: (text) => Effect.gen(function* () {
-			const parsed = yield* Effect.try(() => parseJson(text));
-			const rawReport = yield* Effect.fromResult(decodeIncrementalReport(parsed));
-			const isMutationTestResult = (_value) => true;
-			if (!isMutationTestResult(rawReport)) throw new Error("Invalid incremental report shape");
-			return Option.fromUndefinedOr(rawReport);
-		})
-	});
-}
-function readIncrementalReport(incremental, incrementalFile) {
-	return Match.value(incremental).pipe(Match.when(false, () => Effect.succeedNone), Match.orElse(() => Effect.gen(function* () {
-		return yield* parseIncrementalReport(yield* (yield* FileSystem.FileSystem).readFileString(incrementalFile).pipe(Effect.catchTag("PlatformError", (error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect.logInfo(`No incremental result file found at ${incrementalFile}, a full mutation testing run will be performed.`).pipe(Effect.as(void 0))), Match.orElse(() => Effect.fail(error))))));
-	})));
-}
-function readProject(options, targetMutatePatterns, basePath) {
-	const { mutate, tempDirName, ignorePatterns, incremental, incrementalFile, progressStreamFile, htmlReporter, jsonReporter, testFiles } = options;
-	const mutatePatterns = mutate;
-	const testFilePatterns = testFiles;
-	const ignoreRules = [
-		...ALWAYS_IGNORE,
-		tempDirName,
-		incrementalFile,
-		progressStreamFile,
-		htmlReporter.fileName,
-		jsonReporter.fileName,
-		...ignorePatterns
-	];
-	return Effect.gen(function* () {
-		const inputFileNames = yield* resolveInputFileNames(ignoreRules, basePath);
-		const defaults = yield* defaultOptions;
-		const decision = selectFiles((() => {
-			if (targetMutatePatterns === void 0) return {
-				inputFileNames,
-				mutatePatterns,
-				testFilePatterns,
-				basePath
-			};
-			return {
-				inputFileNames,
-				mutatePatterns,
-				testFilePatterns,
-				basePath,
-				targetMutatePatterns
-			};
-		})());
-		if (!stringArrayEquivalence(mutatePatterns, defaults.mutate)) yield* Effect.forEach(mutatePatterns, (pattern) => Effect.gen(function* () {
-			const excluding = pattern.startsWith("!");
-			const inner = Match.value(excluding).pipe(Match.when(true, () => pattern.substring(1)), Match.orElse(() => pattern));
-			const probed = selectFiles({
-				inputFileNames,
-				mutatePatterns: [inner],
-				testFilePatterns: [],
-				basePath
-			});
-			if (Object.keys(probed.fileDescriptions).length > 0) return;
-			yield* Effect.logWarning(Match.value(excluding).pipe(Match.when(true, () => `Glob pattern "${pattern}" did not exclude any files.`), Match.orElse(() => `Glob pattern "${pattern}" did not result in any files.`)));
-		}));
-		yield* Effect.forEach(testFilePatterns, (pattern) => Effect.gen(function* () {
-			if (selectFiles({
-				inputFileNames,
-				mutatePatterns: [],
-				testFilePatterns: [pattern],
-				basePath
-			}).testFiles.length === 0) yield* Effect.logWarning(`Glob pattern "${pattern}" did not match any test files.`);
-		}));
-		const incrementalReport = yield* readIncrementalReport(incremental, incrementalFile);
-		return makeProject(decision.fileDescriptions, Option.getOrUndefined(incrementalReport), [...decision.testFiles]);
-	});
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@jsr+std__jsonc@1.0.2/node_modules/@jsr/std__jsonc/parse.js
-/**
-* Converts a JSON with Comments (JSONC) string into an object.
-*
-* @example Usage
-* ```ts
-* import { parse } from "@std/jsonc";
-* import { assertEquals } from "@std/assert";
-*
-* assertEquals(parse('{"foo": "bar"}'), { foo: "bar" });
-* assertEquals(parse('{"foo": "bar", }'), { foo: "bar" });
-* assertEquals(parse('{"foo": "bar", } /* comment *\/'), { foo: "bar" });
-* ```
-*
-* @throws {SyntaxError} If the JSONC string is invalid.
-* @param text A valid JSONC string.
-* @returns The parsed JsonValue from the JSONC string.
-*/ function parse(text) {
-	if (new.target) throw new TypeError("Cannot create an instance: parse is not a constructor");
-	return new JsoncParser(text).parse();
-}
-var JsoncParser = class {
-	#whitespace = /* @__PURE__ */ new Set(" 	\r\n");
-	#numberEndToken = /* @__PURE__ */ new Set([..."[]{}:,/", ...this.#whitespace]);
-	#text;
-	#length;
-	#tokenized;
-	constructor(text) {
-		this.#text = `${text}`;
-		this.#length = this.#text.length;
-		this.#tokenized = this.#tokenize();
-	}
-	parse() {
-		const token = this.#getNext();
-		const res = this.#parseJsonValue(token);
-		const { done, value } = this.#tokenized.next();
-		if (!done) throw new SyntaxError(buildErrorMessage(value));
-		return res;
-	}
-	/** Read the next token. If the token is read to the end, it throws a SyntaxError. */ #getNext() {
-		const { done, value } = this.#tokenized.next();
-		if (done) throw new SyntaxError("Cannot parse JSONC: unexpected end of JSONC input");
-		return value;
-	}
-	/** Split the JSONC string into token units. Whitespace and comments are skipped. */ *#tokenize() {
-		for (let i = 0; i < this.#length; i++) {
-			if (this.#whitespace.has(this.#text[i])) continue;
-			if (this.#text[i] === "/" && this.#text[i + 1] === "*") {
-				i += 2;
-				let hasEndOfComment = false;
-				for (; i < this.#length; i++) if (this.#text[i] === "*" && this.#text[i + 1] === "/") {
-					hasEndOfComment = true;
-					break;
-				}
-				if (!hasEndOfComment) throw new SyntaxError("Cannot parse JSONC: unexpected end of JSONC input");
-				i++;
-				continue;
-			}
-			if (this.#text[i] === "/" && this.#text[i + 1] === "/") {
-				i += 2;
-				for (; i < this.#length; i++) if (this.#text[i] === "\n" || this.#text[i] === "\r") break;
-				continue;
-			}
-			switch (this.#text[i]) {
-				case "{":
-					yield {
-						type: "BeginObject",
-						position: i
-					};
-					break;
-				case "}":
-					yield {
-						type: "EndObject",
-						position: i
-					};
-					break;
-				case "[":
-					yield {
-						type: "BeginArray",
-						position: i
-					};
-					break;
-				case "]":
-					yield {
-						type: "EndArray",
-						position: i
-					};
-					break;
-				case ":":
-					yield {
-						type: "NameSeparator",
-						position: i
-					};
-					break;
-				case ",":
-					yield {
-						type: "ValueSeparator",
-						position: i
-					};
-					break;
-				case "\"": {
-					const startIndex = i;
-					let shouldEscapeNext = false;
-					i++;
-					for (; i < this.#length; i++) {
-						if (this.#text[i] === "\"" && !shouldEscapeNext) break;
-						shouldEscapeNext = this.#text[i] === "\\" && !shouldEscapeNext;
-					}
-					yield {
-						type: "String",
-						sourceText: this.#text.substring(startIndex, i + 1),
-						position: startIndex
-					};
-					break;
-				}
-				default: {
-					const startIndex = i;
-					for (; i < this.#length; i++) if (this.#numberEndToken.has(this.#text[i])) break;
-					i--;
-					yield {
-						type: "NullOrTrueOrFalseOrNumber",
-						sourceText: this.#text.substring(startIndex, i + 1),
-						position: startIndex
-					};
-				}
-			}
-		}
-	}
-	#parseJsonValue(value) {
-		switch (value.type) {
-			case "BeginObject": return this.#parseObject();
-			case "BeginArray": return this.#parseArray();
-			case "NullOrTrueOrFalseOrNumber": return this.#parseNullOrTrueOrFalseOrNumber(value);
-			case "String": return this.#parseString(value);
-			default: throw new SyntaxError(buildErrorMessage(value));
-		}
-	}
-	#parseObject() {
-		const target = {};
-		while (true) {
-			const token1 = this.#getNext();
-			if (token1.type === "EndObject") return target;
-			if (token1.type !== "String") throw new SyntaxError(buildErrorMessage(token1));
-			const key = this.#parseString(token1);
-			const token2 = this.#getNext();
-			if (token2.type !== "NameSeparator") throw new SyntaxError(buildErrorMessage(token2));
-			const token3 = this.#getNext();
-			Object.defineProperty(target, key, {
-				value: this.#parseJsonValue(token3),
-				writable: true,
-				enumerable: true,
-				configurable: true
-			});
-			const token4 = this.#getNext();
-			if (token4.type === "EndObject") return target;
-			if (token4.type !== "ValueSeparator") throw new SyntaxError(buildErrorMessage(token4));
-		}
-	}
-	#parseArray() {
-		const target = [];
-		while (true) {
-			const token1 = this.#getNext();
-			if (token1.type === "EndArray") return target;
-			target.push(this.#parseJsonValue(token1));
-			const token2 = this.#getNext();
-			if (token2.type === "EndArray") return target;
-			if (token2.type !== "ValueSeparator") throw new SyntaxError(buildErrorMessage(token2));
-		}
-	}
-	#parseString(value) {
-		let parsed;
-		try {
-			parsed = JSON.parse(value.sourceText);
-		} catch {
-			throw new SyntaxError(buildErrorMessage(value));
-		}
-		if (typeof parsed !== "string") throw new TypeError(`Parsed value is not a string: ${parsed}`);
-		return parsed;
-	}
-	#parseNullOrTrueOrFalseOrNumber(value) {
-		if (value.sourceText === "null") return null;
-		if (value.sourceText === "true") return true;
-		if (value.sourceText === "false") return false;
-		let parsed;
-		try {
-			parsed = JSON.parse(value.sourceText);
-		} catch {
-			throw new SyntaxError(buildErrorMessage(value));
-		}
-		if (typeof parsed !== "number") throw new TypeError(`Parsed value is not a number: ${parsed}`);
-		return parsed;
-	}
-};
-function buildErrorMessage({ type, sourceText, position }) {
-	let token = "";
-	switch (type) {
-		case "BeginObject":
-			token = "{";
-			break;
-		case "EndObject":
-			token = "}";
-			break;
-		case "BeginArray":
-			token = "[";
-			break;
-		case "EndArray":
-			token = "]";
-			break;
-		case "NameSeparator":
-			token = ":";
-			break;
-		case "ValueSeparator":
-			token = ",";
-			break;
-		case "NullOrTrueOrFalseOrNumber":
-		case "String": token = 30 < sourceText.length ? `${sourceText.slice(0, 30)}...` : sourceText;
-	}
-	return `Cannot parse JSONC: unexpected token "${token}" in JSONC at position ${position}`;
-}
-//#endregion
-//#region src/file-matching.ts
-const DEFAULT_GLOB = "**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}";
-const normalizeFileName$2 = (fileName) => fileName.replace(/\\/g, "/");
-const normalizePattern = (pattern, pathService) => Match.value(pattern).pipe(Match.when(Match.string, (value) => normalizeFileName$2(pathService.resolve(value))), Match.when(true, () => DEFAULT_GLOB), Match.orElse(() => false));
-function createFileMatcher(pattern, pathService, allowHiddenFiles = true) {
-	return Match.value(normalizePattern(pattern, pathService)).pipe(Match.when(Match.string, (normalized) => (fileName) => minimatch(normalizeFileName$2(pathService.resolve(fileName)), normalized, { dot: allowHiddenFiles })), Match.orElse((normalized) => () => normalized));
-}
-function matchesFile(pattern, fileName, pathService, allowHiddenFiles = true) {
-	return createFileMatcher(pattern, pathService, allowHiddenFiles)(fileName);
-}
-Schema.TaggedError()("BuildCommandFailedError", {
-	command: Schema.String,
-	description: Schema.String,
-	cause: Schema.optional(Schema.Unknown)
-});
-Schema.TaggedError()("SpawnFailedError", {
-	command: Schema.String,
-	cause: Schema.Unknown
-});
-/**
-* Error returned when a tsconfig file fails to parse, or parses to a value that
-* does not match the shape this package consumes.
-*/
-var TsConfigParseError = class extends Schema.TaggedError()("TsConfigParseError", {
-	file: Schema.String,
-	reason: Schema.String,
-	exitClass: Schema.Literal("ConfigError")
-}) {};
-const JsonRecord = Schema.Record(Schema.String, Schema.Unknown);
-/**
-* The tsconfig shape this package reads and rewrites in the sandbox.
-*
-* The index signature keeps every key the schema does not declare — including
-* `compilerOptions` and `$schema` — so unknown keys survive the write-back untouched.
-* `S.mutableKey` keeps the fields the preprocessor rewrites writable (v4's `mutable`
-* only covers arrays), and `S.mutable` keeps the parsed arrays themselves mutable so
-* `TSConfigPreprocessor` can assign rewritten values back onto the config.
-*/
-const TsConfigSchema = Schema.StructWithRest(Schema.Struct({
-	extends: Schema.mutableKey(Schema.optional(Schema.Union([Schema.String, Schema.Array(Schema.String)]))),
-	references: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.StructWithRest(Schema.Struct({ path: Schema.mutableKey(Schema.String) }), [JsonRecord]))))),
-	files: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.String)))),
-	include: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.String)))),
-	exclude: Schema.mutableKey(Schema.optional(Schema.mutable(Schema.Array(Schema.String))))
-}), [JsonRecord]);
-/** A tsconfig `extends` entry list: the array form of `extends`. */
-const ExtendsArraySchema = Schema.Array(Schema.String);
-Schema.TaggedClass()("SandboxCommand", {
-	fileEntries: Schema.Array(Schema.Struct({
-		name: Schema.String,
-		hasChanges: Schema.Boolean
-	})),
-	basePath: Schema.String,
-	workingDirectory: Schema.String,
-	backupDirectory: Schema.String,
-	inPlace: Schema.Boolean
-});
-Schema.TaggedClass()("SandboxDecision", { entries: Schema.Array(Schema.Struct({
-	original: Schema.String,
-	target: Schema.String,
-	needsBackup: Schema.Boolean
-})) });
-//#endregion
-//#region src/Sandbox.ts
-const combinePreprocessors = (preprocessors) => (project) => Effect.forEach(preprocessors, (pre) => pre(project), { discard: true });
-const makeDisableTypeChecksPreprocessor = (options, impl) => (project) => Effect.gen(function* () {
-	const pathService = yield* Path.Path;
-	const matches = createFileMatcher(options.disableTypeChecks, pathService);
-	(yield* Effect.forEach([...project.files], ([name, file]) => Match.value(matches(pathService.resolve(name))).pipe(Match.when(true, () => Effect.gen(function* () {
-		const instrumenterFile = yield* toInstrumenterFile(file);
-		const content = yield* Effect.map(impl(instrumenterFile), (instrumented) => instrumented.content).pipe(Effect.mapError((cause) => StrykerError.make({
-			message: "disableTypeChecks failed",
-			cause
-		})), Effect.catch((_error) => Effect.gen(function* () {
-			if (isWarningEnabled("preprocessorErrors", options.warnings)) yield* Effect.logWarning(`Unable to disable type checking for file "${name}". Shouldn't type checking be disabled for this file? Consider configuring a more restrictive "${optionsPath("disableTypeChecks")}" settings (or turn it completely off with \`false\`)`);
-		})));
-		if (content !== void 0) return withContent(file, content);
-	})), Match.orElse(() => Effect.succeedNone)), { concurrency: 24 })).forEach(mergeUpdatedInto(project));
-});
-const mergeUpdatedFile = (project, updated) => {
-	const key = updated.name;
-	MutableHashMap.set(project.files, key, updated);
-	if (Option.isSome(MutableHashMap.get(project.filesToMutate, key))) MutableHashMap.set(project.filesToMutate, key, updated);
-};
-const updateOf = (updated) => Match.value(updated).pipe(Match.when(void 0, () => void 0), Match.when(Option.isOption, (option) => Option.getOrUndefined(option)), Match.orElse((file) => file));
-const mergeUpdatedInto = (project) => (updated) => {
-	const file = updateOf(updated);
-	if (file === void 0) return;
-	mergeUpdatedFile(project, file);
-};
-const tsConfigParseError = (file, reason) => TsConfigParseError.make({
-	file,
-	reason,
-	exitClass: "ConfigError"
-});
-const parseJsonText = (jsonText) => {
-	try {
-		return Result.succeed(parse(jsonText.replace(/^\uFEFF/, "")));
-	} catch (error) {
-		return Result.fail(errorToString(error));
-	}
-};
-const parseTsConfigShape = (fileName, parsed) => Match.value(parsed).pipe(Match.when(Schema.is(TsConfigSchema), (config) => Result.succeed(config)), Match.orElse(() => Result.fail(tsConfigParseError(fileName, `parsed to ${JSON.stringify(parsed)}, which does not match the tsconfig shape this package consumes`))));
-function parseTsConfig(fileName, jsonText) {
-	return Result.match(parseJsonText(jsonText), {
-		onFailure: (reason) => Result.fail(tsConfigParseError(fileName, reason)),
-		onSuccess: (parsed) => parseTsConfigShape(fileName, parsed)
-	});
-}
-const makeTSConfigPreprocessor = (options, basePath) => (project) => {
-	if (options.inPlace) return Effect.void;
-	const tryRewriteReference = (reference, originTSConfigFileName, pathService) => {
-		const fileName = pathService.resolve(pathService.dirname(originTSConfigFileName), reference);
-		if (pathService.relative(basePath, fileName).startsWith("..")) return [
-			"..",
-			"..",
-			normalizeFileName(reference)
-		].join("/");
-		return false;
-	};
-	const rewriteReferenceOrKeep = (reference, tsconfigFileName, pathService) => Match.value(tryRewriteReference(reference, tsconfigFileName, pathService)).pipe(Match.when(Predicate.isString, (rewritten) => rewritten), Match.orElse(() => reference));
-	const rewriteEntryAtIndex = (value, index, tsconfigFileName, pathService) => {
-		const entry = value[index];
-		if (typeof entry !== "string") return;
-		value[index] = rewriteReferenceOrKeep(entry, tsconfigFileName, pathService);
-	};
-	const rewriteFileArrayProperty = (config, tsconfigFileName, prop, pathService) => {
-		const value = config[prop];
-		if (Array.isArray(value)) value.forEach((_entry, index) => rewriteEntryAtIndex(value, index, tsconfigFileName, pathService));
-	};
-	const rewriteTSConfigFile = (tsconfigFileName, pathService) => {
-		const tsconfigFileOpt = MutableHashMap.get(project.files, tsconfigFileName);
-		if (Option.isNone(tsconfigFileOpt)) return Effect.void;
-		const tsconfigFile = tsconfigFileOpt.value;
-		return Effect.flatMap(readContent(tsconfigFile), (content) => Effect.flatMap(Effect.sync(() => parseTsConfig(tsconfigFileName, content)), (parsed) => {
-			if (Result.isSuccess(parsed)) {
-				const config = parsed.success;
-				return Effect.all([rewriteExtends(config, tsconfigFileName, pathService), rewriteProjectReferences(config, tsconfigFileName, pathService)], { discard: true }).pipe(Effect.flatMap(() => Effect.gen(function* () {
-					rewriteFileArrayProperty(config, tsconfigFileName, "include", pathService);
-					rewriteFileArrayProperty(config, tsconfigFileName, "exclude", pathService);
-					rewriteFileArrayProperty(config, tsconfigFileName, "files", pathService);
-					const content = yield* Schema.encodeEffect(Schema.fromJsonString(TsConfigSchema, { space: 2 }))(config).pipe(Effect.orDie);
-					Object.assign(tsconfigFile, { content });
-				})));
-			}
-			const reason = parsed.failure.reason;
-			return Effect.logWarning(`Could not rewrite tsconfig file "${tsconfigFileName}": ${reason}. Its extends, project references, and file array properties were not rewritten for the sandbox, so this file still points at paths outside it.`);
-		}));
-	};
-	const rewriteExtendsEntry = (config, extend, tsconfigFileName, pathService) => {
-		const rewritten = tryRewriteReference(extend, tsconfigFileName, pathService);
-		if (rewritten !== false) return Effect.succeed(rewritten);
-		return rewriteTSConfigFile(pathService.resolve(pathService.dirname(tsconfigFileName), extend), pathService).pipe(Effect.as(extend));
-	};
-	const rewriteSingleExtends = (config, extend, tsconfigFileName, pathService) => Effect.flatMap(rewriteExtendsEntry(config, extend, tsconfigFileName, pathService), (rewritten) => {
-		config.extends = rewritten;
-		return Effect.void;
-	});
-	const rewriteExtendsArray = (config, extendEntries, tsconfigFileName, pathService) => Effect.forEach(extendEntries, (entry) => rewriteExtendsEntry(config, entry, tsconfigFileName, pathService)).pipe(Effect.flatMap((rewritten) => {
-		config.extends = rewritten;
-		return Effect.void;
-	}));
-	const rewriteExtends = (config, tsconfigFileName, pathService) => Match.value(config.extends).pipe(Match.when(Predicate.isString, (extend) => rewriteSingleExtends(config, extend, tsconfigFileName, pathService)), Match.when(Schema.is(ExtendsArraySchema), (extendEntries) => rewriteExtendsArray(config, extendEntries, tsconfigFileName, pathService)), Match.orElse(() => Effect.void));
-	const referencedTsConfigPath = (referencePath) => Match.value(referencePath.endsWith(".json")).pipe(Match.when(true, () => referencePath), Match.orElse(() => `${referencePath}/tsconfig.json`));
-	const rewriteReference = (ref, originTSConfigFileName, pathService) => Match.value(tryRewriteReference(ref.path, originTSConfigFileName, pathService)).pipe(Match.when(Predicate.isString, (rewritten) => {
-		ref.path = rewritten;
-		return Effect.void;
-	}), Match.orElse(() => rewriteTSConfigFile(pathService.resolve(pathService.dirname(originTSConfigFileName), referencedTsConfigPath(ref.path)), pathService)));
-	const rewriteProjectReferences = (config, originTSConfigFileName, pathService) => {
-		const references = config.references;
-		if (!references) return Effect.void;
-		return Effect.forEach(references, (ref) => rewriteReference(ref, originTSConfigFileName, pathService)).pipe(Effect.asVoid);
-	};
-	return Effect.gen(function* () {
-		const pathService = yield* Path.Path;
-		return yield* rewriteTSConfigFile(pathService.resolve(options.tsconfigFile), pathService);
-	});
-};
-const createPreprocessor = (options, basePath) => combinePreprocessors([makeDisableTypeChecksPreprocessor(options, disableTypeChecks), makeTSConfigPreprocessor(options, basePath)]);
-var TemporaryDirectory = class extends Context.Service()("@systemfsoftware/stryker-js/Sandbox/TemporaryDirectory") {};
-const removesTempDir = (exit, cleanTempDir) => Exit.isSuccess(exit) || cleanTempDir === "always";
-const removeEmptyParentDirectory = (parent, fs) => Effect.gen(function* () {
-	if ((yield* fs.readDirectory(parent)).length === 0) yield* fs.remove(parent, {
-		recursive: true,
-		force: true
-	});
-});
-const removeTempDirectory = (tmp, parent, fs) => Effect.gen(function* () {
-	yield* Effect.logDebug(`Deleting stryker temp directory ${tmp}`);
-	yield* fs.remove(tmp, {
-		recursive: true,
-		force: true
-	});
-	if (yield* fs.exists(parent)) yield* removeEmptyParentDirectory(parent, fs);
-});
-const TemporaryDirectoryLive = (options) => Layer.effect(TemporaryDirectory, Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const parent = (yield* Path.Path).resolve(options.tempDirName);
-	yield* fs.makeDirectory(parent, { recursive: true });
-	let prefix = "sandbox-";
-	if (options.inPlace) prefix = "backup-";
-	const tmp = yield* fs.makeTempDirectory({
-		directory: parent,
-		prefix
-	});
-	yield* Effect.logDebug(`Using temp directory "${tmp}"`);
-	yield* Effect.addFinalizer((exit) => Effect.gen(function* () {
-		if (removesTempDir(exit, options.cleanTempDir)) {
-			yield* removeTempDirectory(tmp, parent, fs);
-			return;
-		}
-		yield* Effect.logDebug("Not removing the temp dir because an error occurred");
-	}).pipe(Effect.orDie));
-	return { path: tmp };
-}));
-const toFileMap = (entries) => new Map(entries);
-const directoryChain = (from, pathService) => {
-	const parent = pathService.dirname(from);
-	if (parent === from) return [from];
-	return [from, ...directoryChain(parent, pathService)];
-};
-const binDirectoriesFrom = (from, pathService) => directoryChain(pathService.resolve(from), pathService).map((directory) => pathService.join(directory, "node_modules", ".bin"));
-const inheritedPath = () => Config.string("PATH").pipe(Effect.option, Effect.map((value) => Option.getOrUndefined(value) ?? ""));
-const failOnBuildFailure = (command, result) => Match.value(result.exitCode).pipe(Match.when((exitCode) => exitCode !== 0, (exitCode) => Effect.fail(StrykerError.make({ message: `Build command "${command}" failed with exit code ${String(exitCode)}.\n${result.stderr}` }))), Match.orElse(() => Effect.void));
-const runBuildCommandIn = (command, workingDirectory) => Effect.gen(function* () {
-	const pathService = yield* Path.Path;
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const separator = Match.value(pathService.sep).pipe(Match.when("\\", () => ";"), Match.orElse(() => ":"));
-	const inherited = yield* inheritedPath();
-	const newPath = [...binDirectoriesFrom(workingDirectory, pathService), inherited].join(separator);
-	const childCommand = ChildProcess.make(command, {
-		shell: true,
-		cwd: workingDirectory,
-		env: { PATH: newPath },
-		extendEnv: true
-	});
-	const result = yield* Effect.scoped(Effect.gen(function* () {
-		const handle = yield* spawner.spawn(childCommand);
-		const stderrChunks = yield* Stream.runCollect(Stream.decodeText(handle.stderr)).pipe(Effect.map((chunks) => [...chunks].join("")), Effect.orElseSucceed(() => ""));
-		const exitCode = yield* handle.exitCode;
-		return {
-			exitCode: Number(exitCode),
-			stderr: stderrChunks
-		};
-	})).pipe(Effect.mapError((cause) => StrykerError.make({
-		message: `Failed to spawn build command "${command}"`,
-		cause
-	})));
-	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 enqueueChildDirectory = (dir, entry, walk) => Effect.gen(function* () {
-	const child = walk.path.join(dir, entry);
-	if ((yield* walk.fs.stat(walk.path.join(walk.basePath, child)).pipe(Effect.map((info) => info.type), Effect.orElseSucceed(() => "Unknown"))) === "Directory") walk.queue.push(child);
-});
-const enqueueChildDirectories = (dir, walk) => Effect.gen(function* () {
-	const entries = yield* walk.fs.readDirectory(walk.path.join(walk.basePath, dir)).pipe(Effect.orElseSucceed(() => []));
-	yield* Effect.forEach(entries, (entry) => enqueueChildDirectory(dir, entry, walk), {
-		concurrency: 1,
-		discard: true
-	});
-});
-const visitDirectory = (dir, walk) => Match.value(directoryRole(dir, walk)).pipe(Match.when("nodeModules", () => Effect.sync(() => {
-	walk.found.push(dir);
-})), Match.when("skipped", () => Effect.void), Match.orElse(() => enqueueChildDirectories(dir, walk)));
-const findNodeModulesList = (basePath, tempDirName) => Effect.gen(function* () {
-	const walk = {
-		basePath,
-		tempDirName,
-		fs: yield* FileSystem.FileSystem,
-		path: yield* Path.Path,
-		queue: ["."],
-		found: []
-	};
-	let dir = walk.queue.pop();
-	while (dir !== void 0) {
-		yield* visitDirectory(dir, walk);
-		dir = walk.queue.pop();
-	}
-	return walk.found;
-});
-const symlinkJunction = (to, from) => Effect.gen(function* () {
-	const fsService = yield* FileSystem.FileSystem;
-	const pathService = yield* Path.Path;
-	yield* fsService.makeDirectory(pathService.dirname(from), { recursive: true });
-	yield* fsService.symlink(to, from);
-});
-const moveEntry = (from, to) => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	if ((yield* fs.stat(from)).type === "Directory") yield* moveDirectoryRecursive(from, to);
-	else yield* fs.rename(from, to).pipe(Effect.catch(() => fs.copyFile(from, to).pipe(Effect.andThen(fs.remove(from)))));
-});
-const moveDirectoryRecursive = (from, to) => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const pathService = yield* Path.Path;
-	if (!(yield* fs.exists(from))) return;
-	yield* fs.makeDirectory(to, { recursive: true });
-	const entries = yield* fs.readDirectory(from);
-	yield* Effect.forEach(entries, (entry) => moveEntry(pathService.join(from, entry), pathService.join(to, entry)), {
-		concurrency: 1,
-		discard: true
-	});
-	yield* fs.remove(from, {
-		recursive: true,
-		force: true
-	});
-});
-const inPlaceSandboxFile = (name, file, backupDirectory, basePath) => Effect.gen(function* () {
-	if (!hasChanges(file)) return name;
-	yield* backupTo(file, backupDirectory, basePath);
-	yield* Effect.logDebug("Stored backup file");
-	yield* writeInPlace(file);
-	return name;
-});
-const sandboxFile = (name, file, workingDirectory, backupDirectory, basePath, options) => Match.value(options.inPlace).pipe(Match.when(true, () => inPlaceSandboxFile(name, file, backupDirectory, basePath)), Match.orElse(() => writeToSandbox(file, workingDirectory, basePath)));
-const sandboxFileNameOf = (fileMap, fileName) => Match.value(fileMap.get(fileName)).pipe(Match.when(Predicate.isString, (sandboxFileName) => sandboxFileName), Match.orElse(() => {
-	throw StrykerError.make({ message: `Cannot find sandbox file for ${fileName}` });
-}));
-const withoutLeadingSeparator = (suffix) => Match.value(suffix.startsWith("/")).pipe(Match.when(true, () => suffix.slice(1)), Match.orElse(() => suffix));
-const relativeToBase = (resolvedSandbox, resolvedWorking, base, pathService) => {
-	const trimmed = withoutLeadingSeparator(resolvedSandbox.slice(resolvedWorking.length));
-	return Match.value(trimmed.length === 0).pipe(Match.when(true, () => base), Match.orElse(() => pathService.join(base, trimmed)));
-};
-const originalFileNameOf = (sandboxFileName, workingDirectory, base, pathService) => {
-	const resolvedSandbox = pathService.resolve(sandboxFileName);
-	const resolvedWorking = pathService.resolve(workingDirectory);
-	return Match.value(resolvedSandbox.startsWith(resolvedWorking)).pipe(Match.when(true, () => relativeToBase(resolvedSandbox, resolvedWorking, base, pathService)), Match.orElse(() => resolvedSandbox.replace(resolvedWorking, base)));
-};
-const buildSandboxHandle = (fileMap, workingDirectory, base, pathService) => ({
-	workingDirectory,
-	sandboxFileFor: (fileName) => sandboxFileNameOf(fileMap, fileName),
-	originalFileFor: (sandboxFileName) => originalFileNameOf(sandboxFileName, workingDirectory, base, pathService)
-});
-const announceSandbox = (options, workingDirectory, backupDirectory, basePath, pathService) => Match.value(options.inPlace).pipe(Match.when(true, () => Effect.logInfo(`In place mode is enabled, Stryker will be overriding YOUR files. Find your backup at: ${pathService.relative(basePath, backupDirectory)}`)), Match.orElse(() => Effect.logDebug(`Creating a sandbox for files in ${workingDirectory}`)));
-const hasBackupToRestore = (options, backupDirectory) => Match.value(options.inPlace).pipe(Match.when(true, () => backupDirectory !== ""), Match.orElse(() => false));
-const restoreOriginalFiles = (workingDirectory, backupDirectory, basePath) => Effect.addFinalizer(() => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const p = yield* Path.Path;
-	if (!(yield* fs.exists(backupDirectory))) return;
-	yield* Effect.logInfo(`Resetting your original files from ${p.relative(basePath, backupDirectory)}.`);
-	yield* moveDirectoryRecursive(backupDirectory, workingDirectory).pipe(Effect.orDie);
-}).pipe(Effect.orDie));
-const isNonEmptyString = (value) => Match.value(value).pipe(Match.when(Predicate.isString, (text) => text !== ""), Match.orElse(() => false));
-const runConfiguredBuild = (options, workingDirectory) => Match.value(options.buildCommand).pipe(Match.when(isNonEmptyString, (command) => Effect.logInfo(`Running build command "${command}" in "${workingDirectory}".`).pipe(Effect.andThen(() => runBuildCommandIn(command, workingDirectory)))), Match.orElse(() => Effect.void));
-const linksNodeModules = (options) => Match.value(options.symlinkNodeModules).pipe(Match.when(true, () => !options.inPlace), Match.orElse(() => false));
-const linkNodeModules = (nodeModules, workingDirectory, basePath, pathService) => Effect.gen(function* () {
-	const resolvedTo = pathService.resolve(pathService.join(basePath, nodeModules));
-	const resolvedFrom = pathService.join(workingDirectory, nodeModules);
-	yield* Effect.logDebug(`Create symlink from ${resolvedTo} to ${resolvedFrom}`);
-	yield* symlinkJunction(resolvedTo, resolvedFrom).pipe(Effect.catch((_error) => Effect.logWarning(`Unexpected error while trying to symlink "${nodeModules}" in sandbox directory.`)));
-});
-const linkFoundNodeModules = (options, workingDirectory, basePath, pathService) => Effect.gen(function* () {
-	const nodeModulesList = yield* findNodeModulesList(basePath, options.tempDirName);
-	if (nodeModulesList.length === 0) {
-		yield* Effect.logDebug(`Could not find a node_modules folder to symlink into the sandbox directory. Search "${basePath}" and its parent directories`);
-		return;
-	}
-	yield* Effect.forEach(nodeModulesList, (nodeModules) => linkNodeModules(nodeModules, workingDirectory, basePath, pathService), {
-		concurrency: 1,
-		discard: true
-	});
-});
-const symlinkNodeModules = (options, workingDirectory, basePath, pathService) => Effect.gen(function* () {
-	yield* Effect.logDebug("Start symlink node_modules");
-	if (linksNodeModules(options)) yield* linkFoundNodeModules(options, workingDirectory, basePath, pathService);
-});
-const makeSandbox = (input) => Effect.gen(function* () {
-	const { options, project, workingDirectory, backupDirectory, basePath } = input;
-	yield* Scope.Scope;
-	const pathService = yield* Path.Path;
-	yield* announceSandbox(options, workingDirectory, backupDirectory, basePath, pathService);
-	yield* Effect.when(restoreOriginalFiles(workingDirectory, backupDirectory, basePath), Effect.succeed(hasBackupToRestore(options, backupDirectory)));
-	yield* createPreprocessor(options, basePath)(project).pipe(Effect.mapError((cause) => StrykerError.make({
-		message: "Sandbox preprocessor failed",
-		cause
-	})));
-	const entries = yield* Effect.forEach([...project.files], ([original, file]) => Effect.map(sandboxFile(original, file, workingDirectory, backupDirectory, basePath, options), (target) => [original, target]), {
-		concurrency: 24,
-		discard: false
-	});
-	const fileMap = toFileMap(entries);
-	yield* runConfiguredBuild(options, workingDirectory);
-	yield* symlinkNodeModules(options, workingDirectory, basePath, pathService);
-	return buildSandboxHandle(fileMap, workingDirectory, basePath, pathService);
-});
-//#endregion
-//#region src/run/instrument.cell.ts
-const instrumentCell = Cell.layer({
-	read: (command) => Effect.gen(function* () {
-		yield* Scope.Scope;
-		const env = yield* RunEnvironment;
-		const filesToMutate = yield* Effect.forEach([...MutableHashMap.values(command.project.filesToMutate)], (file) => toInstrumenterFile(file), { concurrency: 24 }).pipe(Effect.mapError((cause) => StageError.make({
-			stage: "instrument",
-			reason: "Failed to read files to mutate",
-			cause
-		})));
-		const instrumentResult = yield* instrument(filesToMutate, {
-			ignorers: [...command.ignorers],
-			excludedMutations: [...command.options.mutator.excludedMutations]
-		}, env.basePath).pipe(Effect.mapError((cause) => StageError.make({
-			stage: "instrument",
-			reason: "Instrumenter failed",
-			cause
-		})));
-		const instrumentedProject = withInstrumentedFiles(command.project, instrumentResult.files);
-		const basePath = env.basePath;
-		let workingDirectory = command.temporaryDirectoryPath;
-		let backupDirectory = "";
-		if (command.options.inPlace) {
-			workingDirectory = basePath;
-			backupDirectory = command.temporaryDirectoryPath;
-		}
-		return {
-			prev: command,
-			filesToMutate,
-			instrumentResult,
-			instrumentedProject,
-			sandbox: yield* makeSandbox({
-				options: command.options,
-				project: instrumentedProject,
-				workingDirectory,
-				backupDirectory,
-				basePath
-			}).pipe(Effect.mapError((cause) => StageError.make({
-				stage: "instrument",
-				reason: "Sandbox initialization failed",
-				cause
-			}))),
-			concurrency: yield* makeConcurrency(command.options).pipe(Effect.mapError((cause) => StageError.make({
-				stage: "instrument",
-				reason: "Failed to compute concurrency",
-				cause
-			})))
-		};
-	}),
-	decode: (raw) => Result.succeed(InstrumentCommand.make({
-		fileCount: raw.filesToMutate.length,
-		inPlace: raw.prev.options.inPlace,
-		pluginCount: raw.prev.loadedPlugins.pluginModulePaths.length
-	})),
-	decide: planInstrumentation,
-	encode: (outcome) => outcome,
-	write: (output, raw) => withPhaseSpan("instrument", { fileCount: raw.filesToMutate.length }, () => Effect.gen(function* () {
-		const env = yield* RunEnvironment;
-		const now = yield* Clock.currentTimeMillis;
-		const queue = yield* RunEvents;
-		yield* Queue.offer(queue, PhaseEntered.make({
-			phase: "instrument",
-			elapsedMs: now - env.runStartedAt
-		}));
-		const out = output;
-		if (Result.isFailure(out)) {
-			const err = out.failure;
-			return yield* StageError.make({
-				stage: err.stage,
-				reason: err.reason,
-				cause: err
-			});
-		}
-		return {
-			...raw.prev,
-			project: raw.instrumentedProject,
-			mutants: raw.instrumentResult.mutants,
-			sandbox: raw.sandbox,
-			concurrency: {
-				testRunners: raw.concurrency.testRunners,
-				checkers: raw.concurrency.checkers
-			}
-		};
-	}))
-});
-//#endregion
-//#region src/MutationTest.schema.ts
-var MutationTestCommand = class extends S.TaggedClass()("MutationTestCommand", {
-	dryRunOnly: S.Boolean,
-	allowEmpty: S.Boolean,
-	testCount: S.Finite,
-	isZero: S.Boolean
-}) {};
-//#endregion
-//#region src/admit-mutation-test.workflow.ts
-var MutationTestError = class extends S.TaggedError()("MutationTestError", {
-	stage: S.Literal("mutationTest"),
-	reason: S.String
-}) {};
-const MutationTestDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/MutationTestDecision");
-var MutationTestProceed = class extends S.TaggedClass()("MutationTestProceed", {}) {
-	[MutationTestDecisionTypeId] = MutationTestDecisionTypeId;
-};
-var MutationTestDryRunOnly = class extends S.TaggedClass()("MutationTestDryRunOnly", {}) {
-	[MutationTestDecisionTypeId] = MutationTestDecisionTypeId;
-};
-var MutationTestNoTests = class extends S.TaggedClass()("MutationTestNoTests", {}) {
-	[MutationTestDecisionTypeId] = MutationTestDecisionTypeId;
-};
-const isInvalidTestCount = (command) => command.testCount < 0;
-const admitMutationTest = Workflow.make(MutationTestCommand, (command) => Match.value(command).pipe(Match.when(isInvalidTestCount, () => Result.fail(MutationTestError.make({
-	stage: "mutationTest",
-	reason: "Invalid test count"
-}))), Match.when({ dryRunOnly: true }, () => Result.succeed(MutationTestDryRunOnly.make({}))), Match.when({
-	isZero: true,
-	allowEmpty: true
-}, () => Result.succeed(MutationTestNoTests.make({}))), Match.orElse(() => Result.succeed(MutationTestProceed.make({})))));
-//#endregion
-//#region src/admit-checker-answer.workflow.ts
-var CheckerAnsweredUnrequested = class extends S.TaggedError()("CheckerAnsweredUnrequested", {
-	checkerName: S.String,
-	phase: S.Literals(["check", "group"]),
-	unrequestedIds: S.Array(S.String),
-	requestedIds: S.Array(S.String)
-}) {};
-var CheckerSkippedRequested = class extends S.TaggedError()("CheckerSkippedRequested", {
-	checkerName: S.String,
-	phase: S.Literals(["check", "group"]),
-	missingIds: S.Array(S.String)
-}) {};
-const isCheckResult = (_value) => true;
-const CheckResultSchema = S.Unknown.pipe(S.refine(isCheckResult));
-var CheckerCommand = class extends S.TaggedClass()("CheckerCommand", {
-	checkerName: S.String,
-	requestedIds: S.Array(S.String),
-	phase: S.Literals(["check", "group"]),
-	idGroups: S.optional(S.Array(S.Array(S.String))),
-	answers: S.optional(S.Record(S.String, CheckResultSchema))
-}) {};
-const CheckerDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/CheckerDecision");
-var CheckGroupDecision = class extends S.TaggedClass()("CheckGroupDecision", { groups: S.Array(S.Array(S.String)) }) {
-	[CheckerDecisionTypeId] = CheckerDecisionTypeId;
-};
-var CheckResultDecision = class extends S.TaggedClass()("CheckResultDecision", { pairs: S.Array(S.Struct({
-	id: S.String,
-	result: CheckResultSchema
-})) }) {
-	[CheckerDecisionTypeId] = CheckerDecisionTypeId;
-};
-const idRecord = (ids) => Object.fromEntries(ids.map((id) => [id, true]));
-const acknowledgedIds = (submitted, requested) => idRecord(submitted.filter((id) => requested[id] === true));
-const answeredUnrequested = (command, submitted, requested) => Option.liftPredicate(Arr.isReadonlyArrayNonEmpty)(submitted.filter((id) => !(id in requested))).pipe(Option.map((unrequestedIds) => CheckerAnsweredUnrequested.make({
-	checkerName: command.checkerName,
-	phase: command.phase,
-	unrequestedIds,
-	requestedIds: [...command.requestedIds]
-})));
-const skippedRequested = (command, acknowledged) => Option.liftPredicate(Arr.isReadonlyArrayNonEmpty)(command.requestedIds.filter((id) => !(id in acknowledged))).pipe(Option.map((missingIds) => CheckerSkippedRequested.make({
-	checkerName: command.checkerName,
-	phase: command.phase,
-	missingIds
-})));
-/** The first contract breach the answer commits: an unrequested id outranks an unanswered one. */
-const contractBreach = (command, requested, submitted) => Option.firstSomeOf([answeredUnrequested(command, submitted, requested), skippedRequested(command, acknowledgedIds(submitted, requested))]);
-const admit = (command, requested, submitted, decision) => Option.match(contractBreach(command, requested, submitted), {
-	onNone: () => Result.succeed(decision),
-	onSome: (breach) => Result.fail(breach)
-});
-const idGroupsOf = (command) => Option.getOrElse(() => [])(Option.fromUndefinedOr(command.idGroups));
-const answersOf = (command) => Option.getOrElse(() => ({}))(Option.fromUndefinedOr(command.answers));
-const evaluateGroup = (command) => {
-	const idGroups = idGroupsOf(command);
-	return admit(command, idRecord(command.requestedIds), idGroups.flat(), CheckGroupDecision.make({ groups: idGroups.map((group) => [...group]) }));
-};
-const evaluateCheckResult = (command) => {
-	const requested = idRecord(command.requestedIds);
-	const entries = Object.entries(answersOf(command));
-	const pairs = entries.filter(([id]) => requested[id] === true).map(([id, result]) => ({
-		id,
-		result
-	}));
-	return admit(command, requested, entries.map(([id]) => id), CheckResultDecision.make({ pairs }));
-};
-const admitCheckerAnswer = Workflow.make(CheckerCommand, (command) => Match.value(command.phase).pipe(Match.when("group", () => evaluateGroup(command)), Match.when("check", () => evaluateCheckResult(command)), Match.exhaustive));
-//#endregion
-//#region src/Checker.ts
-/**
-* Checker — the Checker capability.
-*
-* Owns the checker port, its contract, the child-process edge, and the
-* Cell pipelines that drive a checker through a pure workflow. A checker
-* speaks `Mutant`; the engine schedules `MutantRunPlan` — this module bridges
-* the two and verifies the join.
-*/
-/**
-* Pair a checker's answers back to the run plans they were asked about.
-*
-* A checker's port speaks `Mutant`; the engine schedules `MutantRunPlan`. Going
-* one way is a projection, but coming back is a join that can fail two ways —
-* the checker answered about something it was not asked about, or it did not
-* answer about something it was. Both are the plugin breaking its contract, and
-* each carries its own tag, so a caller matches on the failure rather than
-* parsing ids out of a message.
-*
-* Pure: the pairing is a decision over two lists, so it runs without a checker,
-* a process or a clock — which is the point, because this is the part worth
-* testing.
-*/
-const pairCheckResults = (checkerName, plans, answers) => Match.value(partitionAnswers(plansById(plans), answers)).pipe(Match.when((partition) => partition.unrequested.length > 0, (partition) => Result.fail(CheckerAnsweredUnrequested.make({
-	checkerName,
-	phase: "check",
-	unrequestedIds: [...partition.unrequested],
-	requestedIds: plans.map((plan) => plan.mutant.id)
-}))), Match.orElse((partition) => admitAnsweredPlans(checkerName, plans, partition.paired)));
-/**
-* Resolve a checker's id groups back to run plans.
-*
-* Same join as `pairCheckResults` and the same two failures, over groups rather
-* than single answers. A mutant absent from every group is as much a dropped
-* mutant as one absent from the check results — it would go on to be scheduled
-* as though the checker had approved it.
-*/
-const pairGroups = (checkerName, plans, idGroups) => Match.value(partitionGroups(plansById(plans), idGroups)).pipe(Match.when((partition) => partition.unrequested.length > 0, (partition) => Result.fail(CheckerAnsweredUnrequested.make({
-	checkerName,
-	phase: "group",
-	unrequestedIds: [...partition.unrequested],
-	requestedIds: plans.map((plan) => plan.mutant.id)
-}))), Match.orElse((partition) => admitGroupedPlans(checkerName, plans, partition)));
-const plansById = (plans) => new Map(plans.map((plan) => [plan.mutant.id, plan]));
-const missingPlanIds = (plans, present) => plans.map((plan) => plan.mutant.id).filter((id) => !present.has(id));
-const answeredPlanIds = (paired) => new Set(paired.map(([plan]) => plan.mutant.id));
-const partitionAnswers = (byId, answers) => {
-	const entries = Object.entries(answers).map(([id, answer]) => ({
-		id,
-		answer,
-		plan: Option.fromUndefinedOr(byId.get(id))
-	}));
-	return {
-		paired: entries.flatMap((entry) => Option.match(entry.plan, {
-			onNone: () => [],
-			onSome: (plan) => [[plan, entry.answer]]
-		})),
-		unrequested: entries.flatMap((entry) => Option.match(entry.plan, {
-			onNone: () => [entry.id],
-			onSome: () => []
-		}))
-	};
-};
-const admitAnsweredPlans = (checkerName, plans, paired) => Match.value(missingPlanIds(plans, answeredPlanIds(paired))).pipe(Match.when((missing) => missing.length > 0, (missing) => Result.fail(CheckerSkippedRequested.make({
-	checkerName,
-	phase: "check",
-	missingIds: [...missing]
-}))), Match.orElse(() => Result.succeed(paired)));
-const partitionGroupIds = (byId, idGroup) => {
-	const entries = idGroup.map((id) => ({
-		id,
-		plan: Option.fromUndefinedOr(byId.get(id))
-	}));
-	return {
-		plans: entries.flatMap((entry) => Option.match(entry.plan, {
-			onNone: () => [],
-			onSome: (plan) => [plan]
-		})),
-		grouped: new Set(idGroup),
-		unrequested: entries.flatMap((entry) => Option.match(entry.plan, {
-			onNone: () => [entry.id],
-			onSome: () => []
-		}))
-	};
-};
-const partitionGroups = (byId, idGroups) => {
-	const parts = idGroups.map((idGroup) => partitionGroupIds(byId, idGroup));
-	return {
-		groups: parts.map((part) => part.plans),
-		grouped: new Set(parts.flatMap((part) => [...part.grouped])),
-		unrequested: parts.flatMap((part) => part.unrequested)
-	};
-};
-const admitGroupedPlans = (checkerName, plans, partition) => Match.value(missingPlanIds(plans, partition.grouped)).pipe(Match.when((missing) => missing.length > 0, (missing) => Result.fail(CheckerSkippedRequested.make({
-	checkerName,
-	phase: "group",
-	missingIds: [...missing]
-}))), Match.orElse(() => Result.succeed(partition.groups)));
-const makeCheckerChildProcess = (params) => Effect.gen(function* () {
-	const crashed = (cause) => ChildProcessCrashedError.make({
-		pid: 0,
-		exit: {
-			_tag: "Code",
-			code: 1
-		},
-		cause
-	});
-	const optionsJson = yield* encodeWorkerOptions(params.options);
-	const client = yield* makeWorkerClient({
-		rpcs: CheckerRpcs,
-		entrypoint: params.workerEntrypoint,
-		workingDirectory: params.workingDirectory,
-		execArgv: [...params.execArgv],
-		optionsJson,
-		tempDirPrefix: "stryker-checker-"
-	}).pipe(Effect.mapError((error) => Match.value(error).pipe(Match.tag("ChildProcessCrashedError", "OutOfMemoryError", (crash) => crash), Match.tag("WorkerBootTimeoutError", () => crashed(`Checker worker failed to start: its boot window closed before it accepted the RPC connection`)), Match.exhaustive)));
-	return {
-		check: (checkerName, mutants) => client.check({
-			checkerName,
-			mutants: [...mutants]
-		}).pipe(Effect.mapError((error) => crashed(error.message))),
-		group: (checkerName, mutants) => client.group({
-			checkerName,
-			mutants: [...mutants]
-		}).pipe(Effect.mapError((error) => crashed(error.message)))
-	};
-});
-const createCheckerFactory = (options, fileDescriptions, workerEntrypoint, idGenerator, workingDirectory) => makeCheckerChildProcess({
-	options,
-	fileDescriptions,
-	workerEntrypoint,
-	workingDirectory,
-	execArgv: [...options.checkerNodeArgs],
-	idGenerator
-});
-const writeDecidedAnswers = (plans, checkerName, answers) => Effect.fromResult(pairCheckResults(checkerName, plans, Object.fromEntries(answers.map((answer) => [answer.id, answer.result]))));
-const writeDecidedGroups = (plans, checkerName, idGroups) => Effect.fromResult(pairGroups(checkerName, plans, idGroups));
-const writeCheckerDecision = (plans, checkerName, decision) => Match.value(decision).pipe(Match.tag("CheckResultDecision", (d) => writeDecidedAnswers(plans, checkerName, d.pairs)), Match.tag("CheckGroupDecision", () => Effect.fail(CheckerSkippedRequested.make({
-	checkerName,
-	phase: "check",
-	missingIds: []
-}))), Match.exhaustive);
-const writeCheckerOutcome = (plans, checkerName, outcome) => Result.match(outcome, {
-	onFailure: (error) => Effect.fail(error),
-	onSuccess: (decision) => writeCheckerDecision(plans, checkerName, decision)
-});
-const writeGroupDecision = (plans, checkerName, decision) => Match.value(decision).pipe(Match.tag("CheckGroupDecision", (d) => writeDecidedGroups(plans, checkerName, d.groups)), Match.tag("CheckResultDecision", () => Effect.fail(CheckerSkippedRequested.make({
-	checkerName,
-	phase: "group",
-	missingIds: []
-}))), Match.exhaustive);
-const writeGroupOutcome = (plans, checkerName, outcome) => Result.match(outcome, {
-	onFailure: (error) => Effect.fail(error),
-	onSuccess: (decision) => writeGroupDecision(plans, checkerName, decision)
-});
-/**
-* Ask a checker about run plans and get run plans back.
-*
-* The port speaks `Mutant` because that is all a checker needs; the engine
-* schedules `MutantRunPlan`. This is the two-line shell around that translation:
-* project the plans down, call the checker, and hand the answers to the pure decision
-* that joins them back. The join is where the work is, and it is pure.
-*/
-const checkPlans = (checker, checkerName, plans) => {
-	return Cell.layer({
-		read: (command) => command.checker.check(command.checkerName, command.plans.map((plan) => plan.mutant)).pipe(Effect.map((answers) => ({
-			checkerName: command.checkerName,
-			requestedIds: command.plans.map((plan) => plan.mutant.id),
-			answers
-		}))),
-		decode: (raw) => Result.succeed(CheckerCommand.make({
-			checkerName: raw.checkerName,
-			requestedIds: [...raw.requestedIds],
-			phase: "check",
-			answers: { ...raw.answers }
-		})),
-		decide: admitCheckerAnswer,
-		encode: (outcome) => outcome,
-		write: (outcome, raw) => writeCheckerOutcome(plans, raw.checkerName, outcome)
-	}).run({
-		checker,
-		checkerName,
-		plans
-	});
-};
-/**
-* Ask a checker how to group run plans, and get groups of run plans back.
-*/
-const groupPlans = (checker, checkerName, plans) => {
-	return Cell.layer({
-		read: (command) => command.checker.group(command.checkerName, command.plans.map((plan) => plan.mutant)).pipe(Effect.map((idGroups) => ({
-			checkerName: command.checkerName,
-			requestedIds: command.plans.map((plan) => plan.mutant.id),
-			idGroups
-		}))),
-		decode: (raw) => Result.succeed(CheckerCommand.make({
-			checkerName: raw.checkerName,
-			requestedIds: [...raw.requestedIds],
-			phase: "group",
-			idGroups: raw.idGroups.map((group) => [...group])
-		})),
-		decide: admitCheckerAnswer,
-		encode: (outcome) => outcome,
-		write: (outcome, raw) => writeGroupOutcome(plans, raw.checkerName, outcome)
-	}).run({
-		checker,
-		checkerName,
-		plans
-	});
-};
-const checkGroupedPlans = (checker, checkerName, plans) => Effect.gen(function* () {
-	const groups = yield* groupPlans(checker, checkerName, plans);
-	return (yield* Effect.forEach(groups, (group) => checkPlans(checker, checkerName, group), { concurrency: 1 })).flat();
-});
-//#endregion
-//#region src/mutant-result-mapping.ts
-const toSchemaPosition = (pos) => ({
-	column: pos.column + 1,
-	line: pos.line + 1
-});
-const toSchemaLocation = (location) => ({
-	start: toSchemaPosition(location.start),
-	end: toSchemaPosition(location.end)
-});
-const checkStatusToMutantStatus = (_status) => "CompileError";
-const mutantResult = (mutant, status, outcome = {}) => ({
-	_tag: "Mutant",
-	id: mutant.id,
-	fileName: mutant.fileName,
-	mutatorName: mutant.mutatorName,
-	replacement: mutant.replacement,
-	location: toSchemaLocation(mutant.location),
-	status,
-	coveredBy: mutant.coveredBy,
-	static: mutant.static,
-	testsCompleted: mutant.testsCompleted,
-	description: mutant.description,
-	...outcome
-});
-const mapRunResult = (mutant, result) => Match.value(result).pipe(Match.discriminator("status")("error", (errored) => mutantResult(mutant, "RuntimeError", { statusReason: errored.errorMessage })), Match.discriminator("status")("killed", (killed) => mutantResult(mutant, "Killed", {
-	testsCompleted: killed.nrOfTests,
-	killedBy: [...killed.killedBy],
-	statusReason: killed.failureMessage
-})), Match.discriminator("status")("timeout", (timedOut) => {
-	if (timedOut.reason === void 0) return mutantResult(mutant, "Timeout");
-	return mutantResult(mutant, "Timeout", { statusReason: timedOut.reason });
-}), Match.discriminator("status")("survived", (survived) => mutantResult(mutant, "Survived", { testsCompleted: survived.nrOfTests })), Match.exhaustive);
-//#endregion
-//#region src/calculate-metrics.ts
-const countStatus = (mutants, status) => mutants.filter((mutant) => mutant.status === status).length;
-const percentage = (numerator, denominator) => numerator / denominator * 100;
-const percentOr = (emptyDenominator, numerator, denominator) => Match.value(denominator).pipe(Match.when(0, () => emptyDenominator), Match.orElse(() => percentage(numerator, denominator)));
-const coveredFraction = (totalDetected, totalCovered, totalValid) => Match.value(totalValid).pipe(Match.when(0, () => NaN), Match.orElse(() => percentOr(0, totalDetected, totalCovered)));
-const countMutants = (mutants) => {
-	const pending = countStatus(mutants, "Pending");
-	const killed = countStatus(mutants, "Killed");
-	const timeout = countStatus(mutants, "Timeout");
-	const survived = countStatus(mutants, "Survived");
-	const noCoverage = countStatus(mutants, "NoCoverage");
-	const runtimeErrors = countStatus(mutants, "RuntimeError");
-	const compileErrors = countStatus(mutants, "CompileError");
-	const ignored = countStatus(mutants, "Ignored");
-	const totalDetected = timeout + killed;
-	const totalUndetected = survived + noCoverage;
-	const totalCovered = totalDetected + survived;
-	const totalValid = totalUndetected + totalDetected;
-	const totalInvalid = runtimeErrors + compileErrors;
-	return {
-		pending,
-		killed,
-		timeout,
-		survived,
-		noCoverage,
-		runtimeErrors,
-		compileErrors,
-		ignored,
-		totalDetected,
-		totalUndetected,
-		totalCovered,
-		totalValid,
-		totalInvalid,
-		totalMutants: totalValid + totalInvalid + ignored + pending,
-		mutationScore: percentOr(NaN, totalDetected, totalValid),
-		mutationScoreBasedOnCoveredCode: coveredFraction(totalDetected, totalCovered, totalValid)
-	};
-};
-const segmentOf = (fileName) => {
-	const separator = fileName.indexOf("/");
-	if (separator === -1) return fileName;
-	return fileName.slice(0, separator);
-};
-const groupBySegment = (files) => Object.entries(files).reduce((groups, [fileName, file]) => {
-	const segment = segmentOf(fileName);
-	const group = groups[segment] ?? {};
-	group[fileName] = file;
-	groups[segment] = group;
-	return groups;
-}, {});
-const metricsOf = (files) => countMutants(Object.values(files).flatMap((file) => file.mutants));
-const fileResultOf = (fileName, file) => ({
-	name: fileName,
-	metrics: countMutants(file.mutants),
-	childResults: []
-});
-const nestedGroupResult = (segment, entries) => {
-	const nested = Object.fromEntries(entries.map(([fileName, file]) => [fileName.slice(segment.length + 1), file]));
-	return {
-		name: segment,
-		metrics: metricsOf(nested),
-		childResults: childResultsOf(nested)
-	};
-};
-const soleSegmentFileResult = (segment, entries) => Option.flatMap(Arr.head(entries), ([fileName, file]) => Match.value(fileName === segment && entries.length === 1).pipe(Match.when(true, () => Option.some(fileResultOf(fileName, file))), Match.orElse(() => Option.none())));
-const childResultOf = (segment, entries) => Option.getOrElse(soleSegmentFileResult(segment, entries), () => nestedGroupResult(segment, entries));
-const childResultsOf = (files) => Object.entries(groupBySegment(files)).map(([segment, grouped]) => childResultOf(segment, Object.entries(grouped))).sort((left, right) => left.name.localeCompare(right.name));
-const calculateMetrics = (files) => ({
-	name: "All files",
-	metrics: metricsOf(files),
-	childResults: childResultsOf(files)
-});
-//#endregion
-//#region src/report-assembly.ts
-const extensionOf = (fileName) => {
-	const base = fileName.slice(fileName.lastIndexOf("/") + 1);
-	const dot = base.lastIndexOf(".");
-	if (dot <= 0) return "";
-	return base.slice(dot).toLowerCase();
-};
-const EXTENSION_LANGUAGES = {
-	".ts": "typescript",
-	".tsx": "typescript",
-	".html": "html",
-	".vue": "html"
-};
-const determineLanguage = (fileName) => EXTENSION_LANGUAGES[extensionOf(fileName)] ?? "javascript";
-const reportFileName = (relativePath) => Option.match(Option.fromUndefinedOr(relativePath), {
-	onNone: () => "",
-	onSome: (present) => present.replaceAll("\\", "/")
-});
-const testIdRemap = (testIds) => {
-	const positions = HashMap.fromIterable(testIds.map((id, position) => [id, position.toString()]));
-	const remapId = (id) => Option.getOrElse(HashMap.get(positions, id), () => id);
-	const remapIds = (ids) => {
-		if (ids === void 0) return;
-		return ids.map(remapId);
-	};
-	return {
-		testId: remapId,
-		testIds: remapIds
-	};
-};
-const toReportMutant = (mutant, remap) => ({
-	id: mutant.id,
-	mutatorName: mutant.mutatorName,
-	replacement: mutant.replacement,
-	status: mutant.status,
-	location: mutant.location,
-	statusReason: mutant.statusReason,
-	testsCompleted: mutant.testsCompleted,
-	description: mutant.description,
-	static: mutant.static,
-	killedBy: remap.testIds(mutant.killedBy),
-	coveredBy: remap.testIds(mutant.coveredBy)
-});
-const toReportTest = (test, remap) => {
-	const base = {
-		id: remap.testId(test.id),
-		name: test.name
-	};
-	if (test.startPosition === void 0) return base;
-	return {
-		...base,
-		location: { start: test.startPosition }
-	};
-};
-const assembleFileResults = (input) => {
-	const entries = [...input.mutants.reduce((accumulator, mutant) => Option.match(HashMap.get(input.reportNames, mutant.fileName), {
-		onNone: () => accumulator,
-		onSome: (reportName) => {
-			const mapped = toReportMutant(mutant, input.remap);
-			return Option.match(HashMap.get(accumulator, reportName), {
-				onNone: () => HashMap.set(accumulator, reportName, {
-					sourceFileName: mutant.fileName,
-					mutants: [mapped]
-				}),
-				onSome: (existing) => HashMap.set(accumulator, reportName, {
-					sourceFileName: existing.sourceFileName,
-					mutants: [...existing.mutants, mapped]
-				})
-			});
-		}
-	}), HashMap.empty())].flatMap(([reportName, group]) => Option.match(HashMap.get(input.sources, group.sourceFileName), {
-		onNone: () => [],
-		onSome: (source) => [[reportName, {
-			...source,
-			mutants: group.mutants
-		}]]
-	}));
-	return Object.fromEntries(entries);
-};
-const assembleTestFiles = (input) => {
-	const entries = [...input.tests.reduce((accumulator, test) => Option.match(Option.fromUndefinedOr(test.fileName), {
-		onNone: () => accumulator,
-		onSome: (testFileName) => Option.match(HashMap.get(input.reportNames, testFileName), {
-			onNone: () => accumulator,
-			onSome: (reportName) => {
-				const mapped = toReportTest(test, input.remap);
-				return Option.match(HashMap.get(accumulator, reportName), {
-					onNone: () => HashMap.set(accumulator, reportName, {
-						sourceFileName: testFileName,
-						tests: [mapped]
-					}),
-					onSome: (existing) => HashMap.set(accumulator, reportName, {
-						sourceFileName: existing.sourceFileName,
-						tests: [...existing.tests, mapped]
-					})
-				});
-			}
-		})
-	}), HashMap.empty())].flatMap(([reportName, group]) => Option.match(HashMap.get(input.testSources, group.sourceFileName), {
-		onNone: () => [],
-		onSome: (source) => [[reportName, {
-			...source,
-			tests: group.tests
-		}]]
-	}));
-	return Object.fromEntries(entries);
-};
-//#endregion
-//#region package.json
-var package_default = {
-	name: "@systemfsoftware/stryker-js",
-	version: "5.0.0",
-	repository: {
-		"type": "git",
-		"url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
-		"directory": "packages/stryker-js"
-	},
-	homepage: "https://github.com/systemfsoftware/stryker-js-effect",
-	bugs: { "url": "https://github.com/systemfsoftware/stryker-js-effect/issues" },
-	description: "The Stryker mutation testing tool — the stryker executable, the run engine, and the configuration surface.",
-	type: "module",
-	files: ["dist"],
-	bin: { "stryker": "./dist/main.mjs" },
-	scripts: {
-		"clean": "rimraf dist",
-		"build": "rimraf dist && tsdown --config tsdown.bin.config.ts && tsdown --config tsdown.config.ts",
-		"typecheck": "tsc --noEmit --incremental && tsc -p tsconfig.node.json --noEmit",
-		"test": "vitest run",
-		"attw": "attw --pack .",
-		"lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
-		"api:check": "concurrently --kill-others-on-fail \"api-extractor run\" \"api-extractor run --config api-extractor.builtin-reporters.json\" \"api-extractor run --config api-extractor.plugin-loader.json\"",
-		"api:update": "concurrently --kill-others-on-fail \"api-extractor run --local\" \"api-extractor run --local --config api-extractor.builtin-reporters.json\" \"api-extractor run --local --config api-extractor.plugin-loader.json\"",
-		"lint:tsgo": "effect-tsgo diagnostics --project tsconfig.json --format ${TSGO_FORMAT:-text}"
-	},
-	license: "Apache-2.0",
-	engines: { "node": ">=22.18.0" },
-	dependencies: {
-		"@effect/opentelemetry": "4.0.0-rc.112",
-		"@effect/platform-node": "catalog:",
-		"@effect/platform-node-shared": "catalog:",
-		"@noble/hashes": "catalog:",
-		"@opentelemetry/api": "^1.9.0",
-		"@opentelemetry/exporter-trace-otlp-http": "^0.208.0",
-		"@opentelemetry/sdk-trace-base": "^2.2.0",
-		"@systemfsoftware/effect-cell-types": "catalog:",
-		"@systemfsoftware/stryker-ignorer-interface": "workspace:^",
-		"@systemfsoftware/stryker-js-html-reporter": "workspace:^",
-		"@systemfsoftware/stryker-js-instrumenter": "workspace:^",
-		"@systemfsoftware/stryker-js-plugin-interface": "workspace:^",
-		"@systemfsoftware/stryker-js-plugin-runtime": "workspace:^",
-		"diff-match-patch": "1.0.5",
-		"minimatch": "~10.2.4"
-	},
-	peerDependencies: { "effect": "catalog:" },
-	devDependencies: {
-		"@effect/tsgo": "catalog:",
-		"@effect/vitest": "catalog:",
-		"@microsoft/api-extractor": "catalog:",
-		"@oxc-parser/binding-wasm32-wasi": "catalog:",
-		"@std/jsonc": "catalog:",
-		"@systemfsoftware/all": "catalog:",
-		"@systemfsoftware/arethetypeswrong-cli": "catalog:",
-		"@systemfsoftware/effect-gherkin-spec": "catalog:",
-		"@systemfsoftware/effect-schema-law": "catalog:",
-		"@systemfsoftware/effect-schema-vite": "catalog:",
-		"@systemfsoftware/stryker-ignorer-effect-schema-declarations": "workspace:^",
-		"@systemfsoftware/stryker-ignorer-in-source-vitest-block": "workspace:^",
-		"@systemfsoftware/tsconfig": "catalog:",
-		"@systemfsoftware/tsdown-config": "workspace:^",
-		"@systemfsoftware/vitest-config": "workspace:^",
-		"@types/diff-match-patch": "1.0.36",
-		"@types/node": "catalog:",
-		"@vitest/coverage-v8": "catalog:",
-		"concurrently": "catalog:",
-		"mutation-testing-elements": "catalog:stryker",
-		"oxc-parser": "catalog:",
-		"oxlint": "catalog:",
-		"oxlint-tsgolint": "catalog:",
-		"rimraf": "catalog:",
-		"tsdown": "catalog:",
-		"typescript": "catalog:",
-		"vitest": "catalog:"
-	},
-	publishConfig: {
-		"access": "public",
-		"provenance": true,
-		"exports": {
-			".": {
-				"types": "./dist/index.d.mts",
-				"default": "./dist/index.mjs"
-			},
-			"./builtin-reporters": {
-				"types": "./dist/builtin-reporters.d.mts",
-				"default": "./dist/builtin-reporters.mjs"
-			},
-			"./config": {
-				"types": "./dist/config.d.mts",
-				"default": "./dist/config.mjs"
-			},
-			"./plugin-loader": {
-				"types": "./dist/plugin-loader.d.mts",
-				"default": "./dist/plugin-loader.mjs"
-			},
-			"./promises": {
-				"types": "./dist/promises.d.mts",
-				"default": "./dist/promises.mjs"
-			},
-			"./package.json": "./package.json"
-		}
-	},
-	exports: { "./package.json": "./package.json" }
-};
-//#endregion
-//#region src/stryker-package.schema.ts
-const PackageJsonSchema = Schema.Struct({ version: Schema.String });
-//#endregion
-//#region src/stryker-package.ts
-const rawPackageJson = package_default;
-const strykerVersion = Schema.decodeUnknownSync(PackageJsonSchema)(rawPackageJson).version;
-//#endregion
-//#region src/verdict-envelope.ts
-const normalizeFileName$1 = (fileName) => fileName.replaceAll("\\", "/");
-const VERDICT_ENVELOPE_SCHEMA_VERSION = "1.1";
-const ACTIONABLE_STATUSES = [
-	"Survived",
-	"NoCoverage",
-	"Timeout",
-	"RuntimeError"
-];
-function isActionableStatus(status) {
-	return ACTIONABLE_STATUSES.some((actionable) => actionable === status);
-}
-const CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-const emitQuint = (accumulator) => {
-	const bits = accumulator.bits - 5;
-	return {
-		value: accumulator.value & (1 << bits) - 1,
-		bits,
-		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 pushByte = (accumulator, byte) => drainQuints({
-	value: accumulator.value << 8 | byte,
-	bits: accumulator.bits + 8,
-	chars: accumulator.chars
-});
-function generateRunId(now) {
-	const bytes = /* @__PURE__ */ new Uint8Array(16);
-	const epoch = DateTime.toEpochMillis(now);
-	bytes[0] = epoch / 1099511627776 % 256;
-	bytes[1] = epoch / 4294967296 % 256;
-	bytes[2] = epoch / 16777216 % 256;
-	bytes[3] = epoch / 65536 % 256;
-	bytes[4] = epoch / 256 % 256;
-	bytes[5] = epoch % 256;
-	bytes.set(randomBytes(10), 6);
-	const drained = Array.from(bytes).reduce(pushByte, {
-		value: 0,
-		bits: 0,
-		chars: ""
-	});
-	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);
-}
-function embeddedConfig(report) {
-	const JsonReporterSchema = S.Struct({ fileName: S.String });
-	const EmbeddedConfigSchema = S.StructWithRest(S.Struct({ jsonReporter: S.optional(JsonReporterSchema) }), [S.Record(S.String, S.Unknown)]);
-	const decoded = S.decodeUnknownOption(EmbeddedConfigSchema)(report.config);
-	const jsonReporter = Option.flatMap(decoded, (config) => Option.fromUndefinedOr(config.jsonReporter));
-	return { jsonReporterFileName: Option.getOrUndefined(Option.map(jsonReporter, (reporter) => reporter.fileName)) };
-}
-function breakThreshold(thresholds) {
-	const ThresholdsBreakSchema = S.StructWithRest(S.Struct({ break: S.optional(S.Union([S.Finite, S.Null])) }), [S.Record(S.String, S.Unknown)]);
-	const decoded = S.decodeUnknownOption(ThresholdsBreakSchema)(thresholds);
-	return Option.getOrNull(Option.flatMap(decoded, (value) => Option.fromNullishOr(value.break)));
-}
-const actionableMutants = (files) => Object.entries(files).flatMap(([file, fileResult]) => fileResult.mutants.filter((mutant) => isActionableStatus(mutant.status)).map((mutant) => ({
-	id: mutant.id,
-	file,
-	location: mutant.location,
-	mutator: mutant.mutatorName,
-	replacement: mutant.replacement ?? null,
-	status: mutant.status
-})));
-function buildVerdictEnvelope(report, mode, signal, runId, basePath, pathService) {
-	const metrics = calculateMetrics(report.files).metrics;
-	const { jsonReporterFileName } = embeddedConfig(report);
-	return {
-		schemaVersion: "1.1",
-		runId,
-		mode,
-		signal,
-		score: Option.getOrNull(Option.filter(Option.some(metrics.mutationScore), (score) => metrics.totalMutants > 0 && Number.isFinite(score))),
-		thresholds: {
-			high: report.thresholds.high,
-			low: report.thresholds.low,
-			break: breakThreshold(report.thresholds)
-		},
-		counts: {
-			killed: metrics.killed,
-			timeout: metrics.timeout,
-			survived: metrics.survived,
-			noCoverage: metrics.noCoverage,
-			runtimeErrors: metrics.runtimeErrors,
-			compileErrors: metrics.compileErrors,
-			ignored: metrics.ignored,
-			pending: metrics.pending
-		},
-		reportFile: Option.getOrNull(Option.map(Option.filter(Option.fromUndefinedOr(jsonReporterFileName), () => metrics.totalMutants > 0), (fileName) => normalizeFileName$1(pathService.relative(basePath, fileName)))),
-		mutants: actionableMutants(report.files)
-	};
-}
-//#endregion
-//#region src/mutation-reporting.ts
-const STRYKER_FRAMEWORK = Object.freeze({
-	branding: {
-		homepageUrl: "https://stryker-mutator.io",
-		imageUrl: "https://stryker-mutator.io/assets/images/stryker-80x80.png"
-	},
-	name: "StrykerJS",
-	version: strykerVersion
-});
-Context.Service()("@systemfsoftware/stryker-js/mutation-reporting/MutationReporting");
-const makeMutationReportingService = (input) => {
-	const reportMutantStatus = (mutant, status) => {
-		const location = toSchemaLocation(mutant.location);
-		return Effect.succeed({
-			_tag: "Mutant",
-			id: mutant.id,
-			fileName: mutant.fileName,
-			mutatorName: mutant.mutatorName,
-			replacement: mutant.replacement,
-			location,
-			status,
-			coveredBy: mutant.coveredBy,
-			static: mutant.static,
-			testsCompleted: mutant.testsCompleted,
-			description: mutant.description,
-			statusReason: mutant.statusReason
-		});
-	};
-	const reportCheckFailure = (mutant, result) => reportMutantStatus(mutant, checkStatusToMutantStatus(result.status));
-	const reportMutantRunResult = (mutant, result) => {
-		const mapped = mapRunResult(mutant, result);
-		return Effect.succeed(mapped);
-	};
-	const uniqueNames = (names) => [...new Set(names.filter((name) => name !== void 0))];
-	const readMutatedSources = (fileNames) => Effect.gen(function* () {
-		const entries = yield* Effect.forEach(fileNames, (fileName) => Effect.gen(function* () {
-			const language = determineLanguage(fileName);
-			const file = MutableHashMap.get(input.project.files, fileName);
-			if (Option.isNone(file)) {
-				yield* Effect.logWarning(`File "${fileName}" not found in input files, but did receive mutant result for it. This shouldn't happen`);
-				return [fileName, {
-					language,
-					mutants: [],
-					source: ""
-				}];
-			}
-			return [fileName, {
-				language,
-				mutants: [],
-				source: yield* readOriginal(file.value)
-			}];
-		}), { concurrency: 24 });
-		return HashMap.fromIterable(entries);
-	});
-	const readTestSources = (fileNames) => Effect.gen(function* () {
-		const entries = yield* Effect.forEach(fileNames, (fileName) => Effect.gen(function* () {
-			const file = MutableHashMap.get(input.project.files, fileName);
-			if (Option.isNone(file)) {
-				yield* Effect.logWarning(`Test file "${fileName}" not found in input files, but did receive test result for it. This shouldn't happen.`);
-				return [fileName, { tests: [] }];
-			}
-			return [fileName, {
-				tests: [],
-				source: yield* readOriginal(file.value)
-			}];
-		}), { concurrency: 24 });
-		return HashMap.fromIterable(entries);
-	});
-	const assembleReport = (results) => Effect.gen(function* () {
-		const pathService = yield* Path.Path;
-		const tests = [...MutableHashMap.values(input.testCoverage.testsById)];
-		const remap = testIdRemap(tests.map((test) => test.id));
-		const mutatedFileNames = uniqueNames(results.map((result) => result.fileName));
-		const testFileNames = uniqueNames(tests.map((test) => test.fileName));
-		const sources = yield* readMutatedSources(mutatedFileNames);
-		const testSources = yield* readTestSources(testFileNames);
-		const reportNames = HashMap.fromIterable([...mutatedFileNames, ...testFileNames].map((fileName) => [fileName, reportFileName(pathService.relative(input.basePath, fileName))]));
-		return {
-			files: assembleFileResults({
-				sources,
-				reportNames,
-				mutants: results,
-				remap
-			}),
-			testFiles: assembleTestFiles({
-				testSources,
-				reportNames,
-				tests,
-				remap
-			})
-		};
-	});
-	const mutationTestReport = (results) => Effect.gen(function* () {
-		const { files, testFiles } = yield* assembleReport(results);
-		const dependencies = yield* discoverDependencies();
-		return {
-			files,
-			schemaVersion: "1.0",
-			thresholds: input.options.thresholds,
-			testFiles,
-			projectRoot: input.basePath,
-			config: input.options,
-			framework: {
-				...STRYKER_FRAMEWORK,
-				dependencies
-			}
-		};
-	});
-	const MANIFEST_SPECIFIERS = [
-		"@systemfsoftware/stryker-js-vitest-runner",
-		"@systemfsoftware/stryker-js-typescript-checker",
-		"@systemfsoftware/stryker-ignorer-effect-schema-declarations",
-		"vitest",
-		"karma",
-		"karma-chai",
-		"karma-chrome-launcher",
-		"karma-jasmine",
-		"karma-mocha",
-		"mocha",
-		"jasmine",
-		"jasmine-core",
-		"jest",
-		"react-scripts",
-		"typescript",
-		"@angular/cli",
-		"webpack",
-		"webpack-cli",
-		"ts-jest"
-	];
-	const ManifestSchema = S.Struct({ version: S.optional(S.String) });
-	const readManifestVersion = (fs, pathService, specifier) => Effect.gen(function* () {
-		const resolved = yield* Effect.try(() => new URL(import.meta.resolve(`${specifier}/package.json`)));
-		const manifestPath = yield* pathService.fromFileUrl(resolved);
-		const text = yield* fs.readFileString(manifestPath);
-		return Result.match(S.decodeUnknownResult(S.fromJsonString(ManifestSchema))(text), {
-			onFailure: () => Option.none(),
-			onSuccess: (manifest) => Option.some(manifest.version ?? "")
-		});
-	}).pipe(Effect.orElseSucceed(() => Option.none()));
-	const discoverDependencies = () => Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const pathService = yield* Path.Path;
-		const pairs = yield* Effect.forEach(MANIFEST_SPECIFIERS, (specifier) => Effect.map(readManifestVersion(fs, pathService, specifier), (version) => [specifier, version]), { concurrency: 24 });
-		return Object.fromEntries(pairs.flatMap(([specifier, version]) => Option.match(version, {
-			onNone: () => [],
-			onSome: (present) => [[specifier, present]]
-		})));
-	});
-	const determineExitCode = (metrics) => Effect.gen(function* () {
-		const { mutationScore } = metrics.metrics;
-		const breaking = input.options.thresholds.break;
-		const formattedScore = mutationScore.toFixed(2);
-		const verdict = verdictExitClass(mutationScore, breaking);
-		if (verdict === null) {
-			yield* Match.value(breaking).pipe(Match.when(null, () => Effect.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.logInfo(`Final mutation score of ${formattedScore} is greater than or equal to break threshold ${String(threshold)}`)));
-			return null;
-		}
-		yield* Effect.logError(`Final mutation score ${formattedScore} under breaking threshold ${String(breaking)}, setting exit code to 1 (failure).`);
-		yield* Effect.logInfo("(improve mutation score or set `thresholds.break = null` to prevent this error in the future)");
-		return verdict;
-	});
-	const emitVerdict = (report, pathService) => Effect.gen(function* () {
-		const envelope = buildVerdictEnvelope(report, input.resolvedMode.mode, input.resolvedMode.signal, input.runId, input.basePath, pathService);
-		const queue = yield* RunEvents;
-		yield* Queue.offer(queue, VerdictReached.make({
-			schemaVersion: envelope.schemaVersion,
-			runId: envelope.runId,
-			mode: envelope.mode,
-			signal: envelope.signal,
-			score: envelope.score,
-			thresholds: envelope.thresholds,
-			reportFile: envelope.reportFile,
-			counts: envelope.counts,
-			mutants: envelope.mutants
-		}));
-	});
-	const reportAll = (results) => Effect.gen(function* () {
-		const pathService = yield* Path.Path;
-		const report = yield* mutationTestReport(results);
-		const metrics = calculateMetrics(report.files);
-		yield* offerTerminalReport(input.reporterStage, report, metrics);
-		const terminalDrain = terminalDrainClass(yield* closeReporterStage(input.reporterStage));
-		const finalVerdict = highestExitClass([yield* determineExitCode(metrics), terminalDrain].filter((candidate) => candidate !== null));
-		yield* emitVerdict(report, pathService);
-		if (input.options.incremental) {
-			const fs = yield* FileSystem.FileSystem;
-			const dir = pathService.dirname(input.options.incrementalFile);
-			yield* fs.makeDirectory(dir, { recursive: true });
-			const json = yield* S.encodeEffect(S.fromJsonString(S.Unknown, { space: 2 }))(report).pipe(Effect.orDie);
-			yield* fs.writeFileString(input.options.incrementalFile, json);
-		}
-		return {
-			results,
-			verdict: finalVerdict
-		};
-	});
-	const writeAtomic = (file, content) => Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const pathService = yield* Path.Path;
-		yield* fs.makeDirectory(pathService.dirname(file), { recursive: true });
-		const tmp = `${file}.tmp`;
-		yield* fs.writeFileString(tmp, content);
-		yield* fs.rename(tmp, file).pipe(Effect.catch(() => fs.copyFile(tmp, file).pipe(Effect.andThen(fs.remove(tmp)))));
-	});
-	const slimIncrementalReport = (results) => Effect.gen(function* () {
-		const { files, testFiles } = yield* assembleReport(results);
-		return {
-			schemaVersion: "1.0",
-			thresholds: input.options.thresholds,
-			files,
-			testFiles
-		};
-	});
-	const checkpoint = (results) => Effect.gen(function* () {
-		if (!input.options.incremental) return;
-		const report = yield* slimIncrementalReport(results);
-		const json = yield* S.encodeEffect(S.fromJsonString(S.Unknown))(report).pipe(Effect.orDie);
-		yield* writeAtomic(input.options.incrementalFile, json);
-	});
-	return {
-		reportCheckFailure,
-		reportMutantRunResult,
-		reportAll,
-		checkpoint
-	};
-};
-//#endregion
-//#region src/run/mutation-test.cell.ts
-const readCurrentRelativeFiles = (project, basePath) => Effect.gen(function* () {
-	const entries = yield* Effect.forEach(MutableHashMap.values(project.files), (file) => Effect.map(readOriginal(file), (content) => [toRelativeNormalizedFileName(file.name, basePath), content]), { concurrency: 24 });
-	return Object.fromEntries(entries);
-});
-const rememberedCoveredBy = (entry) => Option.match(Option.fromNullishOr(entry.coveredBy), {
-	onNone: () => ({}),
-	onSome: (coveredBy) => ({ coveredBy: [...coveredBy] })
-});
-const rememberedKilledBy = (entry) => Option.match(Option.fromNullishOr(entry.killedBy), {
-	onNone: () => ({}),
-	onSome: (killedBy) => ({ killedBy: [...killedBy] })
-});
-const rememberedCoverage = (entry) => ({
-	...rememberedCoveredBy(entry),
-	...rememberedKilledBy(entry)
-});
-const rememberedResultOf = (mutant, entry) => Object.assign({}, mutant, {
-	location: toSchemaLocation(mutant.location),
-	status: entry.status,
-	statusReason: REMEMBERED_REASON,
-	testsCompleted: entry.testsCompleted
-}, rememberedCoverage(entry));
-const rememberedResultsOf = (mutants, remembered) => {
-	const byId = new Map(mutants.map((mutant) => [mutant.id, mutant]));
-	return remembered.flatMap((entry) => Option.match(Option.fromNullishOr(byId.get(entry.mutantId)), {
-		onNone: () => [],
-		onSome: (mutant) => [rememberedResultOf(mutant, entry)]
-	}));
-};
-const isRunPlan = (plan) => plan.plan === "Run";
-const earlyResultOf = (plan) => Object.assign({}, plan.mutant, {
-	location: toSchemaLocation(plan.mutant.location),
-	status: plan.mutant.status ?? "Ignored"
-});
-const collectPlan = (plan, coveredPlans, earlyResults) => Match.value(plan).pipe(Match.when(isRunPlan, (runPlan) => {
-	coveredPlans.push(runPlan);
-}), Match.orElse((earlyPlan) => {
-	earlyResults.push(earlyResultOf(earlyPlan));
-}));
-const partitionPlans = (plans) => {
-	const coveredPlans = [];
-	const earlyResults = [];
-	plans.forEach((plan) => collectPlan(plan, coveredPlans, earlyResults));
-	return {
-		coveredPlans,
-		earlyResults
-	};
-};
-const VALID_MUTANT_STATUS_SET = /* @__PURE__ */ new Set([
-	"Killed",
-	"Survived",
-	"NoCoverage",
-	"Timeout",
-	"CompileError",
-	"RuntimeError",
-	"Ignored",
-	"Pending"
-]);
-function isMutantStatus(s) {
-	return VALID_MUTANT_STATUS_SET.has(s);
-}
-const toReportedMutant = (mutant) => Object.assign(mutant, {
-	coveredBy: mutant.coveredBy,
-	static: mutant.static
-});
-const makeCheckerPool = (prev, idGenerator) => Effect.gen(function* () {
-	const checkerName = Option.getOrUndefined(Option.fromUndefinedOr(prev.options.checkers[0]));
-	if (checkerName === void 0) return;
-	const checkerEntry = yield* resolvePluginWorkerEntry({
-		loaded: prev.loadedPlugins,
-		kind: "Checker",
-		name: checkerName
-	}).pipe(Effect.mapError(missingWorkerEntry("mutationTest", "checker", checkerName)));
-	return yield* Pool.make({
-		acquire: createCheckerFactory(prev.options, prev.project.fileDescriptions, checkerEntry.entrypoint, idGenerator, prev.sandbox.workingDirectory),
-		size: prev.concurrency.checkers
-	});
-});
-const passedCheck = (result) => result.status === "passed";
-const reportCheckOutcome = ([plan, result], reporting) => Match.value(result).pipe(Match.when(passedCheck, () => Effect.void), Match.orElse((failed) => reporting.reportCheckFailure(toReportedMutant(plan.mutant), failed).pipe(Effect.asVoid)));
-const checkPlansWithOneChecker = (checkerPool, checkerName, plans, reporting) => Effect.gen(function* () {
-	const checked = yield* Effect.scoped(Effect.flatMap(Pool.get(checkerPool), (checker) => checkGroupedPlans(checker, checkerName, plans).pipe(Effect.catchTags({
-		OutOfMemoryError: (error) => Effect.flatMap(Pool.invalidate(checkerPool, checker), () => Effect.fail(error)),
-		ChildProcessCrashedError: (error) => Effect.flatMap(Pool.invalidate(checkerPool, checker), () => Effect.fail(error))
-	}))));
-	yield* Effect.forEach(checked, (pair) => reportCheckOutcome(pair, reporting), {
-		concurrency: 1,
-		discard: true
-	});
-	return checked.filter(([, result]) => result.status === "passed").map(([plan]) => plan);
-});
-const checkPlansWithEachChecker = (prev, checkerPool, plans, reporting) => Effect.gen(function* () {
-	let passed = plans;
-	for (const checkerName of prev.options.checkers) passed = yield* checkPlansWithOneChecker(checkerPool, checkerName, passed, reporting);
-	return passed;
-});
-const checkPlansWithConfiguredCheckers = (prev, checkerPool, plans, reporting) => Option.match(Option.fromNullishOr(checkerPool), {
-	onNone: () => Effect.succeed(plans),
-	onSome: (pool) => checkPlansWithEachChecker(prev, pool, plans, reporting)
-});
-const mutationTestCell$1 = Cell.layer({
-	read: (command) => Effect.gen(function* () {
-		yield* Scope.Scope;
-		return { prev: command };
-	}),
-	decode: (raw) => Result.succeed(MutationTestCommand.make({
-		dryRunOnly: raw.prev.options.dryRunOnly,
-		allowEmpty: raw.prev.options.allowEmpty,
-		testCount: raw.prev.dryRunResult.tests.length,
-		isZero: raw.prev.dryRunResult.tests.length === 0
-	})),
-	decide: admitMutationTest,
-	encode: (outcome) => outcome,
-	write: (outcome, raw) => withPhaseSpan("mutationTest", {
-		mutantCount: raw.prev.mutants.length,
-		testCount: raw.prev.dryRunResult.tests.length
-	}, () => Effect.gen(function* () {
-		const decision = yield* Result.match(outcome, {
-			onFailure: (err) => Effect.fail(StageError.make({
-				stage: err.stage,
-				reason: err.reason,
-				cause: err
-			})),
-			onSuccess: (d) => Effect.succeed(d)
-		});
-		return yield* Match.value(decision).pipe(Match.tag("MutationTestDryRunOnly", () => Effect.gen(function* () {
-			const env = yield* RunEnvironment;
-			const queue = yield* RunEvents;
-			const nowEmit = yield* Clock.currentTimeMillis;
-			yield* Queue.offer(queue, PhaseEntered.make({
-				phase: "mutation-test",
-				elapsedMs: nowEmit - env.runStartedAt
-			}));
-			yield* Effect.logInfo("The dry-run has been completed successfully. No mutations have been executed.");
-			return {
-				results: [],
-				verdict: null
-			};
-		})), Match.tag("MutationTestNoTests", () => Effect.gen(function* () {
-			const env = yield* RunEnvironment;
-			const queue = yield* RunEvents;
-			const now = yield* Clock.currentTimeMillis;
-			const elapsed = Duration.millis(now - env.runStartedAt);
-			yield* Effect.logInfo(`Done in ${Duration.format(elapsed)}.`);
-			const nowEmit = yield* Clock.currentTimeMillis;
-			yield* Queue.offer(queue, PhaseEntered.make({
-				phase: "mutation-test",
-				elapsedMs: nowEmit - env.runStartedAt
-			}));
-			return {
-				results: [],
-				verdict: null
-			};
-		})), Match.tag("MutationTestProceed", () => Effect.gen(function* () {
-			const prev = raw.prev;
-			const env = yield* RunEnvironment;
-			yield* Effect.gen(function* () {
-				const nowEmit = yield* Clock.currentTimeMillis;
-				const queue = yield* RunEvents;
-				yield* Queue.offer(queue, PhaseEntered.make({
-					phase: "mutation-test",
-					elapsedMs: nowEmit - env.runStartedAt
-				}));
-			});
-			const idGenerator = yield* IdGenerator;
-			const checkerPool = yield* makeCheckerPool(prev, idGenerator);
-			const testRunnerContext = {
-				options: prev.options,
-				fileDescriptions: prev.project.fileDescriptions,
-				sandboxWorkingDirectory: prev.sandbox.workingDirectory,
-				idGenerator,
-				retire: Effect.void,
-				testFiles: prev.project.testFiles.map((file) => prev.sandbox.sandboxFileFor(file))
-			};
-			const testRunnerPool = yield* Pool.make({
-				acquire: buildTestRunner(testRunnerContext, Effect.suspend(() => resolvePluginWorkerEntry({
-					loaded: prev.loadedPlugins,
-					kind: "TestRunner",
-					name: prev.options.testRunner
-				}).pipe(Effect.mapError(missingWorkerEntry("mutationTest", "test runner", prev.options.testRunner)), Effect.flatMap((runnerEntry) => makeChildProcessTestRunner({
-					options: prev.options,
-					fileDescriptions: prev.project.fileDescriptions,
-					sandboxWorkingDirectory: prev.sandbox.workingDirectory,
-					workerEntrypoint: runnerEntry.entrypoint,
-					idGenerator
-				}))))),
-				size: prev.concurrency.testRunners
-			});
-			const reporting = makeMutationReportingService({
-				reporterStage: prev.reporterStage,
-				options: prev.options,
-				project: prev.project,
-				testCoverage: prev.testCoverage,
-				runId: env.runId,
-				resolvedMode: env.resolvedMode,
-				sandboxDirectory: prev.sandbox.workingDirectory,
-				basePath: env.basePath
-			});
-			const sandboxFileByName = Object.fromEntries([...MutableHashMap.keys(prev.project.filesToMutate)].map((name) => [name, prev.sandbox.sandboxFileFor(name)]));
-			const currentRelativeFiles = yield* readCurrentRelativeFiles(prev.project, env.basePath);
-			const incremental = incrementalDiff({
-				currentMutants: prev.mutants,
-				testCoverage: prev.testCoverage,
-				incrementalReport: prev.project.incrementalReport,
-				currentRelativeFiles,
-				basePath: env.basePath,
-				force: prev.options.force
-			});
-			const rememberedResults = rememberedResultsOf(prev.mutants, incremental.remembered);
-			yield* Effect.when(Effect.logInfo(`Incremental mode: reusing ${rememberedResults.length} mutant result(s), running ${incremental.mutants.length} mutant(s).`), Effect.succeed(rememberedResults.length > 0));
-			const { coveredPlans, earlyResults: noCoverageResults } = partitionPlans(yield* decidePlans(incremental.mutants, prev.testCoverage, {
-				disableBail: prev.options.disableBail,
-				timeoutMS: prev.options.timeoutMS,
-				timeoutFactor: prev.options.timeoutFactor,
-				ignoreStatic: prev.options.ignoreStatic
-			}, Duration.toMillis(prev.timeOverhead), void 0, sandboxFileByName));
-			const sortedPlans = [...coveredPlans].sort((a, b) => Number(a.runOptions.reloadEnvironment) - Number(b.runOptions.reloadEnvironment));
-			const allPlansForReporter = [...sortedPlans];
-			yield* offerReporterEvent(prev.reporterStage, MutationTestingPlanReady.make({
-				total: allPlansForReporter.length + noCoverageResults.length + rememberedResults.length,
-				plans: allPlansForReporter.map((plan) => ({
-					mutantId: plan.mutant.id,
-					plan: plan.plan,
-					netTime: plan.netTime,
-					reloadEnvironment: plan.runOptions.reloadEnvironment
-				}))
-			})).pipe(Effect.ignoreCause);
-			{
-				const queue2 = yield* RunEvents;
-				yield* Queue.offer(queue2, PlanKnown.make({ total: allPlansForReporter.length + noCoverageResults.length }));
-			}
-			const passedPlans = yield* checkPlansWithConfiguredCheckers(prev, checkerPool, sortedPlans, reporting);
-			const testRunnerStream = Stream.fromIterable(passedPlans);
-			const plannedTotal = allPlansForReporter.length + noCoverageResults.length + rememberedResults.length;
-			const pathService = yield* Path.Path;
-			const progressQueue = yield* RunEvents;
-			const completedRef = yield* Ref.make(0);
-			const preparedStreamableOf = (result) => {
-				if (!isMutantStatus(result.status)) return;
-				return {
-					status: result.status,
-					file: reportFileName(pathService.relative(env.basePath, result.fileName)),
-					location: toSchemaLocation(result.location)
-				};
-			};
-			const toStreamEvent = (result, completed, prepared) => MutantTested.make({
-				id: result.id,
-				status: prepared.status,
-				file: prepared.file,
-				location: prepared.location,
-				mutator: result.mutatorName,
-				replacement: result.replacement,
-				completed,
-				total: plannedTotal
-			});
-			const offerFinished = (result, prepared) => Effect.gen(function* () {
-				if (prepared === void 0) return;
-				const completed = yield* Ref.updateAndGet(completedRef, (n) => n + 1);
-				yield* Queue.offer(progressQueue, RunMutantTested.make({
-					id: result.id,
-					status: prepared.status,
-					file: prepared.file,
-					location: prepared.location,
-					mutator: result.mutatorName,
-					replacement: result.replacement,
-					completed,
-					total: plannedTotal
-				}));
-				return completed;
-			});
-			const reportStreamTested = (result, completed, prepared) => offerReporterEvent(prev.reporterStage, toStreamEvent(result, completed, prepared)).pipe(Effect.catchCause((cause) => Effect.logWarning("Reporter stream failed handling mutantTested", cause)));
-			const offerStreamTested = (result, completed, prepared) => Option.match(Option.all([Option.fromNullishOr(completed), Option.fromNullishOr(prepared)]), {
-				onNone: () => Effect.void,
-				onSome: ([done, streamable]) => reportStreamTested(result, done, streamable)
-			});
-			const announceSettledMutant = (result) => Effect.gen(function* () {
-				const prepared = preparedStreamableOf(result);
-				const completed = yield* offerFinished(result, prepared);
-				yield* offerStreamTested(result, completed, prepared);
-			});
-			yield* Effect.forEach([...rememberedResults, ...noCoverageResults], announceSettledMutant, {
-				concurrency: 1,
-				discard: true
-			});
-			const completedMutants = yield* Ref.make([...rememberedResults, ...noCoverageResults]);
-			const checkpointGate = yield* Semaphore.make(1);
-			yield* reporting.checkpoint(yield* Ref.get(completedMutants)).pipe(Effect.catchCause((cause) => Effect.logWarning("Failed to persist the mutation checkpoint", cause)));
-			const persist = (result) => checkpointGate.withPermits(1)(Effect.gen(function* () {
-				const next = yield* Ref.updateAndGet(completedMutants, (prev) => [...prev, result]);
-				yield* reporting.checkpoint(next).pipe(Effect.catchCause((cause) => Effect.logWarning("Failed to persist the mutation checkpoint", cause)));
-			}));
-			const runResults = yield* withPhaseSpan("mutationTest.batch", {
-				total: plannedTotal,
-				testRunners: prev.concurrency.testRunners
-			}, () => Stream.mapEffect(testRunnerStream, (plan) => Effect.scoped(Effect.gen(function* () {
-				const pool = testRunnerPool;
-				const runner = yield* Pool.get(pool);
-				const result = yield* runner.mutantRun(plan.runOptions).pipe(Effect.catchTags({
-					OutOfMemoryError: (error) => Effect.flatMap(Pool.invalidate(pool, runner), () => Effect.fail(error)),
-					ChildProcessCrashedError: (error) => Effect.flatMap(Pool.invalidate(pool, runner), () => Effect.fail(error))
-				}));
-				const reported = yield* reporting.reportMutantRunResult(toReportedMutant(plan.mutant), result);
-				const prepared = preparedStreamableOf(reported);
-				const finished = yield* offerFinished(reported, prepared);
-				yield* offerStreamTested(reported, finished, prepared);
-				yield* persist(reported);
-				return reported;
-			})), { concurrency: Math.max(1, prev.concurrency.testRunners) }).pipe(Stream.runCollect, Effect.map((chunk) => [...chunk])));
-			const allResults = [
-				...rememberedResults,
-				...noCoverageResults,
-				...runResults
-			];
-			const outcomeResult = yield* reporting.reportAll(allResults);
-			const doneNow = yield* Clock.currentTimeMillis;
-			const elapsed = Duration.millis(doneNow - env.runStartedAt);
-			yield* Effect.logInfo(`Done in ${Duration.format(elapsed)}.`);
-			return outcomeResult;
-		})), Match.exhaustive);
-	})).pipe(Effect.mapError((cause) => Match.value(cause).pipe(Match.tag("StageError", (stage) => stage), Match.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({
-		stage: "mutationTest",
-		reason: `Checker "${breach.checkerName}" skipped requested mutants (${breach.phase} phase): ${breach.missingIds.join(", ")}`,
-		cause: breach
-	})), Match.tag("ChildProcessCrashedError", "OutOfMemoryError", "PlatformError", "TestRunnerFailed", () => StageError.make({
-		stage: "mutationTest",
-		reason: "Mutation testing failed",
-		cause
-	})), Match.exhaustive)))
-});
-//#endregion
-//#region src/select-reporters.ts
-const STREAM_REPORTER = "progress-stream";
-const HUMAN_REPORTER = "clear-text";
-const STDOUT_REPORTERS = {
-	"clear-text": true,
-	"progress": true
-};
-const asHumanReporter = (name) => {
-	if (name === STREAM_REPORTER) return HUMAN_REPORTER;
-	return name;
-};
-const selectReporters = (configured, mode) => Match.value(mode).pipe(Match.when("human", () => [...new Set(configured.map(asHumanReporter))]), Match.when("machine", () => {
-	const permitted = configured.filter((name) => STDOUT_REPORTERS[name] !== true);
-	return Match.value(permitted.includes(STREAM_REPORTER)).pipe(Match.when(true, () => permitted), Match.when(false, () => [...permitted, STREAM_REPORTER]), Match.exhaustive);
-}), Match.exhaustive);
-//#endregion
-//#region src/run/plan-prepare.workflow.ts
-const PrepareDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/PrepareDecision");
-var PrepareDecoded = class extends S.Class("PrepareDecoded")({
-	mode: S.Literals(["human", "machine"]),
-	reporters: S.Array(S.String),
-	fileCount: S.Finite,
-	availableReporters: S.Array(S.String)
-}) {};
-var HumanReporters = class extends S.TaggedClass()("HumanReporters", { reporters: S.Array(S.String) }) {
-	[PrepareDecisionTypeId] = PrepareDecisionTypeId;
-};
-var MachineReporters = class extends S.TaggedClass()("MachineReporters", { reporters: S.Array(S.String) }) {
-	[PrepareDecisionTypeId] = PrepareDecisionTypeId;
-};
-const planPrepare = Workflow.total(PrepareDecoded, (decoded) => Match.value(decoded.mode).pipe(Match.when("human", () => Result.succeed(HumanReporters.make({ reporters: decoded.reporters }))), Match.when("machine", () => Result.succeed(MachineReporters.make({ reporters: decoded.reporters }))), Match.exhaustive));
-//#endregion
-//#region src/run/prepare.cell.ts
-const isRecord = Predicate.isObject;
-const asRecord = (value) => Match.value(value).pipe(Match.when(isRecord, (record) => Object.fromEntries(Object.entries(record))), Match.orElse(() => ({})));
-const schemaPropertiesOf = (document) => asRecord(asRecord(document)["properties"]);
-const buildMergedSchema = (core, contributions) => Match.value(contributions.length === 0).pipe(Match.when(true, () => core), Match.orElse(() => ({
-	...core,
-	properties: Object.assign({}, schemaPropertiesOf(core), ...contributions.map((contribution) => schemaPropertiesOf(contribution)))
-})));
-const announceSummary = (env, summary) => Match.value(env.resolvedMode.mode).pipe(Match.when("human", () => announceHumanSummary(env.allowConsoleColors, summary)), Match.orElse(() => Effect.logInfo(summary)));
-const announceHumanSummary = (allowConsoleColors, summary) => Match.value(allowConsoleColors).pipe(Match.when(true, () => Console.log(ansi.green(summary))), Match.orElse(() => Console.log(summary)));
-const NO_PLUGIN_DESCRIPTORS = [];
-const spawnPluginReporterFactory = (name, loaded, projectBasePath, options) => Effect.gen(function* () {
-	const entry = yield* resolvePluginWorkerEntry({
-		loaded,
-		kind: "Reporter",
-		name
-	}).pipe(Effect.mapError(missingWorkerEntry("prepare", "reporter", name)));
-	const client = yield* spawnReporterWorker({
-		entrypoint: entry.entrypoint,
-		projectBasePath,
-		execArgv: [],
-		options,
-		tempDirPrefix: "stryker-reporter-"
-	}).pipe(Effect.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: `Failed to start the reporter worker "${name}"`,
-		cause
-	})));
-	return reporterWorkerFactory(client);
-});
-const reporterInputsOf = (names, choicesByName, loaded, projectBasePath, options) => Effect.forEach(selectReporterChoices(names, choicesByName), (choice) => Option.match(choice.builtinFactory, {
-	onSome: (builtin) => Effect.succeed({
-		name: choice.name,
-		factory: builtin
-	}),
-	onNone: () => Effect.map(spawnPluginReporterFactory(choice.name, loaded, projectBasePath, options), (factory) => ({
-		name: choice.name,
-		factory
-	}))
-}), { concurrency: 1 });
-const selectReporter = (chosen, name, choicesByName) => {
-	const key = name.toLowerCase();
-	Option.match(HashMap.get(choicesByName, key), {
-		onNone: () => void 0,
-		onSome: (choice) => {
-			if (!chosen.has(key)) chosen.set(key, choice);
-		}
-	});
-};
-const selectReporterChoices = (names, choicesByName) => {
-	const chosen = /* @__PURE__ */ new Map();
-	names.forEach((name) => selectReporter(chosen, name, choicesByName));
-	return [...chosen.values()];
-};
-const readPrepare = (command) => Effect.gen(function* () {
-	yield* Scope.Scope;
-	const env = yield* RunEnvironment;
-	const queue = yield* RunEvents;
-	const coreSchema = forkCoreSchema;
-	const configured = yield* readConfig(command.cliOptions, {
-		command: "run",
-		mode: env.resolvedMode.mode
-	}).pipe(Effect.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: "Failed to read config",
-		cause
-	})), Effect.tapCause(() => Effect.gen(function* () {
-		const now = yield* Clock.currentTimeMillis;
-		yield* Queue.offer(queue, PhaseEntered.make({
-			phase: "prepare",
-			elapsedMs: now - env.runStartedAt
-		}));
-	}).pipe(Effect.ignore)));
-	const resolvedReporters = selectReporters([...configured.reporters], env.resolvedMode.mode);
-	const options = {
-		...configured,
-		reporters: resolvedReporters,
-		allowConsoleColors: env.allowConsoleColors,
-		clearTextReporter: {
-			...configured.clearTextReporter,
-			allowColor: env.allowConsoleColors
-		}
-	};
-	const descriptors = [...options.plugins, ...options.appendPlugins];
-	const loaded = yield* loadPlugins(descriptors).pipe(Effect.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: "Failed to load plugins",
-		cause
-	})));
-	const mergedSchema = buildMergedSchema(coreSchema, loaded.schemaContributions);
-	const record = { ...options };
-	yield* validateOptions(record, mergedSchema).pipe(Effect.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: "Failed to revalidate options with plugin schema",
-		cause
-	})));
-	const project = yield* readProject(options, command.targetMutatePatterns, env.basePath).pipe(Effect.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: "Failed to read project",
-		cause
-	})));
-	const selectedIgnorers = HashSet.fromIterable(options.ignorers);
-	const ignorers = loaded.ignorers.filter((ignorer) => HashSet.has(selectedIgnorers, ignorer.name));
-	const builtinReporterFactories = {
-		...makeBuiltinReporterFactories({
-			fileSystem: yield* FileSystem.FileSystem,
-			path: yield* Path.Path,
-			stdio: yield* Stdio.Stdio
-		}),
-		...env.builtinReporters
-	};
-	const pluginReporterDescriptors = Option.getOrElse(HashMap.get(loaded.pluginsByKind, "Reporter"), () => NO_PLUGIN_DESCRIPTORS);
-	return {
-		env,
-		queue,
-		options,
-		loaded,
-		project,
-		ignorers,
-		builtinReporterFactories,
-		reporterChoicesByName: HashMap.fromIterable([...Object.entries(builtinReporterFactories).map(([name, factory]) => [name.toLowerCase(), {
-			name,
-			builtinFactory: Option.some(factory)
-		}]), ...pluginReporterDescriptors.map((descriptor) => [descriptor.name.toLowerCase(), {
-			name: descriptor.name,
-			builtinFactory: Option.none()
-		}])])
-	};
-});
-const decodePrepare = (raw) => Result.succeed(PrepareDecoded.make({
-	mode: raw.env.resolvedMode.mode,
-	reporters: [...raw.options.reporters],
-	fileCount: MutableHashMap.size(raw.project.files),
-	availableReporters: [...HashMap.values(raw.reporterChoicesByName)].map((choice) => choice.name)
-}));
-const encodePrepareDecision = (outcome) => outcome;
-const writePrepare = (outcome, raw) => withPhaseSpan("prepare", {}, (span) => Effect.gen(function* () {
-	const decision = yield* Effect.fromResult(outcome);
-	const mutateCount = MutableHashMap.size(raw.project.filesToMutate);
-	yield* announceSummary(raw.env, `Found ${mutateCount} of ${MutableHashMap.size(raw.project.files)} file(s) to be mutated.`);
-	yield* validateReporterNames(raw.options.reporters, [...HashMap.values(raw.reporterChoicesByName)].map((choice) => choice.name)).pipe(Effect.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: cause.message,
-		cause
-	})));
-	yield* Match.value(MutableHashMap.size(raw.project.files)).pipe(Match.when(0, () => Effect.fail(StageError.make({
-		stage: "prepare",
-		reason: "No input files found.",
-		cause: PrepareError.make({
-			stage: "prepare",
-			reason: "No input files found."
-		})
-	}))), Match.orElse(() => Effect.void));
-	const temporaryDirectoryPath = yield* Effect.gen(function* () {
-		const live = TemporaryDirectoryLive(raw.options);
-		return (yield* Effect.service(TemporaryDirectory).pipe(Effect.provide(live))).path;
-	}).pipe(Effect.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: "Failed to create temporary directory",
-		cause
-	})));
-	const reporterInputs = yield* reporterInputsOf(Option.getOrElse(Match.value(decision).pipe(Match.tag("HumanReporters", (human) => Option.some(human.reporters)), Match.tag("MachineReporters", (machine) => Option.some(machine.reporters)), Match.exhaustive), () => raw.options.reporters), raw.reporterChoicesByName, raw.loaded, raw.env.basePath, raw.options);
-	const reporterInit = yield* currentReporterInit(span);
-	const reporterStage = yield* attachReporterFactories(reporterInputs, raw.options, reporterInit);
-	const now = yield* Clock.currentTimeMillis;
-	yield* Queue.offer(raw.queue, PhaseEntered.make({
-		phase: "prepare",
-		elapsedMs: now - raw.env.runStartedAt
-	}));
-	return {
-		project: raw.project,
-		loadedPlugins: raw.loaded,
-		ignorers: raw.ignorers,
-		options: raw.options,
-		temporaryDirectoryPath,
-		reporterStage
-	};
-}));
-const prepareCell = Cell.layer({
-	read: readPrepare,
-	decode: decodePrepare,
-	decide: planPrepare,
-	encode: encodePrepareDecision,
-	write: writePrepare
-});
-//#endregion
-//#region src/Run.ts
-const RUN_EVENTS_QUEUE_BOUND = 256;
-const makeRunLayer = (env, events) => {
-	const eventsLayer = Match.value(events).pipe(Match.when(void 0, () => Layer.effect(RunEvents, Queue.bounded(256))), Match.orElse((queue) => Layer.succeed(RunEvents, queue)));
-	return Layer.mergeAll(Layer.succeed(RunEnvironment, env), eventsLayer, layer, Layer.effect(Scope.Scope, Effect.gen(function* () {
-		const stageScope = yield* Scope.make();
-		yield* Effect.addFinalizer(() => Scope.close(stageScope, Exit.void));
-		return stageScope;
-	})));
-};
-const mutationTestCell = Cell.andThen(Cell.andThen(Cell.andThen(prepareCell, instrumentCell), dryRunCell), mutationTestCell$1);
-const shouldKeepTempDir = (exit, cleanTempDir) => Exit.isFailure(exit) && cleanTempDir !== "always";
-//#endregion
-//#region src/Output.ts
-const TICK_INTERVAL_MS = 1e4;
-var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js/Output/RunEventStreamPortTag") {};
-const RunEventStreamPort = RunEventStreamPortTag;
-const isTerminalEvent = (event) => Match.value(event).pipe(Match.tag("verdict", () => true), Match.tag("error", () => true), Match.tag("help", () => true), Match.orElse(() => false));
-const wireKind = (event) => Match.value(event).pipe(Match.tag("stream", () => "stream"), Match.tag("phase", () => "phase"), Match.tag("plan", () => "plan"), Match.tag("mutant", () => "mutant"), Match.tag("tick", () => "tick"), Match.tag("verdict", () => "verdict"), Match.tag("error", () => "error"), Match.tag("help", () => "help"), Match.exhaustive);
-const toWireLine = (event) => {
-	const fields = Object.fromEntries(Object.entries(event).filter(([key]) => key !== "_tag"));
-	return JSON.stringify({
-		kind: wireKind(event),
-		...fields
-	});
-};
-function numberText(value, fallback) {
-	if (typeof value === "number") return String(value);
-	return fallback;
-}
-function phaseLine(phase) {
-	if (typeof phase === "string") return `phase ${phase}`;
-	return "phase ";
-}
-const stderrProgressLine = (event, alreadyClosed) => {
-	if (alreadyClosed) return;
-	return Match.value(event).pipe(Match.tag("plan", (e) => `plan ${numberText(e.total, "0")} mutants`), Match.tag("phase", (e) => phaseLine(e.phase)), Match.tag("tick", (e) => `${numberText(e.completed, "0")}/${numberText(e.total, "?")} elapsed ${numberText(e.elapsedMs, "0")}ms`), Match.tag("verdict", (e) => `score ${numberText(e.score, "n/a")} killed ${numberText(e.counts.killed, "0")} survived ${numberText(e.counts.survived, "0")}`), Match.tag("error", (e) => {
-		if (typeof e.error === "string") return `error ${e.error}`;
-		return "error ";
-	}), Match.orElse(() => void 0));
-};
-const writeStderr = (stdio, line) => Stream.run(Stream.succeed(`${line}\n`), stdio.stderr({ endOnDone: false })).pipe(Effect.ignore);
-const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect.ignore);
-const makeRunEventStream = (stdio, resolved, drainFramed = drainOf.bind(null, stdio)) => Effect.gen(function* () {
-	const startedAt = yield* Clock.currentTimeMillis;
-	const runId = generateRunId(DateTime.makeUnsafe(startedAt));
-	const queue = yield* Queue.bounded(256);
-	const state = {
-		mode: resolved.mode,
-		signal: resolved.signal,
-		headerWritten: false,
-		terminalWritten: false,
-		progress: {
-			completed: 0,
-			total: null
-		}
-	};
-	const queueStream = Stream.fromQueue(queue).pipe(Stream.tap((event) => Effect.sync(() => {
-		Match.value(event).pipe(Match.tag("plan", (e) => {
-			state.progress = {
-				...state.progress,
-				total: e.total
-			};
-		}), Match.tag("mutant", (e) => {
-			state.progress = {
-				completed: e.completed,
-				total: e.total
-			};
-		}), Match.orElse(() => {}));
-	})));
-	const tickStream = Stream.tick(TICK_INTERVAL_MS).pipe(Stream.drop(1), Stream.filter(() => state.headerWritten && !state.terminalWritten), Stream.mapEffect(() => Effect.gen(function* () {
-		const now = yield* Clock.currentTimeMillis;
-		return Heartbeat.make({
-			elapsedMs: now - startedAt,
-			completed: state.progress.completed,
-			total: state.progress.total
-		});
-	})));
-	let terminalSeen = false;
-	const noteTerminal = (event) => {
-		state.terminalWritten = state.terminalWritten || isTerminalEvent(event);
-	};
-	const progressTap = (event) => {
-		const line = stderrProgressLine(event, state.terminalWritten);
-		noteTerminal(event);
-		return Option.match(Option.fromUndefinedOr(line), {
-			onNone: () => Effect.void,
-			onSome: (text) => writeStderr(stdio, text)
-		});
-	};
-	const framingOpen = () => state.mode === "machine" && !terminalSeen;
-	const markTerminalFramed = (event) => {
-		terminalSeen = terminalSeen || isTerminalEvent(event);
-	};
-	const frameEvent = (event) => {
-		if (!framingOpen()) return false;
-		markTerminalFramed(event);
-		return true;
-	};
-	const drain = drainFramed(Stream.merge(queueStream, tickStream, { haltStrategy: "either" }).pipe(Stream.tap(progressTap)).pipe(Stream.filter(frameEvent), Stream.map((event) => `${toWireLine(event)}\n`)));
-	let drainFiber = null;
-	const outputOpen = () => state.mode === "machine" && !state.terminalWritten;
-	const offerStarted = () => Effect.gen(function* () {
-		if (state.mode !== "machine") return;
-		yield* Queue.offer(queue, RunStarted.make({
-			schemaVersion: "1.0",
-			runId,
-			mode: state.mode,
-			signal: state.signal
-		}));
-	});
-	const openHeader = () => Effect.gen(function* () {
-		if (state.headerWritten) return;
-		state.headerWritten = true;
-		yield* offerStarted();
-	});
-	return {
-		queue,
-		runId,
-		startedAt,
-		isOpen: () => outputOpen() && drainFiber !== null,
-		ensureOpen: (openResolved) => {
-			if (state.headerWritten) return;
-			state.mode = openResolved.mode;
-			state.signal = openResolved.signal;
-		},
-		open: Effect.gen(function* () {
-			if (drainFiber !== null) return;
-			yield* openHeader();
-			drainFiber = yield* Effect.forkDetach(drain);
-		}),
-		closeAndDrain: Effect.gen(function* () {
-			state.terminalWritten = true;
-			yield* Queue.end(queue);
-			if (drainFiber !== null) yield* Fiber.join(drainFiber);
-		})
-	};
-});
-Layer.effect(RunEventStreamPort, Effect.map(Stdio.Stdio, (stdio) => RunEventStreamPort.of({ createRunEventStream: (resolved) => makeRunEventStream(stdio, resolved) })));
-const TOOL_VARIABLES = ["CLAUDECODE", "CODEX_SANDBOX"];
-const decisionToResolvedMode = (decision) => Match.value(decision).pipe(Match.tag("HumanOutput", (human) => ({
-	mode: "human",
-	signal: human.signal,
-	stdoutIsTTY: human.stdoutIsTTY
-})), Match.tag("MachineOutput", (machine) => ({
-	mode: "machine",
-	signal: machine.signal,
-	stdoutIsTTY: machine.stdoutIsTTY
-})), Match.exhaustive);
-const definedToolVars = (vars) => Object.fromEntries(Object.entries(vars ?? {}).filter((entry) => entry[1] !== void 0));
-const commandFor = (input) => ResolveModeCommand.make({
-	stdoutIsTTY: input.stdoutIsTTY,
-	text: input.text,
-	json: input.json,
-	envMode: input.envMode,
-	agent: input.agent,
-	toolVars: definedToolVars(input.toolVars)
-});
-function isColorEnabled(resolved, noColor) {
-	const requested = Option.exists(Option.fromUndefinedOr(noColor), S.is(S.NonEmptyString));
-	return resolved.mode === "human" && !requested;
-}
-var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js/Output/OutputModeProbeTag") {};
-const OutputModeProbe = OutputModeProbeTag;
-const envToolVars = () => Effect.forEach(TOOL_VARIABLES, (variable) => Config.string(variable).pipe(Effect.option, Effect.map((value) => [variable, Option.getOrUndefined(value)]))).pipe(Effect.map((entries) => definedToolVars(Object.fromEntries(entries))));
-const probeInput = (command) => Effect.gen(function* () {
-	const stdio = yield* Stdio.Stdio;
-	const envMode = yield* Config.string("STRYKER_MODE").pipe(Effect.option);
-	const agent = yield* Config.string("AGENT").pipe(Effect.option);
-	return {
-		stdoutIsTTY: yield* stdio.stdoutIsTerminal,
-		text: command.text,
-		json: command.json,
-		envMode: Option.getOrUndefined(envMode),
-		agent: Option.getOrUndefined(agent),
-		toolVars: yield* envToolVars()
-	};
-});
-const outputModeProbeCell = Cell.layer({
-	read: (command) => probeInput(command),
-	decode: (raw) => Result.succeed(commandFor(raw)),
-	decide: resolveOutputMode,
-	encode: (outcome) => Result.map(outcome, decisionToResolvedMode),
-	write: (outcome) => Result.match(outcome, {
-		onFailure: (error) => Effect.fail(error),
-		onSuccess: (mode) => Effect.succeed(mode)
-	})
-});
-const detectModeWithProbe = (flags = {}) => outputModeProbeCell.run(flags).pipe(Effect.mapError((error) => CliError.InvalidValue.make({
-	option: error.option,
-	value: error.value,
-	expected: error.expected,
-	kind: "flag"
-})));
-Layer.effect(OutputModeProbe, Effect.map(Stdio.Stdio, (stdio) => OutputModeProbe.of({ detectMode: Effect.provideService(detectModeWithProbe({}), Stdio.Stdio, stdio) })));
-//#endregion
-//#region src/StreamFile.ts
-const DEFAULT_PROGRESS_STREAM_FILE = "reports/mutation-stream.jsonl";
-const encodeUtf8 = (line) => new TextEncoder().encode(line);
-const drainStdoutAndFile = (stdio, fileName, framed) => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	yield* fs.makeDirectory(path.dirname(fileName), { recursive: true }).pipe(Effect.orDie);
-	yield* Effect.scoped(Effect.gen(function* () {
-		const handle = yield* fs.open(fileName, { flag: "w" });
-		const withFile = framed.pipe(Stream.tap((line) => handle.writeAll(encodeUtf8(line)).pipe(Effect.flatMap(() => handle.sync))));
-		yield* Stream.run(withFile, stdio.stdout({ endOnDone: true })).pipe(Effect.ignore);
-	})).pipe(Effect.orDie);
-});
-Layer.effect(RunEventStreamPort, Effect.gen(function* () {
-	const stdio = yield* Stdio.Stdio;
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const fileNameRef = yield* Ref.make(DEFAULT_PROGRESS_STREAM_FILE);
-	const drainFramed = (framed) => Effect.gen(function* () {
-		const fileName = yield* Ref.get(fileNameRef);
-		yield* drainStdoutAndFile(stdio, fileName, framed).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
-	});
-	return RunEventStreamPort.of({ createRunEventStream: (resolved) => Effect.gen(function* () {
-		return {
-			...yield* makeRunEventStream(stdio, resolved, drainFramed),
-			setProgressStreamFile: (fileName) => Ref.set(fileNameRef, fileName)
-		};
-	}) });
-}));
-//#endregion
-//#region src/run-host.ts
-const hostRunLayer = Layer.unwrap(Effect.map(Effect.all([RunEnvironment, RunEvents], { concurrency: 1 }), ([env, events]) => makeRunLayer(env, events))).pipe(Layer.provideMerge(nodePlatformLayer));
-const hostMutationTest = Cell.provide(mutationTestCell, hostRunLayer);
-const onHost = (host, effect) => effect.pipe(Effect.provide(hostRunLayer), Effect.provideService(RunEnvironment, host.env), Effect.provideService(RunEvents, host.events));
-const runOnHost = (host, command) => onHost(host, Effect.scoped(hostMutationTest.run(command)));
-const prepareCommandOf = (options, targetMutatePatterns) => ({
-	cliOptions: options,
-	targetMutatePatterns
-});
-const hostOptionsOf = (mode, stream, noColor) => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	return {
-		runId: stream.runId,
-		resolvedMode: mode,
-		runStartedAt: stream.startedAt,
-		basePath: yield* fs.realPath("."),
-		builtinReporters: { html: makeHtmlReporter },
-		allowConsoleColors: isColorEnabled(mode, noColor)
-	};
-});
-//#endregion
-//#region src/index.ts
-const HEADLESS_MODE = {
-	mode: "machine",
-	signal: "flag",
-	stdoutIsTTY: false
-};
-const strykerCell = (options, targetMutatePatterns) => Effect.gen(function* () {
-	const stdio = yield* Stdio.Stdio;
-	const stream = yield* makeRunEventStream(stdio, HEADLESS_MODE);
-	const env = yield* hostOptionsOf(HEADLESS_MODE, stream, void 0);
-	let patterns;
-	if (targetMutatePatterns !== void 0) patterns = [...targetMutatePatterns];
-	return yield* runOnHost({
-		env,
-		events: stream.queue
-	}, prepareCommandOf(options, patterns));
-});
-//#endregion
-export { RunMutantTested as A, SUPPORTED_CONFIG_FILE_NAMES as B, RunEvents as C, PhaseEntered as D, HelpRendered as E, ExitClass$1 as F, isModuleSpecifier as G, deepFreeze as H, highestExitClass as I, isWarningEnabled as K, resolveExitCode as L, RunStarted as M, VerdictReached as N, PlanKnown as O, EXIT_CODE as P, verdictExitClass as R, toRelativeNormalizedFileName as S, Heartbeat as T, defaultOptions as U, createDefaultOptions as V, findUnserializables as W, IncrementalReportSchema as _, shouldKeepTempDir as a, reporterWorkerFactory as b, buildVerdictEnvelope as c, strykerVersion as d, calculateMetrics as f, matchesFile as g, createFileMatcher as h, mutationTestCell as i, RunPhase as j, RunFailed as k, generateRunId as l, checkGroupedPlans as m, RUN_EVENTS_QUEUE_BOUND as n, ACTIONABLE_STATUSES as o, countMutants as p, optionsPath as q, makeRunLayer as r, VERDICT_ENVELOPE_SCHEMA_VERSION as s, strykerCell as t, isActionableStatus as u, RunEnvironment as v, RunIdentity as w, spawnReporterWorker as x, REPORTER_EVENT_BATCH_BOUND as y, CONFIG_SYNTAX_HELP as z };