@systemfsoftware/stryker-js 7.0.0 → 8.0.0

package/dist/{src-BY5pFAY5.mjs → src-WMC3thmX.mjs}

@@ -54,8 +54,10 @@ import * as RpcClient from "effect/unstable/rpc/RpcClient";
 import * as Schedule from "effect/Schedule";
 import * as Data from "effect/Data";
 import * as Equivalence from "effect/Equivalence";
+import * as Metric from "effect/Metric";
 import * as Pool from "effect/Pool";
 import * as Semaphore from "effect/Semaphore";
+import * as SchemaTransformation from "effect/SchemaTransformation";
 import { randomBytes } from "@noble/hashes/utils.js";
 import "effect/Sink";
 import * as NodeFileSystem$1 from "@effect/platform-node-shared/NodeFileSystem";
@@ -7917,6 +7919,24 @@ const instrument = (files, options, basePath) => Effect$1.gen(function* () {
 		mutants
 	});
 });
+//#endregion
+//#region ../stryker-js-plugin-interface/dist/index.mjs
+/** A position inside a file, in the coordinates the wire carries — 0-based line and column. */
+const CheckerPositionWire = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const CheckerLocationWire = S.Struct({
+	start: CheckerPositionWire,
+	end: CheckerPositionWire
+});
+const CheckerMutantWire = S.Struct({
+	id: S.NonEmptyString,
+	fileName: S.NonEmptyString,
+	mutatorName: S.NonEmptyString,
+	replacement: S.String,
+	location: CheckerLocationWire
+});
 S.Literals(["passed", "compileError"]);
 const CheckResultSchema$1 = S.Union([S.Struct({ status: S.Literal("passed") }), S.Struct({
 	status: S.Literal("compileError"),
@@ -8185,7 +8205,7 @@ const TestRunnerDryRunRequest = S.Struct({ options: DryRunOptionsSchema });
 const TestRunnerMutantRunRequest = S.Struct({ options: MutantRunOptionsSchema });
 const CheckerRequest = S.Struct({
 	checkerName: S.String,
-	mutants: S.Array(Mutant)
+	mutants: S.Array(CheckerMutantWire)
 });
 const CheckerCheckResult = S.Record(S.String, CheckResultSchema$1);
 const CheckerGroupResult = S.Array(S.Array(S.String));
@@ -9323,6 +9343,39 @@ const PreviousFileSchema = S.Struct({
 const PreviousTestFileSchema = S.Struct({ source: S.optional(S.String) });
 const PreviousFilesSchema = S.Record(S.String, PreviousFileSchema);
 const PreviousTestFilesSchema = S.Record(S.String, PreviousTestFileSchema);
+//#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);
 const ZERO = 0;
 const firstDefined = (first, second) => Option.getOrElse(Option.fromNullishOr(first), () => second);
 const staticField = (isStatic) => Option.match(Option.fromUndefinedOr(isStatic), {
@@ -9587,6 +9640,18 @@ const decidePlans = (mutants, testCoverage, options, timeOverheadMS, globalTestF
 	const command = coverageToCommand(mutants, testCoverage, options, timeOverheadMS, globalTestFilter, sandboxFileByName);
 	return makeMutantTestPlanner(command);
 };
+const isRunPlan = (plan) => plan.plan === "Run";
+const isEarlyPlan = (plan) => !isRunPlan(plan);
+const earlyResultOf = (plan) => Object.assign({}, plan.mutant, {
+	location: toSchemaLocation(plan.mutant.location),
+	status: plan.mutant.status ?? "Ignored"
+});
+const partitionRunPlans = (plans) => ({
+	runPlans: plans.filter(isRunPlan),
+	earlyResults: plans.filter(isEarlyPlan).map(earlyResultOf)
+});
+const byReloadEnvironment = (left, right) => Number(left.runOptions.reloadEnvironment) - Number(right.runOptions.reloadEnvironment);
+const sortRunPlans = (plans) => [...plans].sort(byReloadEnvironment);
 const REMEMBERED_STATUS = /* @__PURE__ */ new Set([
 	"Killed",
 	"Survived",
@@ -12972,6 +13037,29 @@ const admitMutationTest = Workflow.make(MutationTestCommand, (command) => Match.
 	allowEmpty: true
 }, () => Result.succeed(MutationTestNoTests.make({}))), Match.orElse(() => Result.succeed(MutationTestProceed.make({})))));
 //#endregion
+//#region src/checker-mutant-wire.ts
+const CheckerMutantFromMutant = Mutant.pipe(S.decodeTo(CheckerMutantWire, SchemaTransformation.transform({
+	decode: (m) => ({
+		id: m.id,
+		fileName: m.fileName,
+		mutatorName: m.mutatorName,
+		replacement: m.replacement,
+		location: m.location
+	}),
+	encode: (w) => Mutant.make({
+		id: w.id,
+		fileName: w.fileName,
+		mutatorName: w.mutatorName,
+		replacement: w.replacement,
+		location: w.location
+	})
+})));
+const wireRecordOf = (mutant) => Result.mapError(S.decodeUnknownResult(CheckerMutantFromMutant)(mutant), (error) => ({
+	id: mutant.id,
+	fileName: mutant.fileName,
+	reason: error.message
+}));
+//#endregion
 //#region src/admit-checker-answer.workflow.ts
 var CheckerAnsweredUnrequested = class extends S.TaggedError()("CheckerAnsweredUnrequested", {
 	checkerName: S.String,
@@ -13039,6 +13127,19 @@ const evaluateCheckResult = (command) => {
 };
 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/metrics.ts
+const checkerDuration = Metric.timer("stryker.checker.duration", { description: "Checker worker RPC duration in milliseconds" });
+const checkerMutantsChecked = Metric.counter("stryker.checker.mutants.checked", { description: "Total number of mutants a checker worker answered for" });
+const checkerMutantsSkipped = Metric.counter("stryker.checker.mutants.skipped", { description: "Total number of mutants dropped because they cannot be described to a checker" });
+const checkerRpcFailures = Metric.counter("stryker.checker.rpc_failures", {
+	description: "Checker worker RPC calls that did not complete, excluding interruptions",
+	incremental: true
+});
+const checkerProcessCrashes = Metric.counter("stryker.checker.process_crashes", {
+	description: "Checker worker processes that never became usable",
+	incremental: true
+});
+//#endregion
 //#region src/Checker.ts
 /**
 * Checker — the Checker capability.
@@ -13154,16 +13255,20 @@ const makeCheckerChildProcess = (params) => Effect$1.gen(function* () {
 		execArgv: [...params.execArgv],
 		optionsJson,
 		tempDirPrefix: "stryker-checker-"
-	}).pipe(Effect$1.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)));
+	}).pipe(Effect$1.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)), Effect$1.tapError(() => Metric.update(checkerProcessCrashes, 1)));
+	const recordCheckerCall = (spanName, checkerName, mutants, call) => call.pipe(Effect$1.withSpan(spanName, { attributes: {
+		"stryker.checker.name": checkerName,
+		"stryker.mutants.count": mutants.length
+	} }), Effect$1.timed, Effect$1.onExit((exit) => Match.value(exit).pipe(Match.tag("Success", () => Metric.update(checkerMutantsChecked, mutants.length)), Match.tag("Failure", (failure) => Match.value(Cause.hasInterruptsOnly(failure.cause)).pipe(Match.when(true, () => Effect$1.void), Match.orElse(() => Metric.update(checkerRpcFailures, 1)))), Match.exhaustive)), Effect$1.tap(([duration]) => Metric.update(checkerDuration, duration)), Effect$1.map(([, result]) => result), Effect$1.mapError((error) => crashed(error.message)));
 	return {
-		check: (checkerName, mutants) => client.check({
+		check: (checkerName, mutants) => recordCheckerCall("stryker.checker.check", checkerName, mutants, client.check({
 			checkerName,
 			mutants: [...mutants]
-		}).pipe(Effect$1.mapError((error) => crashed(error.message))),
-		group: (checkerName, mutants) => client.group({
+		})),
+		group: (checkerName, mutants) => recordCheckerCall("stryker.checker.group", checkerName, mutants, client.group({
 			checkerName,
 			mutants: [...mutants]
-		}).pipe(Effect$1.mapError((error) => crashed(error.message)))
+		}))
 	};
 });
 const createCheckerFactory = (options, fileDescriptions, workerEntrypoint, idGenerator, workingDirectory) => makeCheckerChildProcess({
@@ -13194,6 +13299,69 @@ const writeGroupOutcome = (plans, checkerName, outcome) => Result.match(outcome,
 	onFailure: (error) => Effect$1.fail(error),
 	onSuccess: (decision) => writeGroupDecision(plans, checkerName, decision)
 });
+const partitionMutantsForWire = (plans) => {
+	const wire = [];
+	const undescribable = [];
+	plans.forEach((plan) => Result.match(wireRecordOf(plan.mutant), {
+		onSuccess: (wireMutant) => {
+			wire.push(wireMutant);
+		},
+		onFailure: (refused) => {
+			undescribable.push(refused);
+		}
+	}));
+	return {
+		wire,
+		undescribable
+	};
+};
+const compileErrorAnswersOf = (undescribable) => Object.fromEntries(undescribable.map((mutant) => [mutant.id, {
+	status: "compileError",
+	reason: mutant.reason
+}]));
+const singletonGroupsOf = (undescribable) => undescribable.map((mutant) => [mutant.id]);
+const undescribableIdsOf = (undescribable) => new Set(undescribable.map((mutant) => mutant.id));
+const lookupOf = (partitioned) => ({
+	wireById: new Map(partitioned.wire.map((mutant) => [mutant.id, mutant])),
+	undescribableById: new Map(partitioned.undescribable.map((mutant) => [mutant.id, mutant]))
+});
+const selectedFromLookup = (plans, lookup) => {
+	const wire = [];
+	const undescribable = [];
+	plans.forEach((plan) => {
+		Option.match(Option.fromUndefinedOr(lookup.wireById.get(plan.mutant.id)), {
+			onSome: (wired) => {
+				wire.push(wired);
+			},
+			onNone: () => Option.match(Option.fromUndefinedOr(lookup.undescribableById.get(plan.mutant.id)), {
+				onSome: (refused) => {
+					undescribable.push(refused);
+				},
+				onNone: () => {
+					Result.match(wireRecordOf(plan.mutant), {
+						onSuccess: (wired) => {
+							wire.push(wired);
+						},
+						onFailure: (refused) => {
+							undescribable.push(refused);
+						}
+					});
+				}
+			})
+		});
+	});
+	return {
+		wire,
+		undescribable
+	};
+};
+const SKIPPED_IDS_IN_WARNING = 5;
+const skippedIdsOf = (undescribable) => `${undescribable.slice(0, SKIPPED_IDS_IN_WARNING).map((item) => item.id).join(", ")}${Option.match(Option.liftPredicate(undescribable.length, (count) => count > SKIPPED_IDS_IN_WARNING), {
+	onNone: () => "",
+	onSome: (count) => `, +${count - SKIPPED_IDS_IN_WARNING} more`
+})}`;
+const refusalReasonsOf = (undescribable) => [...new Set(undescribable.map((mutant) => mutant.reason))].join("; ");
+const logSkippedMutants = (checkerName, undescribable) => Match.value(undescribable.length).pipe(Match.when(0, () => Effect$1.void), Match.orElse(() => Effect$1.logWarning(`Checker "${checkerName}" skipped ${undescribable.length} mutant(s) it cannot be told about: ${refusalReasonsOf(undescribable)} (${skippedIdsOf(undescribable)})`)));
 /**
 * Ask a checker about run plans and get run plans back.
 *
@@ -13202,13 +13370,26 @@ const writeGroupOutcome = (plans, checkerName, outcome) => Result.match(outcome,
 * 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) => {
+const checkPlans = (checker, checkerName, plans, lookup) => {
 	return Cell.layer({
-		read: (command) => command.checker.check(command.checkerName, command.plans.map((plan) => plan.mutant)).pipe(Effect$1.map((answers) => ({
-			checkerName: command.checkerName,
-			requestedIds: command.plans.map((plan) => plan.mutant.id),
-			answers
-		}))),
+		read: (command) => Effect$1.gen(function* () {
+			const partitioned = Option.match(Option.fromUndefinedOr(command.lookup), {
+				onSome: (known) => selectedFromLookup(command.plans, known),
+				onNone: () => partitionMutantsForWire(command.plans)
+			});
+			yield* logSkippedMutants(command.checkerName, partitioned.undescribable);
+			if (partitioned.undescribable.length > 0) yield* Metric.update(checkerMutantsSkipped, partitioned.undescribable.length);
+			yield* Effect$1.annotateCurrentSpan({ "stryker.checker.skipped_mutants_count": partitioned.undescribable.length });
+			const answers = yield* command.checker.check(command.checkerName, partitioned.wire);
+			return {
+				checkerName: command.checkerName,
+				requestedIds: command.plans.map((plan) => plan.mutant.id),
+				answers: {
+					...compileErrorAnswersOf(partitioned.undescribable),
+					...answers
+				}
+			};
+		}),
 		decode: (raw) => Result.succeed(CheckerCommand.make({
 			checkerName: raw.checkerName,
 			requestedIds: [...raw.requestedIds],
@@ -13221,19 +13402,29 @@ const checkPlans = (checker, checkerName, plans) => {
 	}).run({
 		checker,
 		checkerName,
-		plans
+		plans,
+		lookup
 	});
 };
 /**
 * Ask a checker how to group run plans, and get groups of run plans back.
 */
-const groupPlans = (checker, checkerName, plans) => {
+const groupPlans = (checker, checkerName, plans, lookup) => {
 	return Cell.layer({
-		read: (command) => command.checker.group(command.checkerName, command.plans.map((plan) => plan.mutant)).pipe(Effect$1.map((idGroups) => ({
-			checkerName: command.checkerName,
-			requestedIds: command.plans.map((plan) => plan.mutant.id),
-			idGroups
-		}))),
+		read: (command) => Effect$1.gen(function* () {
+			const partitioned = Option.match(Option.fromUndefinedOr(command.lookup), {
+				onSome: (known) => selectedFromLookup(command.plans, known),
+				onNone: () => partitionMutantsForWire(command.plans)
+			});
+			yield* Effect$1.annotateCurrentSpan({ "stryker.checker.skipped_mutants_count": partitioned.undescribable.length });
+			const undescribableIds = undescribableIdsOf(partitioned.undescribable);
+			const withoutSkipped = (yield* command.checker.group(command.checkerName, partitioned.wire)).map((group) => group.filter((id) => !undescribableIds.has(id))).filter((group) => group.length > 0);
+			return {
+				checkerName: command.checkerName,
+				requestedIds: command.plans.map((plan) => plan.mutant.id),
+				idGroups: [...singletonGroupsOf(partitioned.undescribable), ...withoutSkipped]
+			};
+		}),
 		decode: (raw) => Result.succeed(CheckerCommand.make({
 			checkerName: raw.checkerName,
 			requestedIds: [...raw.requestedIds],
@@ -13246,47 +13437,16 @@ const groupPlans = (checker, checkerName, plans) => {
 	}).run({
 		checker,
 		checkerName,
-		plans
+		plans,
+		lookup
 	});
 };
 const checkGroupedPlans = (checker, checkerName, plans) => Effect$1.gen(function* () {
-	const groups = yield* groupPlans(checker, checkerName, plans);
-	return (yield* Effect$1.forEach(groups, (group) => checkPlans(checker, checkerName, group), { concurrency: 1 })).flat();
+	const lookup = lookupOf(partitionMutantsForWire(plans));
+	const groups = yield* groupPlans(checker, checkerName, plans, lookup);
+	return (yield* Effect$1.forEach(groups, (group) => checkPlans(checker, checkerName, group, lookup), { 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;
@@ -13471,7 +13631,7 @@ const assembleTestFiles = (input) => {
 //#region package.json
 var package_default = {
 	name: "@systemfsoftware/stryker-js",
-	version: "7.0.0",
+	version: "8.0.0",
 	repository: {
 		"type": "git",
 		"url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -13503,7 +13663,9 @@ var package_default = {
 		"@effect/platform-node-shared": "catalog:",
 		"@noble/hashes": "catalog:",
 		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/exporter-metrics-otlp-http": "^0.208.0",
 		"@opentelemetry/exporter-trace-otlp-http": "^0.208.0",
+		"@opentelemetry/sdk-metrics": "^2.2.0",
 		"@opentelemetry/sdk-trace-base": "^2.2.0",
 		"@systemfsoftware/effect-cell-types": "catalog:"
 	},
@@ -13925,25 +14087,6 @@ const rememberedResultsOf = (mutants, remembered) => {
 		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",
@@ -13961,6 +14104,8 @@ const toReportedMutant = (mutant) => Object.assign(mutant, {
 	coveredBy: mutant.coveredBy,
 	static: mutant.static
 });
+const CHECKER_ACQUIRE_RETRIES = 2;
+const isCheckerCrash = (error) => Match.value(error).pipe(Match.tag("ChildProcessCrashedError", "OutOfMemoryError", () => true), Match.orElse(() => false));
 const makeCheckerPool = (prev, idGenerator) => Match.value(prev.options.checkers.length === 0).pipe(Match.when(true, () => Effect$1.as(Effect$1.void, void 0)), Match.orElse(() => Pool.make({
 	acquire: Effect$1.forEach(prev.options.checkers, (checker) => Effect$1.gen(function* () {
 		const resolved = yield* resolveConfiguredWorkerSpawn({
@@ -13971,7 +14116,10 @@ const makeCheckerPool = (prev, idGenerator) => Match.value(prev.options.checkers
 		const service = yield* createCheckerFactory({
 			...prev.options,
 			checkers: [checker]
-		}, prev.project.fileDescriptions, resolved.spawn.entrypoint, idGenerator, prev.sandbox.workingDirectory);
+		}, prev.project.fileDescriptions, resolved.spawn.entrypoint, idGenerator, prev.sandbox.workingDirectory).pipe(Effect$1.retry({
+			times: CHECKER_ACQUIRE_RETRIES,
+			while: isCheckerCrash
+		}));
 		return {
 			checkerName: resolved.name,
 			checker: service
@@ -13994,6 +14142,28 @@ const checkPlansWithConfiguredCheckers = (checkerPool, plans, reporting) => Opti
 		}).pipe(Effect$1.as(checked.filter(([, result]) => result.status === "passed").map(([plan]) => plan))))));
 	}))
 });
+const isPlannable = (mutant) => Result.isSuccess(wireRecordOf(mutant));
+const DROPPED_IDS_IN_WARNING = 5;
+const partitionPlannable = (mutants) => {
+	const plannable = [];
+	const dropped = [];
+	mutants.forEach((mutant) => {
+		if (isPlannable(mutant)) plannable.push(mutant);
+		else dropped.push(mutant);
+	});
+	return {
+		plannable,
+		dropped
+	};
+};
+const droppedIdsOf = (dropped) => `${dropped.slice(0, DROPPED_IDS_IN_WARNING).map((mutant) => mutant.id).join(", ")}${Option.match(Option.liftPredicate(dropped.length, (count) => count > DROPPED_IDS_IN_WARNING), {
+	onNone: () => "",
+	onSome: (count) => `, +${count - DROPPED_IDS_IN_WARNING} more`
+})}`;
+const reportDroppedMutants = (dropped) => Match.value(dropped.length).pipe(Match.when(0, () => Effect$1.void), Match.orElse(() => Effect$1.gen(function* () {
+	yield* Metric.update(checkerMutantsSkipped, dropped.length);
+	yield* Effect$1.logWarning(`${dropped.length} mutant(s) cannot be described to a checker and were left out of the run (${droppedIdsOf(dropped)})`);
+})));
 const mutationTestCell$1 = Cell.layer({
 	read: (command) => Effect$1.gen(function* () {
 		yield* Scope.Scope;
@@ -14007,156 +14177,147 @@ const mutationTestCell$1 = Cell.layer({
 	})),
 	decide: admitMutationTest,
 	encode: (outcome) => outcome,
-	write: (outcome, raw) => withPhaseSpan("mutationTest", {
-		mutantCount: raw.prev.mutants.length,
-		testCount: raw.prev.dryRunResult.tests.length
-	}, () => Effect$1.gen(function* () {
-		const decision = yield* Result.match(outcome, {
-			onFailure: (err) => Effect$1.fail(StageError.make({
-				stage: err.stage,
-				reason: err.reason,
-				cause: err
-			})),
-			onSuccess: (d) => Effect$1.succeed(d)
-		});
-		return yield* Match.value(decision).pipe(Match.tag("MutationTestDryRunOnly", () => Effect$1.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$1.logInfo("The dry-run has been completed successfully. No mutations have been executed.");
-			return {
-				results: [],
-				verdict: null
-			};
-		})), Match.tag("MutationTestNoTests", () => Effect$1.gen(function* () {
-			const env = yield* RunEnvironment;
-			const queue = yield* RunEvents;
-			const now = yield* Clock.currentTimeMillis;
-			const elapsed = Duration.millis(now - env.runStartedAt);
-			yield* Effect$1.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$1.gen(function* () {
-			const prev = raw.prev;
-			const env = yield* RunEnvironment;
-			yield* Effect$1.gen(function* () {
+	write: (outcome, raw) => {
+		const { dropped, plannable: plannableMutants } = partitionPlannable(raw.prev.mutants);
+		return withPhaseSpan("mutationTest", {
+			mutantCount: raw.prev.mutants.length,
+			skippedMutantCount: dropped.length,
+			testCount: raw.prev.dryRunResult.tests.length
+		}, () => Effect$1.gen(function* () {
+			yield* reportDroppedMutants(dropped);
+			const decision = yield* Result.match(outcome, {
+				onFailure: (err) => Effect$1.fail(StageError.make({
+					stage: err.stage,
+					reason: err.reason,
+					cause: err
+				})),
+				onSuccess: (d) => Effect$1.succeed(d)
+			});
+			return yield* Match.value(decision).pipe(Match.tag("MutationTestDryRunOnly", () => Effect$1.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$1.logInfo("The dry-run has been completed successfully. No mutations have been executed.");
+				return {
+					results: [],
+					verdict: null
+				};
+			})), Match.tag("MutationTestNoTests", () => Effect$1.gen(function* () {
+				const env = yield* RunEnvironment;
 				const queue = yield* RunEvents;
+				const now = yield* Clock.currentTimeMillis;
+				const elapsed = Duration.millis(now - env.runStartedAt);
+				yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
+				const nowEmit = yield* Clock.currentTimeMillis;
 				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$1.void,
-				testFiles: prev.project.testFiles.map((file) => prev.sandbox.sandboxFileFor(file))
-			};
-			const testRunnerPool = yield* Pool.make({
-				acquire: buildTestRunner(testRunnerContext, Effect$1.suspend(() => {
-					const runnerConfigured = prev.options.testRunner;
-					const runnerLabel = Match.value(runnerConfigured).pipe(Match.when(isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
-					return resolveConfiguredWorkerSpawn({
-						loaded: prev.loadedPlugins,
-						kind: "TestRunner",
-						configured: runnerConfigured
-					}).pipe(Effect$1.mapError(missingWorkerEntry("mutationTest", "test runner", runnerLabel)), Effect$1.flatMap(({ spawn }) => makeChildProcessTestRunner({
-						options: prev.options,
-						fileDescriptions: prev.project.fileDescriptions,
-						sandboxWorkingDirectory: prev.sandbox.workingDirectory,
-						workerEntrypoint: spawn.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$1.when(Effect$1.logInfo(`Incremental mode: reusing ${rememberedResults.length} mutant result(s), running ${incremental.mutants.length} mutant(s).`), Effect$1.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$1.ignoreCause);
-			{
-				const queue2 = yield* RunEvents;
-				yield* Queue.offer(queue2, PlanKnown.make({ total: allPlansForReporter.length + noCoverageResults.length }));
-			}
-			const passedPlans = yield* checkPlansWithConfiguredCheckers(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)
+					results: [],
+					verdict: null
 				};
-			};
-			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$1.gen(function* () {
-				if (prepared === void 0) return;
-				const completed = yield* Ref.updateAndGet(completedRef, (n) => n + 1);
-				yield* Queue.offer(progressQueue, RunMutantTested.make({
+			})), Match.tag("MutationTestProceed", () => Effect$1.gen(function* () {
+				const prev = raw.prev;
+				const env = yield* RunEnvironment;
+				yield* Effect$1.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$1.void,
+					testFiles: prev.project.testFiles.map((file) => prev.sandbox.sandboxFileFor(file))
+				};
+				const testRunnerPool = yield* Pool.make({
+					acquire: buildTestRunner(testRunnerContext, Effect$1.suspend(() => {
+						const runnerConfigured = prev.options.testRunner;
+						const runnerLabel = Match.value(runnerConfigured).pipe(Match.when(isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
+						return resolveConfiguredWorkerSpawn({
+							loaded: prev.loadedPlugins,
+							kind: "TestRunner",
+							configured: runnerConfigured
+						}).pipe(Effect$1.mapError(missingWorkerEntry("mutationTest", "test runner", runnerLabel)), Effect$1.flatMap(({ spawn }) => makeChildProcessTestRunner({
+							options: prev.options,
+							fileDescriptions: prev.project.fileDescriptions,
+							sandboxWorkingDirectory: prev.sandbox.workingDirectory,
+							workerEntrypoint: spawn.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: plannableMutants,
+					testCoverage: prev.testCoverage,
+					incrementalReport: prev.project.incrementalReport,
+					currentRelativeFiles,
+					basePath: env.basePath,
+					force: prev.options.force
+				});
+				const rememberedResults = rememberedResultsOf(plannableMutants, incremental.remembered);
+				yield* Effect$1.when(Effect$1.logInfo(`Incremental mode: reusing ${rememberedResults.length} mutant result(s), running ${incremental.mutants.length} mutant(s).`), Effect$1.succeed(rememberedResults.length > 0));
+				const { runPlans, earlyResults: noCoverageResults } = partitionRunPlans(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 = sortRunPlans(runPlans);
+				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$1.ignoreCause);
+				{
+					const queue2 = yield* RunEvents;
+					yield* Queue.offer(queue2, PlanKnown.make({ total: allPlansForReporter.length + noCoverageResults.length }));
+				}
+				const passedPlans = yield* checkPlansWithConfiguredCheckers(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,
@@ -14165,71 +14326,85 @@ const mutationTestCell$1 = Cell.layer({
 					replacement: result.replacement,
 					completed,
 					total: plannedTotal
+				});
+				const offerFinished = (result, prepared) => Effect$1.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$1.catchCause((cause) => Effect$1.logWarning("Reporter stream failed handling mutantTested", cause)));
+				const offerStreamTested = (result, completed, prepared) => Option.match(Option.all([Option.fromNullishOr(completed), Option.fromNullishOr(prepared)]), {
+					onNone: () => Effect$1.void,
+					onSome: ([done, streamable]) => reportStreamTested(result, done, streamable)
+				});
+				const announceSettledMutant = (result) => Effect$1.gen(function* () {
+					const prepared = preparedStreamableOf(result);
+					const completed = yield* offerFinished(result, prepared);
+					yield* offerStreamTested(result, completed, prepared);
+				});
+				yield* Effect$1.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$1.catchCause((cause) => Effect$1.logWarning("Failed to persist the mutation checkpoint", cause)));
+				const persist = (result) => checkpointGate.withPermits(1)(Effect$1.gen(function* () {
+					const next = yield* Ref.updateAndGet(completedMutants, (prev) => [...prev, result]);
+					yield* reporting.checkpoint(next).pipe(Effect$1.catchCause((cause) => Effect$1.logWarning("Failed to persist the mutation checkpoint", cause)));
 				}));
-				return completed;
-			});
-			const reportStreamTested = (result, completed, prepared) => offerReporterEvent(prev.reporterStage, toStreamEvent(result, completed, prepared)).pipe(Effect$1.catchCause((cause) => Effect$1.logWarning("Reporter stream failed handling mutantTested", cause)));
-			const offerStreamTested = (result, completed, prepared) => Option.match(Option.all([Option.fromNullishOr(completed), Option.fromNullishOr(prepared)]), {
-				onNone: () => Effect$1.void,
-				onSome: ([done, streamable]) => reportStreamTested(result, done, streamable)
-			});
-			const announceSettledMutant = (result) => Effect$1.gen(function* () {
-				const prepared = preparedStreamableOf(result);
-				const completed = yield* offerFinished(result, prepared);
-				yield* offerStreamTested(result, completed, prepared);
-			});
-			yield* Effect$1.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$1.catchCause((cause) => Effect$1.logWarning("Failed to persist the mutation checkpoint", cause)));
-			const persist = (result) => checkpointGate.withPermits(1)(Effect$1.gen(function* () {
-				const next = yield* Ref.updateAndGet(completedMutants, (prev) => [...prev, result]);
-				yield* reporting.checkpoint(next).pipe(Effect$1.catchCause((cause) => Effect$1.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$1.scoped(Effect$1.gen(function* () {
-				const pool = testRunnerPool;
-				const runner = yield* Pool.get(pool);
-				const result = yield* runner.mutantRun(plan.runOptions).pipe(Effect$1.catchTags({
-					OutOfMemoryError: (error) => Effect$1.flatMap(Pool.invalidate(pool, runner), () => Effect$1.fail(error)),
-					ChildProcessCrashedError: (error) => Effect$1.flatMap(Pool.invalidate(pool, runner), () => Effect$1.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$1.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$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
-			return outcomeResult;
-		})), Match.exhaustive);
-	})).pipe(Effect$1.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)))
+				const runResults = yield* withPhaseSpan("mutationTest.batch", {
+					total: plannedTotal,
+					testRunners: prev.concurrency.testRunners
+				}, () => Stream.mapEffect(testRunnerStream, (plan) => Effect$1.scoped(Effect$1.gen(function* () {
+					const pool = testRunnerPool;
+					const runner = yield* Pool.get(pool);
+					const result = yield* runner.mutantRun(plan.runOptions).pipe(Effect$1.catchTags({
+						OutOfMemoryError: (error) => Effect$1.flatMap(Pool.invalidate(pool, runner), () => Effect$1.fail(error)),
+						ChildProcessCrashedError: (error) => Effect$1.flatMap(Pool.invalidate(pool, runner), () => Effect$1.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$1.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$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
+				return outcomeResult;
+			})), Match.exhaustive);
+		})).pipe(Effect$1.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/reporter-output.ts
@@ -15437,4 +15612,4 @@ const strykerCell = (options, targetMutatePatterns) => Effect$1.gen(function* ()
 	}, prepareCommandOf(options, patterns));
 });
 //#endregion
-export { ConfigFileNotFoundError as $, ReporterInitOptions as $t, mergeConfigs as A, resolveExitCode as At, classifyWorkerExit as B, optionsPath$1 as Bt, spawnReporterWorker as C, RunFailed as Ct, importModule as D, VerdictReached as Dt, forkCoreSchema as E, RunStarted as Et, isCommandRunner as F, deepFreeze$1 as Ft, isVmRunner as G, MutantResultSchema as Gt, OutOfMemoryError as H, ExitClass as Ht, WorkerLauncher as I, defaultOptions$1 as It, vmTestRunner as J, MutationTestResultSchema$1 as Jt, vmRunnerCapabilities as K, MutantTested as Kt, connectRetry as L, findUnserializables$1 as Lt, resolveExtends as M, CONFIG_SYNTAX_HELP$1 as Mt, validateOptions as N, SUPPORTED_CONFIG_FILE_NAMES$1 as Nt, initialExtendsStepState as O, EXIT_CODE as Ot, buildTestRunner as P, createDefaultOptions$1 as Pt, ConfigFileInvalidError as Q, ReporterEventBatch as Qt, makeWorkerClient as R, isModuleSpecifier$1 as Rt, reporterWorkerFactory as S, PlanKnown as St, describeErrors as T, RunPhase as Tt, WorkerBootTimeoutError as U, FileResultSchema as Ut, ChildProcessCrashedError as V, DryRunCompleted as Vt, VmRunner as W, MetricsSchema as Wt, ConfigDocumentSchema as X, ReporterAck as Xt, StrykerError as Y, MutationTestingPlanReady as Yt, ConfigError as Z, ReporterDrained as Zt, createFileMatcher as _, RunEvents as _t, shouldKeepTempDir as a, LocationSchema$1 as an, ExtendsStepRefused as at, RunEnvironment as b, HelpRendered as bt, buildVerdictEnvelope as c, PositionSchema$2 as cn, ImportedModuleSchema as ct, strykerVersion as d, ReadConfigCommand as dt, ReporterRpcs as en, ConfigFileUnreadableError as et, calculateMetrics as f, extendsPropertySchema as ft, CheckerSkippedRequested as g, StageError as gt, CheckerAnsweredUnrequested as h, toRelativeNormalizedFileName as ht, mutationTestCell as i, WorkerPluginKind as in, ExtendsStepRead as it, readConfig as j, verdictExitClass as jt, loadConfigCell as k, highestExitClass as kt, generateRunId as l, MergeCommand as lt, checkGroupedPlans as m, survivorsPriorReport as mt, RUN_EVENTS_QUEUE_BOUND as n, TestRunnerConfigSchema as nn, ExtendsStepDocumentSchema as nt, ACTIONABLE_STATUSES as o, MutantActivationSchema as on, ExtendsStepResolve as ot, countMutants as p, forkOptionsSchema as pt, vmRunnerName as q, MutationTestReportReady as qt, makeRunLayer as r, TraceContextMiddleware as rn, ExtendsStepDone as rt, VERDICT_ENVELOPE_SCHEMA_VERSION as s, MutantStatusSchema as sn, ExtendsStepStateSchema as st, strykerCell as t, StrykerOptionsSchema as tn, ConfigFileUnsupportedError as tt, isActionableStatus as u, MergeResult as ut, matchesFile as v, RunIdentity as vt, decideExtendsStep as w, RunMutantTested as wt, REPORTER_EVENT_BATCH_BOUND as x, PhaseEntered as xt, IncrementalReportSchema as y, Heartbeat as yt, IdGenerator as z, isWarningEnabled$1 as zt };
+export { StrykerError as $, FileResultSchema as $t, describeErrors as A, RunStarted as At, WorkerLauncher as B, defaultOptions$1 as Bt, matchesFile as C, Heartbeat as Ct, reporterWorkerFactory as D, RunFailed as Dt, REPORTER_EVENT_BATCH_BOUND as E, PlanKnown as Et, mergeConfigs as F, verdictExitClass as Ft, ChildProcessCrashedError as G, CheckerCheckResult as Gt, makeWorkerClient as H, isModuleSpecifier$1 as Ht, readConfig as I, CONFIG_SYNTAX_HELP$1 as It, VmRunner as J, CheckerMutantWire as Jt, OutOfMemoryError as K, CheckerFailed as Kt, validateOptions as L, SUPPORTED_CONFIG_FILE_NAMES$1 as Lt, importModule as M, EXIT_CODE as Mt, initialExtendsStepState as N, highestExitClass as Nt, spawnReporterWorker as O, RunMutantTested as Ot, loadConfigCell as P, resolveExitCode as Pt, vmTestRunner as Q, ExitClass as Qt, buildTestRunner as R, createDefaultOptions$1 as Rt, createFileMatcher as S, RunIdentity as St, RunEnvironment as T, PhaseEntered as Tt, IdGenerator as U, isWarningEnabled$1 as Ut, connectRetry as V, findUnserializables$1 as Vt, classifyWorkerExit as W, optionsPath$1 as Wt, vmRunnerCapabilities as X, CheckerRpcs as Xt, isVmRunner as Y, CheckerRequest as Yt, vmRunnerName as Z, DryRunCompleted as Zt, checkerMutantsSkipped as _, MutantStatusSchema as _n, forkOptionsSchema as _t, shouldKeepTempDir as a, MutationTestingPlanReady as an, ConfigFileUnsupportedError as at, CheckerAnsweredUnrequested as b, StageError as bt, buildVerdictEnvelope as c, ReporterEventBatch as cn, ExtendsStepRead as ct, strykerVersion as d, StrykerOptionsSchema as dn, ExtendsStepStateSchema as dt, MetricsSchema as en, ConfigDocumentSchema as et, calculateMetrics as f, TestRunnerConfigSchema as fn, ImportedModuleSchema as ft, checkerMutantsChecked as g, MutantActivationSchema as gn, extendsPropertySchema as gt, checkerDuration as h, LocationSchema$1 as hn, ReadConfigCommand as ht, mutationTestCell as i, MutationTestResultSchema$1 as in, ConfigFileUnreadableError as it, forkCoreSchema as j, VerdictReached as jt, decideExtendsStep as k, RunPhase as kt, generateRunId as l, ReporterInitOptions as ln, ExtendsStepRefused as lt, checkGroupedPlans as m, WorkerPluginKind as mn, MergeResult as mt, RUN_EVENTS_QUEUE_BOUND as n, MutantTested as nn, ConfigFileInvalidError as nt, ACTIONABLE_STATUSES as o, ReporterAck as on, ExtendsStepDocumentSchema as ot, countMutants as p, TraceContextMiddleware as pn, MergeCommand as pt, WorkerBootTimeoutError as q, CheckerGroupResult as qt, makeRunLayer as r, MutationTestReportReady as rn, ConfigFileNotFoundError as rt, VERDICT_ENVELOPE_SCHEMA_VERSION as s, ReporterDrained as sn, ExtendsStepDone as st, strykerCell as t, MutantResultSchema as tn, ConfigError as tt, isActionableStatus as u, ReporterRpcs as un, ExtendsStepResolve as ut, checkerProcessCrashes as v, PositionSchema$2 as vn, survivorsPriorReport as vt, IncrementalReportSchema as w, HelpRendered as wt, CheckerSkippedRequested as x, RunEvents as xt, checkerRpcFailures as y, toRelativeNormalizedFileName as yt, isCommandRunner as z, deepFreeze$1 as zt };