@systemfsoftware/stryker-js 11.0.0 → 12.1.0

package/dist/{run-stages.cell-CPpkn7og.mjs → run-stages.cell-RwTUyNX9.mjs}

@@ -1,7 +1,6 @@
-import { a as Reporter_exports, c as ErrorText_exports, d as Mutant_exports, i as Report_exports, l as Format_exports, n as Options_exports, o as TestRunner_exports, r as Plugin_exports, s as Trace_exports$1, t as Checker_exports, u as Instrument_exports } from "./dist-ClUhPgb6.mjs";
-import { t as StrykerConfig } from "./stryker-config.schema-CCnDtVuW.mjs";
-import { D as VerdictReached, E as SkippedReported, _ as PluginsReported, b as RunFailed$1, c as Heartbeat, f as OutputMode, i as FormatRegistryResolved, l as HelpRendered, m as PlanKnown, n as StageError, p as PhaseEntered, t as PrepareError, u as ModeSignal, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-B_qdjbe9.mjs";
-import { Cell, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
+import { A as Plugin_exports, D as VerdictReached, E as SkippedReported, F as ErrorText_exports, I as Format_exports, L as Instrument_exports, M as Reporter_exports, N as TestRunner_exports, O as Checker_exports, P as Trace_exports$1, R as Mutant_exports, _ as PluginsReported, b as RunFailed$1, c as Heartbeat, f as OutputMode, i as FormatRegistryResolved, j as Report_exports, k as Options_exports, l as HelpRendered, m as PlanKnown, n as StageError, p as PhaseEntered, t as PrepareError, u as ModeSignal, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-BaK_pxuK.mjs";
+import { t as mergeConfig } from "./merge-config-ByZJPeQZ.mjs";
+import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Boolean$1 from "effect/Boolean";
 import * as Match from "effect/Match";
 import * as Option$1 from "effect/Option";
@@ -9,22 +8,21 @@ import * as Predicate$1 from "effect/Predicate";
 import * as Result from "effect/Result";
 import * as S from "effect/Schema";
 import * as Effect$1 from "effect/Effect";
-import { absurd, dual } from "effect/Function";
+import { absurd, dual, pipe } from "effect/Function";
 import * as Arr from "effect/Array";
 import * as SchemaGetter$1 from "effect/SchemaGetter";
-import { Prototype } from "effect/Pipeable";
 import * as Context from "effect/Context";
-import { Boolean, Option, Predicate, Schema, SchemaGetter } from "effect";
+import { Boolean, Option, Predicate, Schema, SchemaGetter, SchemaTransformation } from "effect";
+import * as Exit from "effect/Exit";
 import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
-import * as Metric from "effect/Metric";
 import * as Cause from "effect/Cause";
+import * as Metric from "effect/Metric";
 import * as SchemaTransformation$1 from "effect/SchemaTransformation";
 import * as Record from "effect/Record";
 import * as Path from "effect/Path";
 import * as Config from "effect/Config";
 import * as FileSystem from "effect/FileSystem";
 import * as Clock from "effect/Clock";
-import * as Exit from "effect/Exit";
 import * as Stream from "effect/Stream";
 import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
@@ -61,15 +59,15 @@ import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
 import * as Socket from "effect/unstable/socket/Socket";
 import * as NodeFileSystem$1 from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath$1 from "@effect/platform-node-shared/NodePath";
-import * as Equivalence from "effect/Equivalence";
 import { badArgument } from "effect/PlatformError";
-import { Session } from "@systemfsoftware/stryker-vm-harness";
+import * as Equivalence from "effect/Equivalence";
 import * as Console from "effect/Console";
 import * as Formatter from "effect/Formatter";
 import * as Runtime from "effect/Runtime";
 import * as Order from "effect/Order";
 import * as CliError from "effect/unstable/cli/CliError";
 import { sha256 } from "@noble/hashes/sha2.js";
+import "effect/Deferred";
 import * as Pool from "effect/Pool";
 import * as Semaphore from "effect/Semaphore";
 //#region src/admit-checker-answer.workflow.ts
@@ -180,14 +178,15 @@ var WorkerBootTimeoutError = class extends Schema.TaggedError()("WorkerBootTimeo
 };
 //#endregion
 //#region src/Checker/Checker.handle.ts
-const TypeId$4 = Symbol.for("@systemfsoftware/stryker-js/CheckerHandle");
+const TypeId$10 = Symbol.for("~systemfsoftware/stryker-js/Checker");
 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 checkerRpcFailures = Metric.counter("stryker.checker.rpc_failures", {
 	description: "Checker worker RPC calls that did not complete, excluding interruptions",
 	incremental: true
 });
-const ClientTypeId = Symbol.for("@systemfsoftware/stryker-js/CheckerHandle/client");
+const CheckerHandle = Handle.make()(TypeId$10);
+const isCheckerHandle = CheckerHandle.is;
 const connectionCrashed = (cause) => ChildProcessCrashedError.make({
 	pid: 0,
 	exit: {
@@ -200,24 +199,17 @@ const recordCheckerCall = (spanName, checkerName, mutants, call) => call.pipe(Ef
 	"stryker.checker.name": checkerName,
 	"stryker.mutants.count": mutants.length
 } }), Effect$1.timed, Effect$1.onExit((exit) => Match.value(exit).pipe(Match.tag("Success", () => Metric.update(checkerMutantsChecked, mutants.length)), Match.tag("Failure", (failure) => failure.cause.pipe(Cause.hasInterruptsOnly, Match.value, Match.when(true, () => Effect$1.void), Match.orElse(() => Metric.update(checkerRpcFailures, 1)))), Match.exhaustive)), Effect$1.tap(([duration]) => Metric.update(checkerDuration, duration)), Effect$1.map(([, result]) => result), Effect$1.mapError((error) => Match.value(error).pipe(Match.tag("CheckerFailed", (failed) => failed), Match.orElse((e) => connectionCrashed(e.message)))));
-const checkOf = (self, checkerName, mutants) => recordCheckerCall("stryker.checker.check", checkerName, mutants, self[ClientTypeId].check({
+const checkOf = (self, checkerName, mutants) => recordCheckerCall("stryker.checker.check", checkerName, mutants, CheckerHandle.slot(self).check({
 	checkerName,
 	mutants: [...mutants]
 }));
-const groupOf$1 = (self, checkerName, mutants) => recordCheckerCall("stryker.checker.group", checkerName, mutants, self[ClientTypeId].group({
+const groupOf$1 = (self, checkerName, mutants) => recordCheckerCall("stryker.checker.group", checkerName, mutants, CheckerHandle.slot(self).group({
 	checkerName,
 	mutants: [...mutants]
 }));
-const makeCheckerHandle = (client) => {
-	const self = {
-		[TypeId$4]: TypeId$4,
-		[ClientTypeId]: client,
-		...Prototype,
-		check: (checkerName, mutants) => checkOf(self, checkerName, mutants),
-		group: (checkerName, mutants) => groupOf$1(self, checkerName, mutants)
-	};
-	return self;
-};
+const check = dual((args) => isCheckerHandle(args[0]), (self, checkerName, mutants) => checkOf(self, checkerName, mutants));
+const group = dual((args) => isCheckerHandle(args[0]), (self, checkerName, mutants) => groupOf$1(self, checkerName, mutants));
+const makeCheckerHandle = (client) => CheckerHandle.make({}, client);
 //#endregion
 //#region src/Checker/Checker.schema.ts
 var UndescribableMutant = class extends S.TaggedError()("UndescribableMutant", {
@@ -245,7 +237,7 @@ const CheckerMutantFromMutant = S.decodeTo(CheckerMutant, SchemaTransformation$1
 	})
 }))(Mutant_exports.Mutant);
 //#endregion
-//#region src/Checker/Checker.cell.ts
+//#region src/Checker/Checker.parts.ts
 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));
@@ -313,8 +305,8 @@ const pairGroups = (checkerName, plans, idGroups) => Match.value(partitionGroups
 	unrequestedIds: [...partition.unrequested],
 	requestedIds: plans.map((plan) => plan.mutant.id)
 }))), Match.orElse((partition) => admitGroupedPlans(checkerName, plans, partition)));
-const writeDecidedAnswers = (plans, checkerName, answers) => Effect$1.fromResult(pairCheckResults(checkerName, plans, Object.fromEntries(answers.map((answer) => [answer.id, answer.result]))));
-const writeDecidedGroups = (plans, checkerName, idGroups) => Effect$1.fromResult(pairGroups(checkerName, plans, idGroups));
+const writeDecidedAnswers = (input) => Effect$1.fromResult(pairCheckResults(input.checkerName, input.plans, Object.fromEntries(input.answers.map((answer) => [answer.id, answer.result]))));
+const writeDecidedGroups = (input) => Effect$1.fromResult(pairGroups(input.checkerName, input.plans, input.idGroups));
 const wireRecordOf = (mutant) => Result.mapError(S.decodeResult(CheckerMutantFromMutant)(mutant), (error) => UndescribableMutant.make({
 	id: mutant.id,
 	fileName: mutant.fileName,
@@ -356,7 +348,7 @@ const skippedIdsOf = (undescribable) => `${undescribable.slice(0, SKIPPED_IDS_IN
 	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)})`)));
+const logSkippedMutants = (input) => Match.value(input.undescribable.length).pipe(Match.when(0, () => Effect$1.void), Match.orElse(() => Effect$1.logWarning(`Checker "${input.checkerName}" skipped ${input.undescribable.length} mutant(s) it cannot be told about: ${refusalReasonsOf(input.undescribable)} (${skippedIdsOf(input.undescribable)})`)));
 const recordSkipped = (skipped) => Boolean$1.match(skipped > 0, {
 	onTrue: () => Metric.update(UndescribableMutant.skipped, skipped),
 	onFalse: () => Effect$1.void
@@ -365,9 +357,14 @@ const partitionedFor = (input) => Option$1.match(Option$1.fromUndefinedOr(input.
 	onSome: (known) => selectedFromLookup(input.plans, known),
 	onNone: () => partitionMutantsForWire(input.plans)
 });
+//#endregion
+//#region src/Checker/Checker.cell.ts
 const readCheckCommand = (input) => Effect$1.gen(function* () {
 	const partitioned = partitionedFor(input);
-	yield* logSkippedMutants(input.checkerName, partitioned.undescribable);
+	yield* logSkippedMutants({
+		checkerName: input.checkerName,
+		undescribable: partitioned.undescribable
+	});
 	yield* recordSkipped(partitioned.undescribable.length);
 	yield* Effect$1.annotateCurrentSpan({ "stryker.checker.skipped_mutants_count": partitioned.undescribable.length });
 	const answers = yield* input.checker.check(input.checkerName, partitioned.wire);
@@ -407,7 +404,11 @@ const commandFailed = (issue, input) => Checker_exports.CheckerFailed.make({
 	mutantIds: input.plans.map((plan) => plan.mutant.id)
 });
 const checkCell = Sandwich.named("stryker.checker.check_plans")(readCheckCommand).decide(admitCheckerAnswer).write({
-	CheckResultDecision: ({ pairs }, raw) => writeDecidedAnswers(raw.plans, raw.checkerName, pairs),
+	CheckResultDecision: ({ pairs }, raw) => writeDecidedAnswers({
+		plans: raw.plans,
+		checkerName: raw.checkerName,
+		answers: pairs
+	}),
 	CheckGroupDecision: (_decision, raw) => Effect$1.fail(CheckerSkippedRequested.make({
 		checkerName: raw.checkerName,
 		phase: "check",
@@ -417,8 +418,12 @@ const checkCell = Sandwich.named("stryker.checker.check_plans")(readCheckCommand
 	CheckerSkippedRequested: (breach) => Effect$1.fail(CheckerSkippedRequested.make(breach)),
 	CommandRejected: ({ issue }, raw) => Effect$1.fail(commandFailed(issue, raw))
 });
-const checkGroupedCell = Sandwich.named("stryker.checker.group_plans")(readGroupCommand).decide(admitCheckerAnswer).write({
-	CheckGroupDecision: ({ groups }, raw) => writeDecidedGroups(raw.plans, raw.checkerName, groups),
+const groupCell = Sandwich.named("stryker.checker.group_plans")(readGroupCommand).decide(admitCheckerAnswer).write({
+	CheckGroupDecision: ({ groups }, raw) => writeDecidedGroups({
+		plans: raw.plans,
+		checkerName: raw.checkerName,
+		idGroups: groups
+	}),
 	CheckResultDecision: (_decision, raw) => Effect$1.fail(CheckerSkippedRequested.make({
 		checkerName: raw.checkerName,
 		phase: "group",
@@ -427,16 +432,20 @@ const checkGroupedCell = Sandwich.named("stryker.checker.group_plans")(readGroup
 	CheckerAnsweredUnrequested: (breach) => Effect$1.fail(CheckerAnsweredUnrequested.make(breach)),
 	CheckerSkippedRequested: (breach) => Effect$1.fail(CheckerSkippedRequested.make(breach)),
 	CommandRejected: ({ issue }, raw) => Effect$1.fail(commandFailed(issue, raw))
-}).pipe(Cell.flatMap((groups) => Cell.mapInput(Cell.collect(checkCell, (perGroup) => perGroup.flat()), (input) => groups.map((group) => ({
+});
+const checkGroupedCell = groupCell.pipe(Cell.flatMap((groups) => Cell.mapInput(Cell.collect(checkCell, (perGroup) => perGroup.flat()), (input) => groups.map((group) => ({
 	...input,
 	plans: group
 })))));
-const checkGroupedPlans = dual(3, (checker, checkerName, plans) => checkGroupedCell.run({
+const checkRequestOf = (checker, checkerName, plans) => ({
 	checker,
 	checkerName,
 	plans,
 	lookup: lookupOf(partitionMutantsForWire(plans))
-}));
+});
+const groupPlans = dual(3, (checker, checkerName, plans) => groupCell.run(checkRequestOf(checker, checkerName, plans)));
+const checkPlans = dual(3, (checker, checkerName, plans) => checkCell.run(checkRequestOf(checker, checkerName, plans)));
+const checkGroupedPlans = dual(3, (checker, checkerName, plans) => checkGroupedCell.run(checkRequestOf(checker, checkerName, plans)));
 //#endregion
 //#region src/Config.schema.ts
 const ConfigDocumentSchema = S.Record(S.String, S.Unknown);
@@ -479,6 +488,22 @@ const forkOptionsSchema = S.StructWithRest(S.Struct({
 	extends: extendsPropertySchema
 }), [S.Record(S.String, S.Unknown)]);
 //#endregion
+//#region src/config/default-options.ts
+const isNonNullObject$1 = (value) => typeof value === "object" && value !== null;
+const isRecordValue = (value) => isNonNullObject$1(value) && Array.isArray(value) === false;
+const isArrayValue$1 = (value) => Array.isArray(value);
+const freezeArrayValue = (value) => Object.freeze(value.map((element) => deepFreeze(element)));
+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((element) => deepFreeze(element))));
+const freezeRegExpValue = (value) => Object.freeze(value);
+const freezeRecordValue = (value) => Object.freeze(Record.map(value, (propertyValue) => deepFreeze(propertyValue)));
+function deepFreeze(target) {
+	return Match.value(target).pipe(Match.when(isArrayValue$1, freezeArrayValue), Match.when((value) => value instanceof Map, freezeMapValue), Match.when((value) => value instanceof RegExp, freezeRegExpValue), Match.when((value) => value instanceof Set, freezeSetValue), Match.when(isRecordValue, freezeRecordValue), Match.orElse(() => target));
+}
+const createDefaultOptions = S.decodeEffect(Options_exports.StrykerOptionsSchema)({}).pipe(Effect$1.orDie);
+const defaultOptions = Effect$1.map(createDefaultOptions, (options) => deepFreeze(options));
+//#endregion
 //#region src/ConfigError.schema.ts
 var ConfigFileNotFoundError = class extends S.TaggedError()("ConfigFileNotFoundError", { file: S.String }) {
 	exitClass = "ConfigError";
@@ -697,13 +722,16 @@ const interpretDryRunResult = Workflow.make({
 });
 //#endregion
 //#region src/pooled-test-runner.handle.ts
-const TypeId$3 = Symbol.for("@systemfsoftware/stryker-js/PooledTestRunner");
-const make$3 = (runner) => ({
-	[TypeId$3]: TypeId$3,
-	...Prototype,
-	...runner
-});
-const withTimeout = (inner) => ({
+const TypeId$9 = Symbol.for("~systemfsoftware/stryker-js/PooledTestRunner");
+const PooledTestRunner = Handle.make()(TypeId$9);
+PooledTestRunner.is;
+const make$3 = (runner) => PooledTestRunner.make({
+	capabilities: runner.capabilities,
+	init: runner.init,
+	dryRun: runner.dryRun,
+	mutantRun: runner.mutantRun
+});
+const withTimeout = (inner) => make$3({
 	...inner,
 	dryRun: (options) => inner.dryRun(options).pipe(Effect$1.timeoutOrElse({
 		duration: Duration.millis(options.timeout),
@@ -725,7 +753,7 @@ const maxRetries = 2;
 const exhaustedMessage = (cause) => `Test runner crashed. Tried ${maxRetries} times to restart it without any luck. ${Cause.pretty(cause)}`;
 const withRetry = (inner) => {
 	const attempt = (run, onExhausted) => run.pipe(Effect$1.tapError((error) => Match.value(error).pipe(Match.when(S.is(OutOfMemoryError), (outOfMemory) => Effect$1.logInfo(`Test runner process [${outOfMemory.pid}] ran out of memory. That usually means the tests leak memory. Stryker restarts the process and carries on, but the run is slower for it.`)), Match.orElse(() => Effect$1.void))), Effect$1.retry({ times: maxRetries }), Effect$1.catchCause((cause) => Effect$1.succeed(onExhausted(exhaustedMessage(cause)))));
-	return {
+	return make$3({
 		...inner,
 		dryRun: (options) => attempt(inner.dryRun(options), (errorMessage) => ({
 			status: "error",
@@ -735,11 +763,11 @@ const withRetry = (inner) => {
 			status: "error",
 			errorMessage
 		}))
-	};
+	});
 };
 const withMaxReuse = dual(2, (options, retire) => (inner) => Match.value(options.maxTestRunnerReuse).pipe(Match.when((restartAfter) => restartAfter <= 0, () => Effect$1.succeed(inner)), Match.orElse((restartAfter) => Effect$1.gen(function* () {
 	const runs = yield* Ref.make(0);
-	return {
+	return make$3({
 		...inner,
 		mutantRun: (runOptions) => {
 			const policy = (self) => Effect$1.gen(function* () {
@@ -752,7 +780,7 @@ const withMaxReuse = dual(2, (options, retire) => (inner) => Match.value(options
 			});
 			return policy(inner.mutantRun(runOptions));
 		}
-	};
+	});
 }))));
 const nextEnvironmentState = (requested) => Boolean$1.match(requested, {
 	onTrue: () => "loaded-static-mutant",
@@ -768,7 +796,7 @@ const reloadPlanOf = (requested, current, canReload) => ({
 });
 const withEnvironmentReload = dual(2, (inner, retire) => Effect$1.gen(function* () {
 	const state = yield* Ref.make("pristine");
-	return {
+	return make$3({
 		...inner,
 		dryRun: (options) => {
 			const policy = (self) => Ref.set(state, "loaded").pipe(Effect$1.andThen(self));
@@ -792,8 +820,11 @@ const withEnvironmentReload = dual(2, (inner, retire) => Effect$1.gen(function*
 				reloadEnvironment: plan.reloadEnvironment
 			}));
 		})
-	};
+	});
 }));
+//#endregion
+//#region src/command-runner.blueprint.ts
+const TypeId$8 = Symbol.for("~systemfsoftware/stryker-js/CommandRunner");
 const ALL_TESTS_NAME = "All tests";
 const isCommandRunner = (name) => typeof name === "string" && name.toLowerCase() === "command";
 const commandRunnerCapabilities = { reloadEnvironment: true };
@@ -845,11 +876,7 @@ const commandRunnerMutantRun = (config, mutantPick) => runCommand(config, mutant
 	onFailure: (failure) => Effect$1.fail(failure),
 	onSuccess: (decision) => Effect$1.succeed(decision.asResult)
 })));
-const commandRunner = dual(2, (context, spawner) => {
-	const config = {
-		workingDir: context.sandboxWorkingDirectory,
-		options: context.options
-	};
+const pooledRunnerOf = (config, spawner) => {
 	const provided = Effect$1.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner);
 	return make$3({
 		capabilities: Effect$1.succeed(commandRunnerCapabilities),
@@ -857,6 +884,23 @@ const commandRunner = dual(2, (context, spawner) => {
 		dryRun: () => commandRunnerDryRun(config).pipe(provided),
 		mutantRun: (options) => commandRunnerMutantRun(config, options).pipe(provided)
 	});
+};
+const CommandRunners = Blueprint.make()(TypeId$8).steps({
+	steps: {},
+	targets: { runner: (spec) => (spawner) => pooledRunnerOf({
+		workingDir: spec.workingDir,
+		options: spec.options
+	}, spawner) }
+});
+const commandRunner = dual(2, (context, spawner) => CommandRunners.of({
+	workingDir: context.sandboxWorkingDirectory,
+	options: context.options
+}).runner(spawner));
+S.Struct({
+	command: S.Literals(["run", "merge-reports"]),
+	isDryRun: S.Boolean,
+	mode: S.Literals(["human", "machine"]),
+	isCi: S.Boolean
 });
 //#endregion
 //#region src/config/warning-enabled.workflow.ts
@@ -996,7 +1040,7 @@ const resolveConfig = Workflow.make({
 const ExitDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/ExitDecision");
 var ClassifyExitCommand = class extends S.TaggedClass()("ClassifyExitCommand", {
 	pending: S.Array(Plugin_exports.ExitClass),
-	score: S.NullOr(S.Finite),
+	score: Report_exports.MutationScore,
 	breakingThreshold: S.NullOr(S.Finite)
 }) {
 	static [Workflow.InstrumentationBrand] = {};
@@ -1031,9 +1075,12 @@ const PRECEDENCE = [
 ];
 const precedenceOf = (pending) => Arr.findFirst(PRECEDENCE, (candidate) => pending.includes(candidate));
 const decisionOf$1 = (exitClass) => Match.value(exitClass).pipe(Match.when("VerdictFail", () => ExitVerdictFailed.make({})), Match.when("ConfigError", () => ExitConfigErrored.make({})), Match.when("RuntimeError", () => ExitRuntimeErrored.make({})), Match.when("InternalError", () => ExitInternalErrored.make({})), Match.exhaustive);
-const verdictExitClass = (score, breakingThreshold) => Option$1.match(Option$1.all([Option$1.fromNullishOr(score), Option$1.fromNullishOr(breakingThreshold)]), {
-	onNone: () => null,
-	onSome: ([actual, threshold]) => Match.value(actual < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)
+const verdictExitClass = (score, breakingThreshold) => Match.valueTags(score, {
+	Unscored: () => null,
+	Scored: ({ percentage }) => Option$1.match(Option$1.fromNullishOr(breakingThreshold), {
+		onNone: () => null,
+		onSome: (threshold) => Match.value(percentage < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)
+	})
 });
 const decide$9 = (command) => Option$1.match(Option$1.fromNullishOr(verdictExitClass(command.score, command.breakingThreshold)), {
 	onNone: () => Option$1.match(precedenceOf(command.pending), {
@@ -1203,7 +1250,14 @@ var Trace_exports = /* @__PURE__ */ __exportAll$1({
 	layerTraceContextServer: () => layerTraceContextServer,
 	withLinkedSpan: () => withLinkedSpan
 });
-const WorkerOptionsWire = S.fromJsonString(Options_exports.StrykerOptionsSchema);
+const isEscapedKey = (key) => JSON.stringify(key) !== `"${key}"`;
+const omitEscapedKeys = (key, value) => isEscapedKey(key) ? void 0 : value;
+const withoutEscapedKeys = (options) => Option$1.getOrThrow(S.decodeUnknownOption(Options_exports.StrykerOptionsSchema)(JSON.parse(JSON.stringify(options, omitEscapedKeys))));
+const OptionsLawDomain = S.declare((value) => S.is(Options_exports.StrykerOptionsSchema)(value), { toCodecArbitrary: () => S.link()(Options_exports.StrykerOptionsSchema, {
+	decode: SchemaGetter.transform(withoutEscapedKeys),
+	encode: SchemaGetter.passthrough()
+}) });
+const WorkerOptionsWire = S.fromJsonString(Options_exports.StrykerOptionsSchema.pipe(S.decodeTo(OptionsLawDomain, SchemaTransformation.passthrough())));
 var WorkerOptions = class WorkerOptions extends Context.Service()("@systemfsoftware/stryker-js-plugin-runtime/worker-options.service/WorkerOptions") {
 	static layer = Layer.effect(WorkerOptions, Effect$1.gen(function* () {
 		const workerDir = yield* Config.String("STRYKER_WORKER_DIR");
@@ -1219,17 +1273,29 @@ const restrictSocket = (address) => Match.value(address).pipe(Match.tag("UnixPat
 	onTrue: () => Effect$1.void,
 	onFalse: () => Effect$1.flatMap(FileSystem.FileSystem, (fs) => fs.chmod(path, 384))
 })), Match.orElse(() => Effect$1.void));
-const workerServerLayer = (params) => Layer.unwrap(Effect$1.gen(function* () {
+const TypeId$7 = Symbol.for("~systemfsoftware/stryker-js-plugin-runtime/WorkerServer");
+const workerServerLayerOf = (params) => Layer.unwrap(Effect$1.gen(function* () {
 	const socket = yield* SocketServer.SocketServer;
 	yield* restrictSocket(socket.address);
 	return RpcServer.layer(params.rpcs).pipe(Layer.provide(params.handlers), Layer.provide(params.schemaServices), Layer.provide(RpcServer.layerProtocolSocketServer), Layer.provide(RpcSerialization.layerNdjson), Layer.provide(traceContextServer));
 }));
+Blueprint.make()(TypeId$7).steps({
+	steps: {},
+	targets: { layer: workerServerLayerOf }
+}).is;
+const workerServerLayer = workerServerLayerOf;
 const TRACES_SUFFIX = "/v1/traces";
 const tracesUrlOf = (endpoint) => Option$1.match(Option$1.liftPredicate(endpoint.replace(/\/+$/u, ""), (trimmed) => trimmed.endsWith(TRACES_SUFFIX)), {
 	onSome: (trimmed) => trimmed,
 	onNone: () => `${endpoint.replace(/\/+$/u, "")}${TRACES_SUFFIX}`
 });
-const canonicalTracesUrl = S.String.pipe(S.check(S.isPattern(/\/v1\/traces$/u)), S.check(S.isPattern(/[^/]$/u)));
+const canonicalTracesUrl = S.String.pipe(S.check(S.isPattern(/\/v1\/traces$/u, { arbitraryConstraint: {
+	patterns: [{
+		source: "\\/v1\\/traces$",
+		flags: "u"
+	}],
+	minLength: 12
+} })));
 const TracesUrl = S.String.pipe(S.decodeTo(canonicalTracesUrl, {
 	decode: SchemaGetter$1.transform(tracesUrlOf),
 	encode: SchemaGetter$1.passthrough()
@@ -1261,23 +1327,22 @@ var Worker_exports = /* @__PURE__ */ __exportAll$1({
 });
 //#endregion
 //#region src/spawned-socket-worker.handle.ts
-const TypeId$2 = Symbol.for("@systemfsoftware/stryker-js/SpawnedSocketWorker");
-const ClientLayerTypeId = Symbol.for("@systemfsoftware/stryker-js/SpawnedSocketWorker/clientLayer");
-const make$2 = (worker) => ({
-	[TypeId$2]: TypeId$2,
-	[ClientLayerTypeId]: worker.clientLayer,
+const TypeId$6 = Symbol.for("~systemfsoftware/stryker-js/SpawnedSocketWorker");
+const SpawnedSocketWorker = Handle.make()(TypeId$6);
+SpawnedSocketWorker.is;
+const make$2 = (worker) => SpawnedSocketWorker.make({
 	pid: worker.pid,
-	exited: worker.exited,
-	...Prototype
-});
-const clientLayer = (self) => self[ClientLayerTypeId];
+	exited: worker.exited
+}, { clientLayer: worker.clientLayer });
+const clientLayer = (self) => SpawnedSocketWorker.slot(self).clientLayer;
 //#endregion
 //#region src/WorkerLauncher.service.ts
 var WorkerLauncher = class extends Context.Service()("@systemfsoftware/stryker-js/WorkerLauncher.service/WorkerLauncher") {};
 //#endregion
-//#region src/worker-client.resource.ts
+//#region src/worker-client.blueprint.ts
+const TypeId$5 = Symbol.for("~systemfsoftware/stryker-js/WorkerClient");
 const connectRetry = Schedule.max([Schedule.spaced(50), Schedule.recurs(100)]);
-const makeWorkerClient = (params) => Effect$1.gen(function* () {
+const scopedOf$1 = (params) => Effect$1.gen(function* () {
 	const launcher = yield* WorkerLauncher;
 	const optionsJson = yield* S.encodeEffect(Worker_exports.WorkerOptionsWire)(params.options).pipe(Effect$1.orDie);
 	const worker = yield* launcher.spawn({
@@ -1292,6 +1357,11 @@ const makeWorkerClient = (params) => Effect$1.gen(function* () {
 	const traceContext = yield* Layer.build(Trace_exports.layerTraceContextClient);
 	return yield* RpcClient.make(params.rpcs).pipe(Effect$1.provideContext(Context.merge(protocol, traceContext)));
 });
+const WorkerClients = () => Blueprint.make()(TypeId$5).steps({
+	steps: {},
+	targets: { scoped: scopedOf$1 }
+});
+const makeWorkerClient = (params) => WorkerClients().of(params).scoped;
 const ReporterStageTypeId = Symbol.for("@systemfsoftware/stryker-js/ReporterStage");
 const carriesAttachments = (stage) => "attachments" in stage;
 const makeReporterStage = (attachments) => {
@@ -1639,7 +1709,10 @@ var VerdictEnvelope = class VerdictEnvelope extends S.Class("VerdictEnvelope")({
 			runId,
 			mode,
 			signal,
-			score: Option$1.getOrNull(Option$1.filter(Option$1.some(metrics.mutationScore), (score) => metrics.totalMutants > 0 && Number.isFinite(score))),
+			score: Report_exports.MutationScore.match(metrics.mutationScore, {
+				Scored: ({ percentage }) => percentage,
+				Unscored: () => null
+			}),
 			thresholds: {
 				high: report.thresholds.high,
 				low: report.thresholds.low,
@@ -1677,7 +1750,7 @@ var RunEvents = class extends Context.Service()("@systemfsoftware/stryker-js/run
 var RunIdentity = class extends Context.Service()("@systemfsoftware/stryker-js/run-events.service/RunIdentity") {};
 //#endregion
 //#region package.json
-var version = "11.0.0";
+var version = "12.1.0";
 //#endregion
 //#region src/stryker-package.schema.ts
 var StrykerPackage = class extends S.Class("StrykerPackage")({
@@ -1969,22 +2042,28 @@ const mutationTestReport = (deps, input) => (results) => Effect$1.gen(function*
 		identities
 	};
 });
-const determineExitCode = (input) => (metrics) => Effect$1.gen(function* () {
-	const { mutationScore } = metrics.metrics;
+const determineExitCode = (input) => (metrics) => {
 	const breaking = input.options.thresholds.break;
-	const formattedScore = mutationScore.toFixed(2);
-	return yield* Option$1.match(Option$1.fromNullishOr(Result.match(classifyExit(ClassifyExitCommand.make({
+	const score = metrics.metrics.mutationScore;
+	const failure = Option$1.fromNullishOr(Result.match(classifyExit(ClassifyExitCommand.make({
 		pending: [],
-		score: mutationScore,
+		score,
 		breakingThreshold: breaking
 	})), {
 		onFailure: (refused) => refused,
 		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("ExitVerdictFailed", () => "VerdictFail"), Match.orElse(() => null))
-	})), {
-		onNone: () => Effect$1.map(Match.value(breaking).pipe(Match.when(null, () => Effect$1.logDebug("No breaking threshold configured. Won't fail the build no matter how low your mutation score is. Set `thresholds.break` to change this behavior.")), Match.orElse((threshold) => Effect$1.logInfo(`Final mutation score of ${formattedScore} is greater than or equal to break threshold ${String(threshold)}`))), () => null),
-		onSome: (failure) => Effect$1.map(Effect$1.andThen(Effect$1.logError(`Final mutation score ${formattedScore} under breaking threshold ${String(breaking)}, setting exit code to 1 (failure).`), Effect$1.logInfo("(improve mutation score or set `thresholds.break = null` to prevent this error in the future)")), () => failure)
+	}));
+	return Report_exports.MutationScore.match(score, {
+		Scored: ({ percentage }) => Option$1.match(failure, {
+			onNone: () => Effect$1.as(logScoredPass(breaking, percentage), null),
+			onSome: (exitClass) => Effect$1.as(logBroken(breaking, percentage), exitClass)
+		}),
+		Unscored: () => Effect$1.as(logUnscored(breaking), Option$1.getOrNull(failure))
 	});
-});
+};
+const logScoredPass = (breaking, percentage) => Match.value(breaking).pipe(Match.when(null, () => Effect$1.logDebug("No breaking threshold configured. Won't fail the build no matter how low your mutation score is. Set `thresholds.break` to change this behavior.")), Match.orElse((threshold) => Effect$1.logInfo(`Final mutation score of ${percentage.toFixed(2)} is greater than or equal to break threshold ${String(threshold)}`)));
+const logUnscored = (breaking) => Match.value(breaking).pipe(Match.when(null, () => Effect$1.void), Match.orElse((threshold) => Effect$1.logInfo(`No valid mutant was tested, so there is no mutation score to hold against break threshold ${String(threshold)}`)));
+const logBroken = (breaking, percentage) => Effect$1.andThen(Effect$1.logError(`Final mutation score ${percentage.toFixed(2)} under breaking threshold ${String(breaking)}, setting exit code to 1 (failure).`), Effect$1.logInfo("(improve mutation score or set `thresholds.break = null` to prevent this error in the future)"));
 const emitVerdict = (deps, input) => (report) => Effect$1.gen(function* () {
 	const envelope = VerdictEnvelope.build(report, input.resolvedMode.mode, input.resolvedMode.signal, input.runId, input.basePath, deps.path);
 	yield* Queue.offer(deps.events, VerdictReached.make({
@@ -2016,7 +2095,7 @@ const reportAll = (deps, input) => Effect$1.gen(function* () {
 	const verdict = yield* determineExitCode(input)(metrics);
 	const finalVerdict = Result.match(classifyExit(ClassifyExitCommand.make({
 		pending: [verdict, terminalDrain].filter((candidate) => candidate !== null),
-		score: null,
+		score: Report_exports.MutationScore.cases.Unscored.make({}),
 		breakingThreshold: null
 	})), {
 		onFailure: (refused) => refused,
@@ -2108,7 +2187,8 @@ var ClearTextReportCommand = class extends S.TaggedClass()("ClearTextReportComma
 };
 var ClearTextReportRendered = class extends S.TaggedClass()("ClearTextReportRendered", {
 	stdout: S.Array(ReportChunkSchema),
-	diagnostics: S.Array(ReportChunkSchema)
+	diagnostics: S.Array(ReportChunkSchema),
+	stderr: S.Array(ReportChunkSchema)
 }) {
 	[ClearTextReportTypeId] = ClearTextReportTypeId;
 };
@@ -2367,8 +2447,12 @@ const mutantReportSection = (report, metrics, render) => Boolean$1.match(render.
 	},
 	onFalse: () => EMPTY_SECTIONS
 });
+const hasFullScore = (metrics) => Match.valueTags(metrics.mutationScore, {
+	Scored: ({ percentage }) => percentage === 100,
+	Unscored: () => false
+});
 const partialScoresVisible = (metrics, render) => Boolean$1.match(render.skipFull, {
-	onTrue: () => metrics.childResults.some((child) => child.metrics.mutationScore !== 100),
+	onTrue: () => metrics.childResults.some((child) => !hasFullScore(child.metrics)),
 	onFalse: () => true
 });
 const drawsScoreTable = (metrics, render) => Boolean$1.match(render.reportScoreTable, {
@@ -2376,14 +2460,14 @@ const drawsScoreTable = (metrics, render) => Boolean$1.match(render.reportScoreT
 	onFalse: () => false
 });
 const mutationScoreOf = (scoreType, metrics) => Match.value(scoreType).pipe(Match.when("total", () => metrics.mutationScore), Match.when("covered", () => metrics.mutationScoreBasedOnCoveredCode), Match.exhaustive);
-const scoreText = (scoreType, row) => {
-	const score = mutationScoreOf(scoreType, row.metrics);
-	return Boolean$1.match(Number.isNaN(score), {
-		onTrue: () => "n/a",
-		onFalse: () => score.toFixed(2)
-	});
-};
-const thresholdTone = (thresholds, score) => Match.value(score).pipe(Match.when((present) => Number.isNaN(present), () => "muted"), Match.when((present) => present >= thresholds.high, () => "positive"), Match.when((present) => present >= thresholds.low, () => "warning"), Match.orElse(() => "negative"));
+const scoreText = (scoreType, row) => Match.valueTags(mutationScoreOf(scoreType, row.metrics), {
+	Scored: ({ percentage }) => percentage.toFixed(2),
+	Unscored: () => "n/a"
+});
+const thresholdTone = (thresholds, score) => Match.valueTags(score, {
+	Scored: ({ percentage }) => Match.value(percentage).pipe(Match.when((value) => value >= thresholds.high, () => "positive"), Match.when((value) => value >= thresholds.low, () => "warning"), Match.orElse(() => "negative")),
+	Unscored: () => "muted"
+});
 const scoreTone = (thresholds, scoreType, allowColor) => Boolean$1.match(allowColor, {
 	onTrue: () => (row) => thresholdTone(thresholds, mutationScoreOf(scoreType, row.metrics)),
 	onFalse: () => () => "plain"
@@ -2480,7 +2564,7 @@ const createColumns = (metricsResult, render) => [
 const leafRules = (columns) => columns.flatMap((column) => column.leaves.map((leaf) => [rule("-", slotWidthOf(leaf))]));
 const leafHeaders = (columns) => columns.flatMap((column) => column.leaves.map((leaf) => placedLine(leaf.header, leaf.style, leaf.netWidth)));
 const fullRowVisible = (render, row) => Boolean$1.match(render.skipFull, {
-	onTrue: () => row.metrics.mutationScore !== 100,
+	onTrue: () => !hasFullScore(row.metrics),
 	onFalse: () => true
 });
 const bodyRow = (columns, row, ancestorCount) => rowOfLines(columns.flatMap((column) => column.leaves.map((leaf) => [placedCell(leaf.cell(row, ancestorCount), leaf.style, leaf.netWidth, leaf.tone(row))])));
@@ -2525,7 +2609,11 @@ const renderClearTextReport = Workflow.make({
 			const sections = renderClearText(report, metrics, command.render);
 			return Result.succeed(ClearTextReportRendered.make({
 				stdout: [...sections.stdout],
-				diagnostics: [...sections.diagnostics]
+				diagnostics: [...sections.diagnostics],
+				stderr: Boolean$1.match(command.render.debug, {
+					onTrue: () => [...sections.diagnostics],
+					onFalse: () => []
+				})
 			}));
 		}
 	})
@@ -2575,14 +2663,8 @@ const renderOptionsOf = (options) => ({
 });
 const readClearTextReport = (input) => Effect$1.map(Stream.fromAsyncIterable(input.events, failAsClearText).pipe(Stream.filterMap(terminalReportOf), Stream.run(Sink.last())), (terminal) => ({
 	_tag: "ClearTextReportCommand",
-	reported: Option$1.match(terminal, {
-		onNone: () => void 0,
-		onSome: (ready) => ready.report
-	}),
-	computed: Option$1.match(terminal, {
-		onNone: () => void 0,
-		onSome: (ready) => ready.metrics
-	}),
+	reported: Option$1.getOrUndefined(Option$1.map(terminal, (ready) => ready.report)),
+	computed: Option$1.getOrUndefined(Option$1.map(terminal, (ready) => ready.metrics)),
 	render: renderOptionsOf(input.options),
 	rendered: true
 }));
@@ -2619,13 +2701,10 @@ const renderLine = (line) => runsOf(line).map(renderSpan).join("");
 const renderChunk = (chunk) => chunk.map(renderLine).join("\n");
 const writeChunks = (output, channel, chunks) => output.write(channel, chunks.map((chunk) => `${renderChunk(chunk)}\n`)).pipe(Effect$1.mapError(failAsClearText), Effect$1.asVoid);
 const clearTextReportCell = Sandwich.named("stryker.report.clearText")(readClearTextReport).decide(renderClearTextReport).write({
-	ClearTextReportRendered: (rendered, raw) => Effect$1.gen(function* () {
+	ClearTextReportRendered: (rendered, _raw) => Effect$1.gen(function* () {
 		const output = yield* ReporterOutput;
 		yield* writeChunks(output, "stdout", rendered.stdout);
-		yield* Boolean$1.match(raw.render.debug, {
-			onTrue: () => writeChunks(output, "stderr", rendered.diagnostics),
-			onFalse: () => Effect$1.void
-		});
+		yield* Effect$1.forEach(rendered.stderr, (chunk) => writeChunks(output, "stderr", [chunk]), { discard: true });
 	}),
 	ClearTextReportSuppressed: () => Effect$1.void,
 	CommandRejected: ({ issue }) => Effect$1.fail(failAsClearText(issue))
@@ -2642,11 +2721,16 @@ const clearTextReporterFactory = (context) => {
 const JsonReportTypeId = Symbol.for("@systemfsoftware/stryker-js/JsonReport");
 var JsonReportCommand = class extends S.TaggedClass()("JsonReportCommand", {
 	reported: S.optional(Report_exports.MutationTestResultSchema),
-	rendered: S.Boolean
+	rendered: S.Boolean,
+	debug: S.Boolean,
+	fileName: S.String
 }) {
 	static [Workflow.InstrumentationBrand] = { rendered: "stryker.report.render" };
 };
-var JsonReportRendered = class extends S.TaggedClass()("JsonReportRendered", { report: Report_exports.MutationTestResultSchema }) {
+var JsonReportRendered = class extends S.TaggedClass()("JsonReportRendered", {
+	report: Report_exports.MutationTestResultSchema,
+	announceFileName: S.Option(S.String)
+}) {
 	[JsonReportTypeId] = JsonReportTypeId;
 };
 var JsonReportSuppressed = class extends S.TaggedClass()("JsonReportSuppressed", {}) {
@@ -2659,7 +2743,13 @@ const renderJsonReport = Workflow.make({
 	error: S.Never,
 	decide: (command) => Option$1.match(Option$1.fromUndefinedOr(command.reported), {
 		onNone: () => Result.succeed(JsonReportSuppressed.make({})),
-		onSome: (report) => Result.succeed(JsonReportRendered.make({ report }))
+		onSome: (report) => Result.succeed(JsonReportRendered.make({
+			report,
+			announceFileName: Boolean$1.match(command.debug, {
+				onTrue: () => Option$1.some(command.fileName),
+				onFalse: () => Option$1.none()
+			})
+		}))
 	})
 });
 //#endregion
@@ -2674,13 +2764,11 @@ const readJsonReport = (input) => Effect$1.map(Stream.fromAsyncIterable(input.ev
 	_tag: "JsonReportCommand",
 	reported: Option$1.getOrUndefined(last),
 	rendered: true,
+	debug: input.options.logLevel === "debug",
+	fileName: input.options.jsonReporter.fileName,
 	options: input.options
 }));
 const jsonBytesOf = (report) => S.encodeEffect(S.fromJsonString(S.Unknown, { space: 0 }))(report).pipe(Effect$1.mapError(failAsJsonReporter));
-const announceRelativePath = (output, options, path) => Boolean$1.match(options.logLevel === "debug", {
-	onTrue: () => Effect$1.ignore(output.write("stderr", [`Using relative path ${path.normalize(options.jsonReporter.fileName)}\n`])),
-	onFalse: () => Effect$1.void
-});
 const jsonReportCell = Sandwich.named("stryker.report.json")(readJsonReport).decide(renderJsonReport).write({
 	JsonReportRendered: (rendered, raw) => Effect$1.gen(function* () {
 		const output = yield* ReporterOutput;
@@ -2688,7 +2776,7 @@ const jsonReportCell = Sandwich.named("stryker.report.json")(readJsonReport).dec
 		const path = yield* Path.Path;
 		const json = yield* jsonBytesOf(rendered.report);
 		const fileName = path.resolve(raw.options.jsonReporter.fileName);
-		yield* announceRelativePath(output, raw.options, path);
+		yield* Effect$1.forEach(Option$1.toArray(rendered.announceFileName), (name) => Effect$1.ignore(output.write("stderr", [`Using relative path ${path.normalize(name)}\n`])), { discard: true });
 		yield* fs.makeDirectory(path.dirname(fileName), { recursive: true }).pipe(Effect$1.mapError(failAsJsonReporter));
 		yield* fs.writeFileString(fileName, json).pipe(Effect$1.mapError(failAsJsonReporter));
 		const url = yield* path.toFileUrl(fileName).pipe(Effect$1.mapError(failAsJsonReporter));
@@ -2705,116 +2793,11 @@ const jsonReporterFactory = (context) => {
 	}));
 };
 //#endregion
-//#region src/render-progress-report.workflow.ts
-const ProgressReportTypeId = Symbol.for("@systemfsoftware/stryker-js/ProgressReport");
-const ProgressTimingSchema = S.Struct({
-	net: S.Finite,
-	overhead: S.Finite
-});
-const ProgressCapabilitiesSchema = S.Struct({ reloadEnvironment: S.Boolean });
-const ProgressTallySchema = S.Struct({
-	survived: S.Finite,
-	timedOut: S.Finite,
-	tested: S.Finite,
-	mutants: S.Finite,
-	total: S.Finite,
-	ticks: S.Finite,
-	ticksByMutantId: S.Record(S.String, S.Finite),
-	timing: ProgressTimingSchema,
-	capabilities: ProgressCapabilitiesSchema,
-	startedAt: S.Finite
-});
-const ProgressBarStateSchema = S.Struct({
-	format: S.String,
-	total: S.Finite,
-	curr: S.Finite,
-	width: S.Finite,
-	complete: S.String,
-	incomplete: S.String
-});
-const ProgressStateSchema = S.Struct({
-	tally: ProgressTallySchema,
-	bar: S.NullOr(ProgressBarStateSchema)
-});
-var ProgressReportCommand = class extends S.TaggedClass()("ProgressReportCommand", {
-	kind: S.Literals([
-		"tick",
-		"skip",
-		"finalize"
-	]),
-	state: ProgressStateSchema,
-	now: S.Finite
-}) {
-	static [Workflow.InstrumentationBrand] = { now: "stryker.report.rendered" };
-};
-var ProgressBarTick = class extends S.TaggedClass()("ProgressBarTick", {
-	bar: ProgressBarStateSchema,
-	tally: ProgressTallySchema,
-	now: S.Finite
-}) {
-	[ProgressReportTypeId] = ProgressReportTypeId;
-};
-var ProgressLineBreak = class extends S.TaggedClass()("ProgressLineBreak", {}) {
-	[ProgressReportTypeId] = ProgressReportTypeId;
-};
-var ProgressChunkSuppressed = class extends S.TaggedClass()("ProgressChunkSuppressed", {}) {
-	[ProgressReportTypeId] = ProgressReportTypeId;
-};
-const ProgressReportDecision = S.Union([
-	ProgressBarTick,
-	ProgressLineBreak,
-	ProgressChunkSuppressed
-]);
-const isComplete$1 = (bar) => bar.curr >= bar.total;
-const renderProgressReport = Workflow.make({
-	command: ProgressReportCommand,
-	decision: ProgressReportDecision,
-	error: S.Never,
-	decide: (command) => Result.succeed(Match.value(command.kind).pipe(Match.when("finalize", () => Option$1.match(Option$1.fromNullishOr(command.state.bar), {
-		onNone: () => ProgressChunkSuppressed.make({}),
-		onSome: (bar) => Boolean$1.match(isComplete$1(bar), {
-			onTrue: () => ProgressChunkSuppressed.make({}),
-			onFalse: () => ProgressLineBreak.make({})
-		})
-	})), Match.when("skip", () => ProgressChunkSuppressed.make({})), Match.when("tick", () => Option$1.match(Option$1.fromNullishOr(command.state.bar), {
-		onNone: () => ProgressChunkSuppressed.make({}),
-		onSome: (bar) => ProgressBarTick.make({
-			bar,
-			tally: command.state.tally,
-			now: command.now
-		})
-	})), Match.exhaustive))
-});
-//#endregion
-//#region src/progress-report.cell.ts
-const failAsProgress = (cause) => Reporter_exports.ReporterFailed.make({
-	reporterName: "progress",
-	event: "mutationTestReportReady",
-	cause: Option$1.getOrElse(Option$1.map(ErrorText_exports.ErrorText.fromCause(cause), (rendered) => rendered.text), () => "")
-});
+//#region src/progress-report.steps.ts
 const PROGRESS_BAR_FORMAT = "Mutation testing  [:bar] :percent (elapsed: :et, remaining: :etc) :tested/:mutants Mutants tested (:survived survived, :timedOut timed out)";
 const PROGRESS_BAR_WIDTH = 50;
 const PROGRESS_BAR_COMPLETE = "=";
 const PROGRESS_BAR_INCOMPLETE = " ";
-const emptyTally = (startedAt) => ({
-	survived: 0,
-	timedOut: 0,
-	tested: 0,
-	mutants: 0,
-	total: 0,
-	ticks: 0,
-	ticksByMutantId: {},
-	timing: {
-		net: 0,
-		overhead: 0
-	},
-	capabilities: { reloadEnvironment: false },
-	startedAt
-});
-const INITIAL_PROGRESS = {
-	tally: emptyTally(0),
-	bar: null
-};
 const TALLY_COUNTED = {
 	Killed: {
 		survived: 0,
@@ -2917,24 +2900,14 @@ const advance = (state, event, now) => Match.value(event).pipe(Match.tag("dryRun
 	kind: "skip",
 	state
 })));
-const readProgressStep = (input) => Effect$1.map(Effect$1.sync(() => performance.now()), (now) => Option$1.match(Option$1.fromNullishOr(input.event), {
+const progressStep = (input) => Option$1.match(Option$1.fromNullishOr(input.event), {
 	onNone: () => ({
-		_tag: "ProgressReportCommand",
 		kind: "finalize",
-		state: input.state,
-		now
+		state: input.state
 	}),
-	onSome: (event) => {
-		const step = advance(input.state, event, now);
-		return {
-			_tag: "ProgressReportCommand",
-			kind: step.kind,
-			state: step.state,
-			now
-		};
-	}
-}));
-const isComplete = (bar) => bar.curr >= bar.total;
+	onSome: (present) => advance(input.state, present, input.now)
+});
+const isComplete$1 = (bar) => bar.curr >= bar.total;
 const secondsBetween = (now, startedAt) => Math.floor((now - startedAt) / 1e3);
 const formatTime = (timeInSeconds) => {
 	const hours = Math.floor(timeInSeconds / 3600);
@@ -2972,7 +2945,128 @@ const lineBreakOf = (complete) => Boolean$1.match(complete, {
 	onTrue: () => "\n",
 	onFalse: () => ""
 });
-const renderTick = (tick) => `\r${formatBar(tick.bar, progressData(tick.tally, tick.now))}${lineBreakOf(isComplete(tick.bar))}`;
+const renderTick = (tick) => `\r${formatBar(tick.bar, progressData(tick.tally, tick.now))}${lineBreakOf(isComplete$1(tick.bar))}`;
+//#endregion
+//#region src/render-progress-report.workflow.ts
+const ProgressReportTypeId = Symbol.for("@systemfsoftware/stryker-js/ProgressReport");
+const ProgressTimingSchema = S.Struct({
+	net: S.Finite,
+	overhead: S.Finite
+});
+const ProgressCapabilitiesSchema = S.Struct({ reloadEnvironment: S.Boolean });
+const ProgressTallySchema = S.Struct({
+	survived: S.Finite,
+	timedOut: S.Finite,
+	tested: S.Finite,
+	mutants: S.Finite,
+	total: S.Finite,
+	ticks: S.Finite,
+	ticksByMutantId: S.Record(S.String, S.Finite),
+	timing: ProgressTimingSchema,
+	capabilities: ProgressCapabilitiesSchema,
+	startedAt: S.Finite
+});
+const ProgressBarStateSchema = S.Struct({
+	format: S.String,
+	total: S.Finite,
+	curr: S.Finite,
+	width: S.Finite,
+	complete: S.String,
+	incomplete: S.String
+});
+const ProgressStateSchema = S.Struct({
+	tally: ProgressTallySchema,
+	bar: S.NullOr(ProgressBarStateSchema)
+});
+var ProgressReportCommand = class extends S.TaggedClass()("ProgressReportCommand", {
+	kind: S.Literals([
+		"tick",
+		"skip",
+		"finalize"
+	]),
+	state: ProgressStateSchema,
+	now: S.Finite
+}) {
+	static [Workflow.InstrumentationBrand] = { now: "stryker.report.rendered" };
+};
+var ProgressBarTick = class extends S.TaggedClass()("ProgressBarTick", {
+	bar: ProgressBarStateSchema,
+	tally: ProgressTallySchema,
+	now: S.Finite
+}) {
+	[ProgressReportTypeId] = ProgressReportTypeId;
+};
+var ProgressLineBreak = class extends S.TaggedClass()("ProgressLineBreak", {}) {
+	[ProgressReportTypeId] = ProgressReportTypeId;
+};
+var ProgressChunkSuppressed = class extends S.TaggedClass()("ProgressChunkSuppressed", {}) {
+	[ProgressReportTypeId] = ProgressReportTypeId;
+};
+const ProgressReportDecision = S.Union([
+	ProgressBarTick,
+	ProgressLineBreak,
+	ProgressChunkSuppressed
+]);
+const isComplete = (bar) => bar.curr >= bar.total;
+const renderProgressReport = Workflow.make({
+	command: ProgressReportCommand,
+	decision: ProgressReportDecision,
+	error: S.Never,
+	decide: (command) => Result.succeed(Match.value(command.kind).pipe(Match.when("finalize", () => Option$1.match(Option$1.fromNullishOr(command.state.bar), {
+		onNone: () => ProgressChunkSuppressed.make({}),
+		onSome: (bar) => Boolean$1.match(isComplete(bar), {
+			onTrue: () => ProgressChunkSuppressed.make({}),
+			onFalse: () => ProgressLineBreak.make({})
+		})
+	})), Match.when("skip", () => ProgressChunkSuppressed.make({})), Match.when("tick", () => Option$1.match(Option$1.fromNullishOr(command.state.bar), {
+		onNone: () => ProgressChunkSuppressed.make({}),
+		onSome: (bar) => ProgressBarTick.make({
+			bar,
+			tally: command.state.tally,
+			now: command.now
+		})
+	})), Match.exhaustive))
+});
+//#endregion
+//#region src/progress-report.cell.ts
+const failAsProgress = (cause) => Reporter_exports.ReporterFailed.make({
+	reporterName: "progress",
+	event: "mutationTestReportReady",
+	cause: Option$1.getOrElse(Option$1.map(ErrorText_exports.ErrorText.fromCause(cause), (rendered) => rendered.text), () => "")
+});
+const emptyTally = (startedAt) => ({
+	survived: 0,
+	timedOut: 0,
+	tested: 0,
+	mutants: 0,
+	total: 0,
+	ticks: 0,
+	ticksByMutantId: {},
+	timing: {
+		net: 0,
+		overhead: 0
+	},
+	capabilities: { reloadEnvironment: false },
+	startedAt
+});
+const INITIAL_PROGRESS = {
+	tally: emptyTally(0),
+	bar: null
+};
+const readProgressStep = (input) => Effect$1.gen(function* () {
+	const now = yield* Clock.currentTimeMillis;
+	const step = progressStep({
+		state: input.state,
+		event: input.event,
+		now
+	});
+	return {
+		_tag: "ProgressReportCommand",
+		kind: step.kind,
+		state: step.state,
+		now
+	};
+});
 const writeChunk = (chunk) => Effect$1.flatMap(ReporterOutput, (output) => Effect$1.ignore(output.write("stdout", [chunk])));
 const progressReportCell = Sandwich.named("stryker.report.progress")(readProgressStep).decide(renderProgressReport).write({
 	ProgressBarTick: (tick, raw) => Effect$1.as(writeChunk(renderTick(tick)), raw.state),
@@ -3061,7 +3155,7 @@ const phaseEntered = (phase) => Effect$1.gen(function* () {
 	}));
 });
 //#endregion
-//#region src/run/load-config.cell.ts
+//#region src/run/load-config.parts.ts
 const isNonNullObject = (value) => typeof value === "object" && value !== null;
 const combine = (prefixes, suffixes, extensions) => prefixes.flatMap((prefix) => suffixes.flatMap((suffix) => extensions.map((extension) => `${prefix}stryker${suffix}.${extension}`)));
 const CONFIG_FILE_NAME_PREFIXES = ["", "."];
@@ -3228,7 +3322,7 @@ const applyConfigFactory = (factory, configEnv) => factory(configEnv);
 /**
 * Settle a config module's default export into the object the document schema decodes.
 *
-* `./config` types `StrykerConfig.define` as accepting the config object, a promise of it,
+* `./config` types `defineConfig` as accepting the config object, a promise of it,
 * or a factory receiving `ConfigEnv`, so the loader accepts all three. The factory
 * is invoked here because this is the only place that knows the invocation the
 * config is being read for; the promise is awaited here because a promise is a
@@ -3536,20 +3630,10 @@ const readLoadConfig = (input) => Effect$1.gen(function* () {
 	};
 	const cliRecord = yield* S.decodeEffect(ConfigDocumentSchema)(input.cliOptions).pipe(Effect$1.orDie);
 	return yield* loadOptionsFromConfigFile(cliRecord, configEnv).pipe(Effect$1.map((fileOptions) => LoadConfigCommand.make({
-		document: StrykerConfig.merge(Option$1.getOrElse(fileOptions, () => ({})), cliRecord),
+		document: mergeConfig(Option$1.getOrElse(fileOptions, () => ({})), cliRecord),
 		fileFound: Option$1.isSome(fileOptions)
 	})));
 });
-const loadConfig = Sandwich.named("stryker.config_read")(readLoadConfig).decide(resolveConfig).write({
-	ConfigFromFile: ({ options }) => Effect$1.succeed(options),
-	ConfigFromDefaults: ({ options }) => Effect$1.succeed(options),
-	ConfigOptionsRefused: ({ message }) => Effect$1.fail(ConfigError.make({ message: configErrorMessage(describeMessageOf(message)) })),
-	CommandRejected: ({ issue }) => Effect$1.fail(ConfigError.make({ message: issue }))
-});
-const readConfig = dual(2, (cliOptions, invocation) => loadConfig.run({
-	cliOptions,
-	invocation
-}));
 const emitPreparePhaseEntered = phaseEntered("prepare");
 const failConfigWith = (message) => Effect$1.fail(ConfigError.make({ message })).pipe(Effect$1.tapCause(() => emitPreparePhaseEntered));
 const readRunConfig = (input) => Effect$1.gen(function* () {
@@ -3566,6 +3650,18 @@ const readRunConfig = (input) => Effect$1.gen(function* () {
 		basePath: env.basePath
 	});
 });
+//#endregion
+//#region src/run/load-config.cell.ts
+const loadConfig = Sandwich.named("stryker.config_read")(readLoadConfig).decide(resolveConfig).write({
+	ConfigFromFile: ({ options }) => Effect$1.succeed(options),
+	ConfigFromDefaults: ({ options }) => Effect$1.succeed(options),
+	ConfigOptionsRefused: ({ message }) => Effect$1.fail(ConfigError.make({ message: configErrorMessage(describeMessageOf(message)) })),
+	CommandRejected: ({ issue }) => Effect$1.fail(ConfigError.make({ message: issue }))
+});
+const readConfig = dual(2, (cliOptions, invocation) => loadConfig.run({
+	cliOptions,
+	invocation
+}));
 const loadConfigCell = Sandwich.named("stryker.load_config")(readRunConfig).decide(resolveConfig).write({
 	ConfigFromFile: ({ options }, raw) => Effect$1.succeed({
 		options,
@@ -3620,9 +3716,10 @@ const classifyWorkerExit = Workflow.make({
 	decide: decide$8
 });
 //#endregion
-//#region src/worker-protocol.resource.ts
+//#region src/worker-protocol.blueprint.ts
+const TypeId$4 = Symbol.for("~systemfsoftware/stryker-js/WorkerProtocol");
 const droppedConnection = RpcClientError.make({ reason: Socket.SocketReadError.make({ cause: /* @__PURE__ */ new Error("worker connection dropped with the request in flight") }) });
-const layerWorkerProtocol = (socket) => Layer.effect(RpcClient.Protocol, Effect$1.gen(function* () {
+const layerOf = (socket) => Layer.effect(RpcClient.Protocol, Effect$1.gen(function* () {
 	const handlers = MutableHashMap.empty();
 	const inFlight = MutableHashMap.empty();
 	const connected = yield* Ref.make(false);
@@ -3661,10 +3758,15 @@ const layerWorkerProtocol = (socket) => Layer.effect(RpcClient.Protocol, Effect$
 		send: (clientId, request, transferables) => track(clientId, request).pipe(Effect$1.andThen(inner.send(clientId, request, transferables)))
 	});
 }));
+const WorkerProtocol = Blueprint.make()(TypeId$4).steps({
+	steps: {},
+	targets: { layer: (spec) => layerOf(spec.socket) }
+});
+const layerWorkerProtocol = (socket) => WorkerProtocol.of({ socket }).layer;
 //#endregion
 //#region src/drivers/node.ts
 const restrictToOwnerOrWarn = (fs, file) => fs.chmod(file, 384).pipe(Effect$1.tapError((cause) => Effect$1.logWarning(`Could not restrict "${file}" to its owner; the worker directory's own mode still protects it.`).pipe(Effect$1.annotateLogs("cause", cause))), Effect$1.catchTag("PlatformError", () => Effect$1.void));
-const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.gen(function* () {
+const nodeWorkerLauncherLayer = (childEnv) => Layer.effect(WorkerLauncher, Effect$1.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -3683,6 +3785,7 @@ const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.gen(functi
 			env: {
 				STRYKER_WORKER_DIR: workerDir,
 				STRYKER_SOCKET: socketPath,
+				...childEnv,
 				...params.env
 			},
 			stderr: "inherit"
@@ -3722,7 +3825,8 @@ const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.gen(functi
 const nodeFsPathLayer$1 = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer);
 const nodeSpawnerLayer = NodeChildProcessSpawner.layer.pipe(Layer.provide(nodeFsPathLayer$1));
 const nodeBase = Layer.mergeAll(nodeFsPathLayer$1, nodeSpawnerLayer, NodeStdio.layer);
-const nodePlatformLayer = Layer.mergeAll(nodeWorkerLauncherLayer.pipe(Layer.provide(Layer.merge(nodeBase, NodeCrypto.layer))), nodeBase);
+const makeNodePlatformLayer = (options) => Layer.mergeAll(nodeWorkerLauncherLayer(options.childEnv).pipe(Layer.provide(Layer.merge(nodeBase, NodeCrypto.layer))), nodeBase);
+const nodePlatformLayer = makeNodePlatformLayer({ childEnv: {} });
 //#endregion
 //#region src/IncrementalDiff.schema.ts
 const PositionSchema$1 = S.Struct({
@@ -3897,7 +4001,7 @@ const writeHtmlFile = (fileName, html) => Effect$1.gen(function* () {
 const readRenderCommand = (input) => Effect$1.succeed({
 	_tag: "RenderHtmlReport",
 	fileName: input.fileName,
-	inlinedBundle: inlinedBundle(),
+	inlinedBundle: input.inlinedBundle,
 	report: input.report
 });
 const writeHtmlReport = Sandwich.named("html_report.write")(readRenderCommand).decide(renderHtmlReport).write({
@@ -3916,7 +4020,8 @@ const failAsHtmlReporter = (cause) => Reporter_exports.ReporterFailed.make({
 });
 const drainEvents = (fileName, events) => Stream.runForEach(Stream.fromAsyncIterable(events, failAsHtmlReporter).pipe(Stream.filter(S.is(Reporter_exports.MutationTestReportReady))), (ready) => writeHtmlReport.run({
 	fileName,
-	report: ready.report
+	report: ready.report,
+	inlinedBundle: inlinedBundle()
 }).pipe(Effect$1.mapError(failAsHtmlReporter)));
 const makeHtmlReporter = dual(2, (options, _init) => (events) => Layer.build(nodeFsPathLayer).pipe(Effect$1.flatMap((platform) => Effect$1.provideContext(drainEvents(options.htmlReporter.fileName, events), platform)), Effect$1.scoped));
 var HtmlReporter_exports = /* @__PURE__ */ __exportAll({ makeHtmlReporter: () => makeHtmlReporter });
@@ -3927,7 +4032,8 @@ const PERCENTAGE_OPTION = /^(100|[1-9]?[0-9])%$/;
 var TestRunnersOnly = class extends S.TaggedClass()("TestRunnersOnly", {
 	testRunners: S.Finite,
 	total: S.Finite,
-	isPercentage: S.Boolean
+	isPercentage: S.Boolean,
+	announcement: S.Option(S.String)
 }) {
 	[ConcurrencyDecisionTypeId] = ConcurrencyDecisionTypeId;
 };
@@ -3935,7 +4041,8 @@ var TestRunnersAndCheckers = class extends S.TaggedClass()("TestRunnersAndChecke
 	testRunners: S.Finite,
 	checkers: S.Finite,
 	total: S.Finite,
-	isPercentage: S.Boolean
+	isPercentage: S.Boolean,
+	announcement: S.Option(S.String)
 }) {
 	[ConcurrencyDecisionTypeId] = ConcurrencyDecisionTypeId;
 };
@@ -3957,31 +4064,37 @@ const defaultedTotal = (availableParallelism) => Boolean$1.match(availableParall
 const percentageDetails = (text, availableParallelism) => Option$1.match(percentageOf(text), {
 	onSome: (percentage) => ({
 		total: percentageTotal(percentage, availableParallelism),
-		isPercentage: true
+		isPercentage: true,
+		announcement: Option$1.some(`Computed concurrency ${percentageTotal(percentage, availableParallelism)} from "${text}" based on ${availableParallelism} available parallelism.`)
 	}),
 	onNone: () => ({
 		total: defaultedTotal(availableParallelism),
-		isPercentage: false
+		isPercentage: false,
+		announcement: Option$1.none()
 	})
 });
 const detailsOf = (concurrency, availableParallelism) => Match.value(concurrency).pipe(Match.when(Predicate$1.isString, (text) => percentageDetails(text, availableParallelism)), Match.when(Predicate$1.isNumber, (total) => ({
 	total,
-	isPercentage: false
+	isPercentage: false,
+	announcement: Option$1.none()
 })), Match.orElse(() => ({
 	total: defaultedTotal(availableParallelism),
-	isPercentage: false
+	isPercentage: false,
+	announcement: Option$1.none()
 })));
 const splitOf = (details, checkerCount) => Boolean$1.match(checkerCount > 0, {
 	onTrue: () => TestRunnersAndCheckers.make({
 		testRunners: max$1(floor(details.total / 2), 1),
 		checkers: max$1(ceil(details.total / 2), 1),
 		total: details.total,
-		isPercentage: details.isPercentage
+		isPercentage: details.isPercentage,
+		announcement: details.announcement
 	}),
 	onFalse: () => TestRunnersOnly.make({
 		testRunners: details.total,
 		total: details.total,
-		isPercentage: details.isPercentage
+		isPercentage: details.isPercentage,
+		announcement: details.announcement
 	})
 });
 const decide$7 = (command) => Result.succeed(splitOf(detailsOf(command.concurrency, command.availableParallelism), command.checkerCount));
@@ -4003,19 +4116,15 @@ const readConcurrency = (record) => Effect$1.sync(() => ({
 	availableParallelism: availableParallelism(),
 	record
 }));
-const announcePercentage = (command, total, isPercentage) => Boolean$1.match(isPercentage, {
-	onTrue: () => Effect$1.logDebug(`Computed concurrency ${total} from "${command.concurrency}" based on ${command.availableParallelism} available parallelism.`),
-	onFalse: () => Effect$1.void
-});
 const concurrencyCell = Sandwich.named("stryker.concurrency")(readConcurrency).decide(resolveConcurrency).write({
-	TestRunnersAndCheckers: (split, command) => Effect$1.as(Effect$1.andThen(announcePercentage(command, split.total, split.isPercentage), Effect$1.logInfo(`Creating ${split.checkers} checker process(es) and ${split.testRunners} test runner process(es).`)), {
+	TestRunnersAndCheckers: (split, command) => Effect$1.as(Effect$1.andThen(Effect$1.forEach(Option$1.toArray(split.announcement), (line) => Effect$1.logDebug(line), { discard: true }), Effect$1.logInfo(`Creating ${split.checkers} checker process(es) and ${split.testRunners} test runner process(es).`)), {
 		...command.record,
 		concurrency: {
 			testRunners: split.testRunners,
 			checkers: split.checkers
 		}
 	}),
-	TestRunnersOnly: (split, command) => Effect$1.as(Effect$1.andThen(announcePercentage(command, split.total, split.isPercentage), Effect$1.logInfo(`Creating ${split.testRunners} test runner process(es).`)), {
+	TestRunnersOnly: (split, command) => Effect$1.as(Effect$1.andThen(Effect$1.forEach(Option$1.toArray(split.announcement), (line) => Effect$1.logDebug(line), { discard: true }), Effect$1.logInfo(`Creating ${split.testRunners} test runner process(es).`)), {
 		...command.record,
 		concurrency: {
 			testRunners: split.testRunners,
@@ -4058,132 +4167,8 @@ const admitIncrementalReport = Workflow.make({
 	error: S.Never,
 	decide: (command) => Result.succeed(decide$6(command))
 });
-const isVmRunner = (name) => typeof name === "string" && name.toLowerCase() === "vm";
-const vmRunnerCapabilities = { reloadEnvironment: true };
-const HOST_TIMEOUT_SLACK_MS = 1e3;
-const messageOf$1 = (cause) => cause instanceof Error ? cause.message : new Error("the vm test runner failed", { cause }).message;
-const testResultOf = (test) => {
-	const base = {
-		id: test.id,
-		name: test.name,
-		timeSpentMs: test.timeSpentMs
-	};
-	return Match.value(test.status).pipe(Match.when("failed", () => ({
-		...base,
-		status: "failed",
-		failureMessage: test.failureMessage ?? ""
-	})), Match.when("skipped", () => ({
-		...base,
-		status: "skipped"
-	})), Match.orElse(() => ({
-		...base,
-		status: "success"
-	})));
-};
-const dryRunResultOf = (response) => {
-	const tests = response.tests.map(testResultOf);
-	return Option$1.match(Option$1.fromUndefinedOr(response.mutantCoverage), {
-		onNone: () => ({
-			status: "complete",
-			tests
-		}),
-		onSome: (mutantCoverage) => ({
-			status: "complete",
-			tests,
-			mutantCoverage
-		})
-	});
-};
-const respond = (response) => Match.value(response).pipe(Match.discriminator("status")("init-failed", (failed) => Effect$1.fail(TestRunner_exports.TestRunnerFailed.make({
-	runnerName: "vm",
-	phase: "init",
-	cause: failed.message
-}))), Match.discriminator("status")("timeout", () => Effect$1.succeed({ status: "timeout" })), Match.discriminator("status")("error", (errored) => Effect$1.succeed({
-	status: "error",
-	errorMessage: errored.errorMessage
-})), Match.discriminator("status")("complete", (complete) => Effect$1.succeed(dryRunResultOf(complete))), Match.exhaustive);
-const pooledVmRunner = (config, scope) => {
-	let client;
-	let sessionTestFiles = config.testFiles;
-	const sessionOptions = () => ({
-		sandboxWorkingDirectory: config.sandboxWorkingDirectory,
-		testFiles: sessionTestFiles
-	});
-	const spawnClient = Effect$1.try({
-		try: () => {
-			const spawned = Session.createVmWorkerClient(sessionOptions(), { onExit: () => {
-				if (client === spawned) client = void 0;
-			} });
-			return spawned;
-		},
-		catch: (cause) => TestRunner_exports.TestRunnerFailed.make({
-			runnerName: "vm",
-			phase: "init",
-			cause: `the vm test runner could not start its worker: ${messageOf$1(cause)}`
-		})
-	});
-	const dropClient = Effect$1.suspend(() => {
-		const current = client;
-		client = void 0;
-		return current === void 0 ? Effect$1.void : Effect$1.promise(() => current.terminate());
-	});
-	const run = (request) => Effect$1.gen(function* () {
-		if (client === void 0) {
-			const spawned = yield* spawnClient;
-			yield* Scope.addFinalizer(scope, Effect$1.promise(() => spawned.terminate()));
-			client = spawned;
-		}
-		const current = client;
-		const answer = yield* Effect$1.tryPromise({
-			try: () => current.run(request),
-			catch: (cause) => ({
-				status: "error",
-				errorMessage: messageOf$1(cause)
-			})
-		}).pipe(Effect$1.catch((failed) => Effect$1.succeed(failed)), Effect$1.timeoutOrElse({
-			duration: request.timeoutMs + HOST_TIMEOUT_SLACK_MS,
-			orElse: () => dropClient.pipe(Effect$1.as({ status: "timeout" }))
-		}));
-		return yield* respond(answer);
-	}).pipe(Effect$1.onInterrupt(() => dropClient));
-	const shouldAdoptTestFiles = () => config.testFiles.length === 0 && client === void 0;
-	const adoptedTestFiles = (testFiles) => testFiles ?? [];
-	const testFilterFieldOf = (testFilter) => testFilter === void 0 ? {} : { testFilter: [...testFilter] };
-	const hitLimitFieldOf = (hitLimit) => hitLimit === void 0 ? {} : { hitLimit };
-	const mutantRequestOf = (options) => ({
-		kind: "mutant",
-		timeoutMs: options.timeout,
-		activeMutantId: String(options.activeMutant.id),
-		...testFilterFieldOf(options.testFilter),
-		...hitLimitFieldOf(options.hitLimit),
-		reloadEnvironment: options.reloadEnvironment
-	});
-	return make$3({
-		capabilities: Effect$1.succeed(vmRunnerCapabilities),
-		init: Effect$1.void,
-		dryRun: (options) => {
-			if (shouldAdoptTestFiles()) sessionTestFiles = adoptedTestFiles(options.testFiles);
-			return run({
-				kind: "dry",
-				timeoutMs: options.timeout,
-				reloadEnvironment: true
-			});
-		},
-		mutantRun: (options) => run(mutantRequestOf(options)).pipe(Effect$1.map((dryRunResult) => interpretDryRunResult(InterpretDryRunResultCommand.make({ dryRunResult }))), Effect$1.flatMap((decided) => Result.match(decided, {
-			onFailure: (failure) => Effect$1.fail(failure),
-			onSuccess: (decision) => Effect$1.succeed(decision.asResult)
-		})), Effect$1.catchTag("TestRunnerFailed", (failure) => Effect$1.succeed({
-			status: "error",
-			errorMessage: failure.cause
-		})))
-	});
-};
-const vmTestRunner = (config) => Effect$1.gen(function* () {
-	const scope = yield* Effect$1.scope;
-	return pooledVmRunner(config, scope);
-});
 //#endregion
-//#region src/read-project.cell.ts
+//#region src/read-project.parts.ts
 const ALWAYS_IGNORE = Object.freeze([
 	"node_modules",
 	".git",
@@ -4195,23 +4180,9 @@ const ALWAYS_IGNORE = Object.freeze([
 ]);
 const IGNORE_PATTERN_CHARACTER = "!";
 const DEFAULT_GLOB = "**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}";
-const VITEST_DEFAULT_TEST_FILE_PATTERNS = ["**/*.{test,spec}.{js,jsx,ts,tsx,cjs,cjsx,cts,ctsx,mjs,mjsx,mts,mtsx}"];
-const defaultTestFileIgnores = (tempDirName) => [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/.{idea,git,cache,output,temp}/**",
-	`**/${tempDirName}/**`
-];
-const shouldDiscoverTestFiles = (options) => options.testFiles.length === 0 && isVmRunner(options.testRunner);
-const testFileSelectionOf = (options) => Boolean.match(shouldDiscoverTestFiles(options), {
-	onTrue: () => ({
-		testFilePatterns: VITEST_DEFAULT_TEST_FILE_PATTERNS,
-		testFileIgnores: defaultTestFileIgnores(options.tempDirName)
-	}),
-	onFalse: () => ({
-		testFilePatterns: options.testFiles,
-		testFileIgnores: []
-	})
+const testFileSelectionOf = (options) => ({
+	testFilePatterns: options.testFiles,
+	testFileIgnores: []
 });
 const normalizeFileName = (value) => value.replace(/\\/g, "/");
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -4596,7 +4567,7 @@ const readProjectCommand = (input) => Effect$1.gen(function* () {
 	const mutatePatterns = input.options.mutate;
 	const { testFileIgnores, testFilePatterns } = testFileSelectionOf(input.options);
 	const inputFileNames = yield* resolveInputFileNames(ignoreRulesOf(input.options), input.basePath);
-	const defaults = yield* StrykerConfig.defaultOptions;
+	const defaults = yield* defaultOptions;
 	const decision = selectFiles(selectionOf$1(inputFileNames, mutatePatterns, testFilePatterns, testFileIgnores, input.basePath, input.targetMutatePatterns));
 	yield* Boolean.match(stringArrayEquivalence(mutatePatterns, defaults.mutate), {
 		onTrue: () => Effect$1.void,
@@ -4619,7 +4590,7 @@ const readProjectCommand = (input) => Effect$1.gen(function* () {
 		testFiles: [...decision.testFiles]
 	});
 });
-const discardLogOf = (command, discard) => Boolean.match(command.incremental, {
+const discardLogOf = ({ command, discard }) => Boolean.match(command.incremental, {
 	onFalse: () => Effect$1.void,
 	onTrue: () => Option$1.match(Option$1.fromUndefinedOr(command.contents), {
 		onNone: () => Effect$1.void,
@@ -4629,15 +4600,26 @@ const discardLogOf = (command, discard) => Boolean.match(command.incremental, {
 		})
 	})
 });
-const projectOf = (command, report) => ({
+const projectOf = ({ command, report }) => ({
 	options: command.options,
 	targetMutatePatterns: command.targetMutatePatterns,
 	basePath: command.basePath,
 	project: makeProject(command.fileDescriptions, report, command.testFiles)
 });
+//#endregion
+//#region src/read-project.cell.ts
 const readProjectCell = Sandwich.named("stryker.project_read")(readProjectCommand).decide(admitIncrementalReport).write({
-	IncrementalReportKeep: (keep, command) => Effect$1.succeed(projectOf(command, keep.report)),
-	IncrementalReportDiscard: (discard, command) => Effect$1.as(discardLogOf(command, discard), projectOf(command, void 0)),
+	IncrementalReportKeep: (keep, command) => Effect$1.succeed(projectOf({
+		command,
+		report: keep.report
+	})),
+	IncrementalReportDiscard: (discard, command) => Effect$1.as(discardLogOf({
+		command,
+		discard
+	}), projectOf({
+		command,
+		report: void 0
+	})),
 	CommandRejected: ({ issue }) => Effect$1.fail(badArgument({
 		module: "stryker-js",
 		method: "incremental-report.cell",
@@ -4712,8 +4694,11 @@ const formatTotal = (total) => Option$1.match(Option$1.fromNullishOr(total), {
 	onSome: (val) => String(val)
 });
 const formatStderrEvent = (event) => Match.value(event).pipe(Match.tag("plan", (e) => `plan ${e.total} mutants`), Match.tag("phase", (e) => `phase ${e.phase}`), Match.tag("tick", (e) => `${e.completed}/${formatTotal(e.total)} elapsed ${e.elapsedMs}ms`), Match.tag("verdict", (e) => `score ${formatScore(e.score)} killed ${e.counts.killed} survived ${e.counts.survived}`), Match.tag("error", (e) => `error ${e.error}`), Match.tag("stream", () => null), Match.tag("mutant", () => null), Match.tag("help", () => null), Match.tag("plugins", () => null), Match.tag("formats", () => null), Match.tag("skipped", () => null), Match.exhaustive);
-const stderrLineFor = (state, event) => Match.value(state.terminalSeen).pipe(Match.when(true, () => null), Match.when(false, () => formatStderrEvent(event)), Match.exhaustive);
-const shouldFrame = (state) => Match.value(state.mode).pipe(Match.when("machine", () => !state.terminalSeen), Match.when("human", () => false), Match.exhaustive);
+const stderrLineFor = (state, event) => Boolean$1.match(Boolean$1.and(state.mode === "human", !state.terminalSeen), {
+	onTrue: () => formatStderrEvent(event),
+	onFalse: () => null
+});
+const shouldFrame = (state) => !state.terminalSeen;
 const decideFrame = (command) => {
 	const nextState = noteState(command.state, command.event);
 	const stderrLine = stderrLineFor(command.state, command.event);
@@ -4772,7 +4757,10 @@ const formatTemplate = (template, args) => {
 };
 const headOf = (args) => Option$1.fromNullishOr(args[0]);
 const formatArgs = (args) => Option$1.match(Option$1.filter(headOf(args), Predicate$1.isString), {
-	onSome: (first) => formatTemplate(first, args.slice(1)),
+	onSome: (first) => Boolean$1.match(args.length === 1, {
+		onTrue: () => first,
+		onFalse: () => formatTemplate(first, args.slice(1))
+	}),
 	onNone: () => args.map(inspectValue).join(" ")
 });
 const DEFAULT_CONSOLE_LABEL = "default";
@@ -5006,7 +4994,7 @@ const PriorReportDocument = S.Struct({
 	}))
 });
 //#endregion
-//#region src/Survivors/Survivors.cell.ts
+//#region src/Survivors/Survivors.parts.ts
 const DEFAULT_SURVIVORS_PRIOR_REPORT = "reports/mutation-report.json";
 const EMPTY_CONFIG = {};
 const hashContent = (content) => bytesToHex(sha256(utf8ToBytes(content)));
@@ -5035,9 +5023,9 @@ const reportMutantToMutant = (file, mutant, resolveAbsolutePath, relativize) =>
 };
 const extractSurvivors = (priorReport, resolveAbsolutePath, relativize) => Object.entries(priorReport.files).flatMap(([file, fileResult]) => fileResult.mutants.filter((mutant) => mutant.status === "Survived").map((mutant) => reportMutantToMutant(file, mutant, resolveAbsolutePath, relativize)));
 const resolveAbsolutePathOf = (basePath) => (file) => `${basePath}/${file}`;
-const resolveSurvivorsRunOptions = (cliOptions, mode) => readConfig(cliOptions, {
+const resolveSurvivorsRunOptions = (input) => readConfig(input.cliOptions, {
 	command: "run",
-	mode
+	mode: input.mode
 });
 const priorReportPathOf = (resolved) => Option$1.getOrElse(Option$1.filter(Option$1.fromUndefinedOr(resolved["survivorsPriorReport"]), Predicate$1.isString), () => DEFAULT_SURVIVORS_PRIOR_REPORT);
 const readPriorReport = (priorReportPath) => Effect$1.flatMap(FileSystem.FileSystem, (fs) => fs.readFileString(priorReportPath).pipe(Effect$1.map((text) => ({
@@ -5060,14 +5048,11 @@ const readSourceFile = (file) => Effect$1.flatMap(FileSystem.FileSystem, (fs) =>
 }))));
 const SOURCE_HASH_CONCURRENCY = 24;
 const currentSourceHashesFor = (files) => Effect$1.map(Effect$1.forEach(files, (file) => Effect$1.map(readSourceFile(file), (content) => [file, hashContent(content)]), { concurrency: SOURCE_HASH_CONCURRENCY }), (pairs) => Object.fromEntries(pairs));
-Sandwich.named("stryker.survivors_admission")((input) => Effect$1.gen(function* () {
-	const resolvedOptions = yield* resolveSurvivorsRunOptions(input.cliOptions, input.mode);
-	const priorReportPath = priorReportPathOf(resolvedOptions);
-	const relativize = (fileName) => RelativeNormalizedFileName.fromAbsolute(fileName, input.basePath).fileName;
-	const resolveAbsolutePath = resolveAbsolutePathOf(input.basePath);
-	const read = yield* readPriorReport(priorReportPath);
-	const sourceContentHashes = yield* currentSourceHashesFor(priorReportFileKeys(read.raw));
-	return yield* Boolean$1.match(read.found, {
+const survivorsRawOf = (input) => {
+	const { read, resolvedOptions, priorReportPath, basePath, sourceContentHashes } = input;
+	const relativize = (fileName) => RelativeNormalizedFileName.fromAbsolute(fileName, basePath).fileName;
+	const resolveAbsolutePath = resolveAbsolutePathOf(basePath);
+	return Boolean$1.match(read.found, {
 		onFalse: () => Effect$1.succeed({
 			currentConfig: resolvedOptions,
 			frameworkVersion: StrykerPackage.version,
@@ -5095,6 +5080,22 @@ Sandwich.named("stryker.survivors_admission")((input) => Effect$1.gen(function*
 			})
 		}))
 	});
+};
+Sandwich.named("stryker.survivors_admission")((input) => Effect$1.gen(function* () {
+	const resolvedOptions = yield* resolveSurvivorsRunOptions({
+		cliOptions: input.cliOptions,
+		mode: input.mode
+	});
+	const priorReportPath = priorReportPathOf(resolvedOptions);
+	const read = yield* readPriorReport(priorReportPath);
+	const sourceContentHashes = yield* currentSourceHashesFor(priorReportFileKeys(read.raw));
+	return yield* survivorsRawOf({
+		read,
+		resolvedOptions,
+		priorReportPath,
+		basePath: input.basePath,
+		sourceContentHashes
+	});
 })).decide(admitSurvivorsRun).write({
 	Admitted: (admitted, raw) => Effect$1.map(S.decodeEffect(Admitted)(admitted), (admission) => ({
 		admission,
@@ -5411,7 +5412,7 @@ var RunEventDrain = class RunEventDrain extends Context.Service()("@systemfsoftw
 	static layer = Layer.effect(RunEventDrain, Effect$1.gen(function* () {
 		const stdio = yield* Stdio.Stdio;
 		return RunEventDrain.of({
-			drainFramed: (framed) => drainOf(stdio, framed),
+			drainFramed: (framed, toStdout) => drainOf(stdio, framed, toStdout),
 			setProgressStreamFile: () => Effect$1.void
 		});
 	}));
@@ -5424,25 +5425,29 @@ var RunEventDrain = class RunEventDrain extends Context.Service()("@systemfsoftw
 };
 const RunEventDrainLive = RunEventDrain.layer;
 const encodeUtf8 = (line) => new TextEncoder().encode(line);
-const drainStdoutAndFile = (fs, path, stdio, fileName, framed) => Effect$1.gen(function* () {
+const runToSink = (stdio, lines, toStdout) => Boolean$1.match(toStdout, {
+	onTrue: () => Stream.run(lines, stdio.stdout({ endOnDone: true })),
+	onFalse: () => Stream.runDrain(lines)
+});
+const drainToSinks = (fs, path, stdio, fileName, toStdout, framed) => Effect$1.gen(function* () {
 	yield* fs.makeDirectory(path.dirname(fileName), { recursive: true });
 	yield* Effect$1.scoped(Effect$1.gen(function* () {
 		const handle = yield* fs.open(fileName, { flag: "w" });
 		const withFile = framed.pipe(Stream.tap((line) => handle.writeAll(encodeUtf8(line)).pipe(Effect$1.flatMap(() => handle.sync))));
-		yield* Stream.run(withFile, stdio.stdout({ endOnDone: true })).pipe(Effect$1.ignore);
+		yield* runToSink(stdio, withFile, toStdout).pipe(Effect$1.ignore);
 	}));
 }).pipe(Effect$1.orDie);
 const drainFileOf = (stdio, fs, path) => Effect$1.gen(function* () {
 	const fileNameRef = yield* Ref.make(DEFAULT_PROGRESS_STREAM_FILE);
 	return RunEventDrain.of({
-		drainFramed: (framed) => Effect$1.gen(function* () {
+		drainFramed: (framed, toStdout) => Effect$1.gen(function* () {
 			const fileName = yield* Ref.get(fileNameRef);
-			yield* drainStdoutAndFile(fs, path, stdio, fileName, framed);
+			yield* drainToSinks(fs, path, stdio, fileName, toStdout, framed);
 		}).pipe(Effect$1.tapCause((cause) => Effect$1.logError("stryker.output.drain_file_failed", cause)), Effect$1.ignoreCause),
 		setProgressStreamFile: (fileName) => Ref.set(fileNameRef, fileName)
 	});
 });
-const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect$1.withSpan("stryker.output.drain"), Effect$1.tapCause((cause) => Effect$1.logError("stryker.output.drain_failed", cause)), Effect$1.ignoreCause);
+const drainOf = (stdio, framed, toStdout) => runToSink(stdio, framed, toStdout).pipe(Effect$1.withSpan("stryker.output.drain"), Effect$1.tapCause((cause) => Effect$1.logError("stryker.output.drain_failed", cause)), Effect$1.ignoreCause);
 const writeStderr = (stdio, line) => Stream.run(Stream.succeed(`${line}\n`), stdio.stderr({ endOnDone: false })).pipe(Effect$1.ignore);
 const emitNullScoreVerdict = (params) => {
 	const { stream, mode, thresholds, basePath, pathService } = params;
@@ -5490,7 +5495,7 @@ const emitHelpEnvelope = (stream, help) => Queue.offer(stream.queue, HelpRendere
 const helpPayload = (ok, captured) => Option$1.filter(Option$1.some(captured), () => ok.help || captured.length > 0);
 const emitNullScoreVerdictWhenOpen = (stream, mode, basePath, pathService) => Effect$1.andThen(stream.isOpen, (open) => Boolean$1.match(open, {
 	onTrue: () => Effect$1.gen(function* () {
-		const defaults = yield* StrykerConfig.defaultOptions;
+		const defaults = yield* defaultOptions;
 		yield* emitNullScoreVerdict({
 			stream,
 			mode,
@@ -5589,7 +5594,8 @@ const makeRunEventStream = (resolved) => Effect$1.gen(function* () {
 		open: Effect$1.gen(function* () {
 			yield* Option$1.match(yield* Ref.get(drainFiberRef), {
 				onNone: () => Effect$1.gen(function* () {
-					const drainFiber = yield* drain.drainFramed(framed).pipe(Effect$1.forkDetach);
+					const mode = (yield* Ref.get(stateRef)).mode;
+					const drainFiber = yield* drain.drainFramed(framed, mode === "machine").pipe(Effect$1.forkDetach);
 					yield* Ref.set(drainFiberRef, Option$1.some(drainFiber));
 				}),
 				onSome: () => Effect$1.void
@@ -5611,6 +5617,14 @@ const makeRunEventStream = (resolved) => Effect$1.gen(function* () {
 var DryRunError = class extends S.TaggedError()("DryRunError", {
 	stage: S.Literals(["dryRun", "dryRunNoTests"]),
 	reason: S.String
+}) {
+	get message() {
+		return this.reason;
+	}
+};
+var FailedTestSummary = class extends S.Class("FailedTestSummary")({
+	name: S.String,
+	failureMessage: S.String
 }) {};
 var DryRunCommand = class extends S.TaggedClass()("DryRunCommand", {
 	status: S.Literals([
@@ -5620,6 +5634,7 @@ var DryRunCommand = class extends S.TaggedClass()("DryRunCommand", {
 	]),
 	testCount: S.Finite,
 	failedTestCount: S.Finite,
+	failedTests: S.Array(FailedTestSummary),
 	allowEmpty: S.Boolean,
 	errorMessage: S.optional(S.String),
 	reason: S.optional(S.String)
@@ -5637,7 +5652,8 @@ var DryRunPassed = class extends S.TaggedClass()("DryRunPassed", { testCount: S.
 };
 var DryRunFailed = class extends S.TaggedClass()("DryRunFailed", {
 	testCount: S.Finite,
-	failedTestCount: S.Finite
+	failedTestCount: S.Finite,
+	failedTests: S.Array(FailedTestSummary)
 }) {
 	[DryRunDecisionTypeId] = DryRunDecisionTypeId;
 };
@@ -5648,13 +5664,15 @@ const completeOutcomeOf = (command) => Match.value(command).pipe(Match.when({
 const decideComplete = (command) => Match.value({
 	outcome: completeOutcomeOf(command),
 	testCount: command.testCount,
-	failedTestCount: command.failedTestCount
+	failedTestCount: command.failedTestCount,
+	failedTests: command.failedTests
 }).pipe(Match.when({ outcome: "noTests" }, () => Result.fail(DryRunError.make({
 	stage: "dryRunNoTests",
 	reason: "No tests were executed. Stryker will exit prematurely. Please check your configuration."
-}))), Match.when({ outcome: "failed" }, ({ testCount, failedTestCount }) => Result.succeed(DryRunFailed.make({
+}))), Match.when({ outcome: "failed" }, ({ testCount, failedTestCount, failedTests }) => Result.succeed(DryRunFailed.make({
 	testCount,
-	failedTestCount
+	failedTestCount,
+	failedTests
 }))), Match.when({ outcome: "passed" }, ({ testCount }) => Result.succeed(DryRunPassed.make({ testCount }))), Match.exhaustive);
 const reasonOrDefault = (reason, fallback) => Match.value(reason).pipe(Match.when(void 0, () => fallback), Match.orElse((present) => present));
 const decide$5 = (command) => Match.value(command.status).pipe(Match.when("Error", () => Result.fail(DryRunError.make({
@@ -5704,7 +5722,52 @@ var PluginLoadRefusedError = class extends Schema.TaggedError()("PluginLoadRefus
 	}
 };
 //#endregion
-//#region src/TestRunner.resource.ts
+//#region src/Sandbox.handle.ts
+const TypeId$3 = Symbol.for("~systemfsoftware/stryker-js/Sandbox");
+const SandboxHandle = Handle.make()(TypeId$3);
+SandboxHandle.is;
+const sandboxFileNameOf = (fileMap, fileName) => Match.value(fileMap.get(fileName)).pipe(Match.when(Predicate$1.isString, (sandboxFileName) => Result.succeed(sandboxFileName)), Match.orElse(() => Result.fail(StrykerError.make({ message: `Cannot find sandbox file for ${fileName}` }))));
+const withoutLeadingSeparator = (suffix) => Boolean$1.match(suffix.startsWith("/"), {
+	onTrue: () => suffix.slice(1),
+	onFalse: () => suffix
+});
+const relativeToBase = (resolvedSandbox, resolvedWorking, base, pathService) => {
+	const trimmed = withoutLeadingSeparator(resolvedSandbox.slice(resolvedWorking.length));
+	return Boolean$1.match(trimmed.length === 0, {
+		onTrue: () => base,
+		onFalse: () => pathService.join(base, trimmed)
+	});
+};
+const originalFileNameOf = (sandboxFileName, workingDirectory, base, pathService) => {
+	const resolvedSandbox = pathService.resolve(sandboxFileName);
+	const resolvedWorking = pathService.resolve(workingDirectory);
+	return Boolean$1.match(resolvedSandbox.startsWith(resolvedWorking), {
+		onTrue: () => relativeToBase(resolvedSandbox, resolvedWorking, base, pathService),
+		onFalse: () => resolvedSandbox.replace(resolvedWorking, base)
+	});
+};
+const make$1 = (options) => SandboxHandle.make({ workingDirectory: options.workingDirectory }, {
+	fileMap: options.fileMap,
+	basePath: options.basePath,
+	pathService: options.pathService
+});
+const sandboxFileFor = dual(2, (self, fileName) => sandboxFileNameOf(SandboxHandle.slot(self).fileMap, fileName));
+const originalFileFor = dual(2, (self, sandboxFileName) => {
+	const slot = SandboxHandle.slot(self);
+	return originalFileNameOf(sandboxFileName, self.workingDirectory, slot.basePath, slot.pathService);
+});
+const VM_RUNNER_SPECIFIER = "@systemfsoftware/stryker-js-vm-runner";
+const vmRunnerOptions = { pool: "threads" };
+const vmRunnerPluginUrl = () => import.meta.resolve(VM_RUNNER_SPECIFIER);
+const isVmRunner = (name) => typeof name === "string" && name.toLowerCase() === "vm";
+const vmTestRunnerConfig = () => ({
+	plugin: vmRunnerPluginUrl(),
+	options: { ...vmRunnerOptions }
+});
+const testRunnerConfigOf = (configured) => Match.value(configured).pipe(Match.when(isVmRunner, vmTestRunnerConfig), Match.orElse((unchanged) => unchanged));
+//#endregion
+//#region src/TestRunner.blueprint.ts
+const TypeId$2 = Symbol.for("~systemfsoftware/stryker-js/TestRunner");
 const toRunnerBootFailure = (runnerName) => (error) => Match.value(error).pipe(Match.tag("WorkerBootTimeoutError", (timeout) => TestRunner_exports.TestRunnerFailed.make({
 	runnerName,
 	phase: "init",
@@ -5727,12 +5790,16 @@ const toRunnerFailure = (runnerName, phase) => (error) => Match.value(error).pip
 * `Pool.invalidate` and the crash-retry combinator can only act on a failure they
 * can see.
 */
-const makeChildProcessTestRunner = (params) => Effect$1.gen(function* () {
-	const runnerName = Match.value(params.options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
-	const execArgv = Match.value(params.options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => Match.value(runner.nodeArgs).pipe(Match.when(Match.undefined, () => params.options.testRunnerNodeArgs), Match.orElse((args) => args))), Match.orElse(() => params.options.testRunnerNodeArgs));
+const scopedOf = (params) => Effect$1.gen(function* () {
+	const options = {
+		...params.options,
+		testRunner: testRunnerConfigOf(params.options.testRunner)
+	};
+	const runnerName = Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
+	const execArgv = Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => Match.value(runner.nodeArgs).pipe(Match.when(Match.undefined, () => options.testRunnerNodeArgs), Match.orElse((args) => args))), Match.orElse(() => options.testRunnerNodeArgs));
 	const client = yield* makeWorkerClient({
 		rpcs: Plugin_exports.TestRunnerRpcs,
-		options: params.options,
+		options,
 		entrypoint: params.workerEntrypoint,
 		workingDirectory: params.sandboxWorkingDirectory,
 		execArgv: [...execArgv],
@@ -5750,11 +5817,13 @@ const makeChildProcessTestRunner = (params) => Effect$1.gen(function* () {
 		mutantRun: (options) => client.mutantRun({ options }).pipe(Effect$1.mapError(toRunnerFailure(runnerName, "mutantRun")))
 	});
 });
+const TestRunners = Blueprint.make()(TypeId$2).steps({
+	steps: {},
+	targets: { scoped: scopedOf }
+});
+const makeChildProcessTestRunner = (params) => TestRunners.of(params).scoped;
 const commandRunnerEffect = (context) => ChildProcessSpawner.ChildProcessSpawner.pipe(Effect$1.map((spawner) => commandRunner(context, spawner).pipe(withTimeout, withRetry)));
-const inProcessRunner = (context) => Match.value(context.options.testRunner).pipe(Match.when(isCommandRunner, () => Option$1.some(commandRunnerEffect(context))), Match.when(isVmRunner, () => Option$1.some(vmTestRunner({
-	testFiles: context.testFiles,
-	sandboxWorkingDirectory: context.sandboxWorkingDirectory
-}))), Match.orElse(() => Option$1.none()));
+const inProcessRunner = (context) => Match.value(context.options.testRunner).pipe(Match.when(isCommandRunner, () => Option$1.some(commandRunnerEffect(context))), Match.orElse(() => Option$1.none()));
 const buildTestRunner = dual(2, (context, childProcessRunner) => Option$1.match(inProcessRunner(context), {
 	onSome: (inProcess) => inProcess,
 	onNone: () => Effect$1.gen(function* () {
@@ -5911,9 +5980,9 @@ const resolveConfiguredPlugin = Workflow.make({
 	decide: decide$4
 });
 //#endregion
-//#region src/run/dry-run.cell.ts
-const sandboxPathsOf = (sandbox, fileNames) => Result.all(fileNames.map((fileName) => sandbox.sandboxFileFor(fileName)));
-const configuredPluginOf$1 = (configured) => Match.value(configured).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
+//#region src/run/dry-run.parts.ts
+const sandboxPathsOf = (sandbox, fileNames) => Result.all(fileNames.map((fileName) => sandboxFileFor(sandbox, fileName)));
+const configuredPluginOf$1 = (configured) => Match.value(testRunnerConfigOf(configured)).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
 const workerSpawnOf$1 = (stage, loaded, kind, configured) => Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
 	sources: loaded.pluginSources,
 	kind,
@@ -5927,7 +5996,11 @@ const optionalSandboxPathsOf = (command) => Boolean$1.match(command.options.test
 	onTrue: () => Result.succeed(void 0),
 	onFalse: () => sandboxPathsOf(command.sandbox, command.project.testFiles)
 });
-const buildDryRunFiles = (command) => Result.flatMap(sandboxPathsOf(command.sandbox, [...MutableHashMap.keys(command.project.filesToMutate)]), (files) => Result.map(optionalSandboxPathsOf(command), (testFiles) => ({
+const mutatedFileNamesOf = (command) => {
+	const mutated = MutableHashSet.fromIterable(command.mutants.map((mutant) => mutant.fileName));
+	return [...MutableHashMap.keys(command.project.filesToMutate)].filter((name) => MutableHashSet.has(mutated, name));
+};
+const buildDryRunFiles = (command) => Result.flatMap(sandboxPathsOf(command.sandbox, mutatedFileNamesOf(command)), (files) => Result.map(optionalSandboxPathsOf(command), (testFiles) => ({
 	files,
 	testFiles
 })));
@@ -5936,11 +6009,16 @@ const resolveDryRunFiles = (command) => Effect$1.fromResult(buildDryRunFiles(com
 	reason: "Failed to resolve sandbox file",
 	cause
 })));
+const failedTestSummariesOf = (tests) => tests.filter((test) => test.status === "failed").map((test) => FailedTestSummary.make({
+	name: test.name,
+	failureMessage: test.failureMessage
+}));
 const commandEncodedComplete = (complete, allowEmpty) => ({
 	_tag: "DryRunCommand",
 	status: "Complete",
 	testCount: complete.tests.length,
 	failedTestCount: complete.tests.filter((test) => test.status === "failed").length,
+	failedTests: failedTestSummariesOf(complete.tests),
 	allowEmpty
 });
 const commandEncodedFailed = (failed, allowEmpty) => ({
@@ -5948,6 +6026,7 @@ const commandEncodedFailed = (failed, allowEmpty) => ({
 	status: "Error",
 	testCount: 0,
 	failedTestCount: 0,
+	failedTests: [],
 	allowEmpty,
 	errorMessage: failed.errorMessage
 });
@@ -5956,6 +6035,7 @@ const commandEncodedTimedOut = (timedOut, allowEmpty) => ({
 	status: "Timeout",
 	testCount: 0,
 	failedTestCount: 0,
+	failedTests: [],
 	allowEmpty,
 	...Option$1.match(Option$1.fromNullishOr(timedOut.reason), {
 		onNone: () => ({}),
@@ -5987,7 +6067,7 @@ const totalTestTime = (tests) => tests.reduce((total, test) => total + test.time
 const overheadMillisOf = (grossMillis, tests) => Math.max(0, grossMillis - totalTestTime(tests));
 const withOriginalFileName = (test, prev) => Match.value(test.fileName).pipe(Match.when(Predicate$1.isString, (fileName) => ({
 	...test,
-	fileName: prev.sandbox.originalFileFor(fileName)
+	fileName: originalFileFor(prev.sandbox, fileName)
 })), Match.orElse(() => test));
 const withOriginalFileNames = (tests, prev) => tests.map((test) => withOriginalFileName(test, prev));
 const ZERO = 0;
@@ -6110,20 +6190,32 @@ const writeDryRunPassed = (raw) => withPhaseSpan("dryRun", {}, () => Effect$1.ge
 	yield* phaseEntered("dry-run");
 	return yield* completeDryRunPassed(raw);
 }));
-const writeDryRunFailed = (raw, testCount, failedTestCount) => withPhaseSpan("dryRun", {}, () => Effect$1.gen(function* () {
+const FAILED_TESTS_REASON = "There were failed tests in the initial test run.";
+const failedTestsDetail = (failedTests) => failedTests.map((test) => `  ${test.name}${test.failureMessage.length > 0 ? `: ${test.failureMessage}` : ""}`).join("\n");
+const reasonWithFailedTests = (detail) => detail.length > 0 ? `${FAILED_TESTS_REASON}\n${detail}` : FAILED_TESTS_REASON;
+const writeDryRunFailed = ({ testCount, failedTestCount, failedTests }) => withPhaseSpan("dryRun", {}, () => Effect$1.gen(function* () {
 	yield* phaseEntered("dry-run");
+	const detail = failedTestsDetail(failedTests);
+	yield* Effect$1.logError(`Initial test run failed. ${failedTestCount} of ${testCount} test(s) failed:\n${detail}`);
 	return yield* StageError.make({
 		stage: "dryRun",
-		reason: "There were failed tests in the initial test run.",
+		reason: reasonWithFailedTests(detail),
 		cause: DryRunFailed.make({
 			testCount,
-			failedTestCount
+			failedTestCount,
+			failedTests
 		})
 	});
 }));
+//#endregion
+//#region src/run/dry-run.cell.ts
 const dryRunCell = Sandwich.named("stryker.dry_run")(readDryRun).decide(dryRun).write({
 	DryRunPassed: (_decision, raw) => writeDryRunPassed(raw),
-	DryRunFailed: ({ testCount, failedTestCount }, raw) => writeDryRunFailed(raw, testCount, failedTestCount),
+	DryRunFailed: ({ testCount, failedTestCount, failedTests }, _raw) => writeDryRunFailed({
+		testCount,
+		failedTestCount,
+		failedTests
+	}),
 	DryRunError: ({ stage, reason }) => Effect$1.fail(StageError.make({
 		stage,
 		reason,
@@ -6139,14 +6231,11 @@ const dryRunCell = Sandwich.named("stryker.dry_run")(readDryRun).decide(dryRun).
 });
 //#endregion
 //#region src/plan-instrumentation.workflow.ts
-var InstrumentError = class extends S.TaggedError()("InstrumentError", {
-	stage: S.Literal("instrument"),
-	reason: S.String
-}) {};
+const Count = S.Int.check(S.isGreaterThanOrEqualTo(0));
 var InstrumentCommand = class extends S.TaggedClass()("InstrumentCommand", {
-	fileCount: S.Finite,
+	fileCount: Count,
 	inPlace: S.Boolean,
-	pluginCount: S.Finite
+	pluginCount: Count
 }) {
 	static [Workflow.InstrumentationBrand] = {
 		fileCount: "stryker.instrument.file_count",
@@ -6157,32 +6246,28 @@ const InstrumentDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/Instrum
 var InPlaceInstrument = class extends S.TaggedClass()("InPlaceInstrument", {
 	workingDirectoryHint: S.String,
 	backupDirectoryHint: S.String,
-	fileCount: S.Finite
+	fileCount: Count
 }) {
 	[InstrumentDecisionTypeId] = InstrumentDecisionTypeId;
 };
 var EphemeralInstrument = class extends S.TaggedClass()("EphemeralInstrument", {
 	workingDirectoryHint: S.String,
-	fileCount: S.Finite
+	fileCount: Count
 }) {
 	[InstrumentDecisionTypeId] = InstrumentDecisionTypeId;
 };
-const commandShape = (command) => Match.value(command.fileCount === 0).pipe(Match.when(true, () => "empty"), Match.when(false, () => Match.value(command.inPlace).pipe(Match.when(true, () => "inPlace"), Match.when(false, () => "ephemeral"), Match.exhaustive)), Match.exhaustive);
-const decide$3 = (command) => Match.value(commandShape(command)).pipe(Match.when("empty", () => Result.fail(InstrumentError.make({
-	stage: "instrument",
-	reason: "No files to instrument."
-}))), Match.when("inPlace", () => Result.succeed(InPlaceInstrument.make({
+const decide$3 = (command) => Match.value(command.inPlace).pipe(Match.when(true, () => Result.succeed(InPlaceInstrument.make({
 	workingDirectoryHint: "inPlace",
 	backupDirectoryHint: "backup",
 	fileCount: command.fileCount
-}))), Match.when("ephemeral", () => Result.succeed(EphemeralInstrument.make({
+}))), Match.when(false, () => Result.succeed(EphemeralInstrument.make({
 	workingDirectoryHint: "temp",
 	fileCount: command.fileCount
 }))), Match.exhaustive);
 const planInstrumentation = Workflow.make({
 	command: InstrumentCommand,
 	decision: S.Union([InPlaceInstrument, EphemeralInstrument]),
-	error: InstrumentError,
+	error: S.Never,
 	decide: decide$3
 });
 //#endregion
@@ -6406,37 +6491,6 @@ function buildErrorMessage({ type, sourceText, position }) {
 	return `Cannot parse JSONC: unexpected token "${token}" in JSONC at position ${position}`;
 }
 //#endregion
-//#region src/Sandbox.handle.ts
-const TypeId$1 = Symbol.for("@systemfsoftware/stryker-js/SandboxHandle");
-const sandboxFileNameOf = (fileMap, fileName) => Match.value(fileMap.get(fileName)).pipe(Match.when(Predicate.isString, (sandboxFileName) => Result.succeed(sandboxFileName)), Match.orElse(() => Result.fail(StrykerError.make({ message: `Cannot find sandbox file for ${fileName}` }))));
-const withoutLeadingSeparator = (suffix) => Boolean.match(suffix.startsWith("/"), {
-	onTrue: () => suffix.slice(1),
-	onFalse: () => suffix
-});
-const relativeToBase = (resolvedSandbox, resolvedWorking, base, pathService) => {
-	const trimmed = withoutLeadingSeparator(resolvedSandbox.slice(resolvedWorking.length));
-	return Boolean.match(trimmed.length === 0, {
-		onTrue: () => base,
-		onFalse: () => pathService.join(base, trimmed)
-	});
-};
-const originalFileNameOf = (sandboxFileName, workingDirectory, base, pathService) => {
-	const resolvedSandbox = pathService.resolve(sandboxFileName);
-	const resolvedWorking = pathService.resolve(workingDirectory);
-	return Boolean.match(resolvedSandbox.startsWith(resolvedWorking), {
-		onTrue: () => relativeToBase(resolvedSandbox, resolvedWorking, base, pathService),
-		onFalse: () => resolvedSandbox.replace(resolvedWorking, base)
-	});
-};
-const make$1 = (options) => {
-	const handle = {
-		workingDirectory: options.workingDirectory,
-		sandboxFileFor: (fileName) => sandboxFileNameOf(options.fileMap, fileName),
-		originalFileFor: (sandboxFileName) => originalFileNameOf(sandboxFileName, options.workingDirectory, options.basePath, options.pathService)
-	};
-	return Object.assign(handle, { [TypeId$1]: TypeId$1 });
-};
-//#endregion
 //#region src/Sandbox.schema.ts
 /**
 * Sandbox.schema — declarations for the Sandbox capability.
@@ -6463,7 +6517,7 @@ const TsConfigSchema = Schema.StructWithRest(Schema.Struct({
 /** A tsconfig `extends` entry list: the array form of `extends`. */
 const ExtendsArraySchema = Schema.Array(Schema.String);
 //#endregion
-//#region src/Sandbox.resource.ts
+//#region src/Sandbox.blueprint.ts
 const combinePreprocessors = (preprocessors) => (project) => Effect$1.forEach(preprocessors, (pre) => pre(project), { discard: true });
 const mergeUpdatedFile = (project, updated) => {
 	MutableHashMap.set(project.files, updated.name, updated);
@@ -6723,13 +6777,13 @@ const symlinkNodeModules = (options, workingDirectory, basePath, pathService) =>
 		onFalse: () => Effect$1.void
 	});
 });
-const acquireSandbox = (state) => Effect$1.gen(function* () {
-	const { options, project, workingDirectory, backupDirectory, basePath } = state.spec;
+const acquireSandbox = (spec) => Effect$1.gen(function* () {
+	const { options, project, workingDirectory, backupDirectory, basePath } = spec;
 	yield* Scope.Scope;
 	const pathService = yield* Path.Path;
 	yield* announceSandbox(options, workingDirectory, backupDirectory, basePath, pathService);
 	yield* Effect$1.when(restoreOriginalFiles(workingDirectory, backupDirectory, basePath), Effect$1.succeed(hasBackupToRestore(options, backupDirectory)));
-	yield* combinePreprocessors([createPreprocessor(options, basePath, state.spec.formatRegistry), ...state.preprocessors])(project).pipe(Effect$1.mapError((cause) => StrykerError.make({
+	yield* combinePreprocessors([createPreprocessor(options, basePath, spec.formatRegistry), ...spec.preprocessors])(project).pipe(Effect$1.mapError((cause) => StrykerError.make({
 		message: "Sandbox preprocessor failed",
 		cause
 	})));
@@ -6754,31 +6808,22 @@ const acquireSandbox = (state) => Effect$1.gen(function* () {
 		pathService
 	});
 });
-const TypeId = Symbol.for("@systemfsoftware/stryker-js/Sandbox");
-const makeProto = (state) => {
-	return {
-		[TypeId]: TypeId,
-		spec: state.spec,
-		...Prototype,
-		withPreprocessor(preprocessor) {
-			return makeProto({
-				spec: state.spec,
-				preprocessors: [...state.preprocessors, preprocessor]
-			});
-		},
-		get scoped() {
-			return acquireSandbox(state);
-		},
-		layer(service) {
-			return Layer.effect(service)(acquireSandbox(state));
-		}
-	};
-};
-const make = (spec) => makeProto({
-	spec,
+const TypeId$1 = Symbol.for("~systemfsoftware/stryker-js/Sandbox");
+const Sandboxes = Blueprint.make()(TypeId$1).steps({
+	steps: { withPreprocessor: (spec, preprocessor) => ({
+		...spec,
+		preprocessors: [...spec.preprocessors, preprocessor]
+	}) },
+	targets: {
+		scoped: (spec) => acquireSandbox(spec),
+		layer: (spec) => (service) => Layer.effect(service)(acquireSandbox(spec))
+	}
+});
+const make = (spec) => Sandboxes.of({
+	...spec,
 	preprocessors: []
 });
-dual(2, (self, preprocessor) => self.withPreprocessor(preprocessor));
+Sandboxes.operations.withPreprocessor;
 const makeSandbox = (input) => make(input).scoped;
 //#endregion
 //#region src/run/explain-file-skip.workflow.ts
@@ -6847,13 +6892,13 @@ const explainFileSkip = Workflow.make({
 	decide: (command) => Match.value(skipKnownOrUnknownOf(explainedOf(command))).pipe(Match.tag("SkipKnownExplained", (known) => Result.succeed(known)), Match.tag("SkipUnknownExplained", (unknown) => Result.succeed(unknown)), Match.exhaustive)
 });
 //#endregion
-//#region src/run/instrument.cell.ts
-const offerSkipsIfAny = (skipped, claimants) => Boolean$1.match(skipped.length === 0, {
+//#region src/run/instrument.parts.ts
+const offerSkipsIfAny = (input) => Boolean$1.match(input.skipped.length === 0, {
 	onTrue: () => Effect$1.void,
 	onFalse: () => Effect$1.gen(function* () {
-		const files = skipped.map((skip) => Result.match(explainFileSkip(ExplainFileSkipCommand.make({
+		const files = input.skipped.map((skip) => Result.match(explainFileSkip(ExplainFileSkipCommand.make({
 			extension: skip.extension,
-			claimants: [...claimants]
+			claimants: [...input.claimants]
 		})), {
 			onFailure: absurd,
 			onSuccess: (explained) => ({
@@ -6866,11 +6911,40 @@ const offerSkipsIfAny = (skipped, claimants) => Boolean$1.match(skipped.length =
 		yield* Queue.offer(queue, SkippedReported.make({ files }));
 	})
 });
+const sandboxDirectoriesOf = (input) => Boolean$1.match(input.command.options.inPlace, {
+	onTrue: () => ({
+		workingDirectory: input.basePath,
+		backupDirectory: input.command.temporaryDirectoryPath
+	}),
+	onFalse: () => ({
+		workingDirectory: input.command.temporaryDirectoryPath,
+		backupDirectory: ""
+	})
+});
+const mergeInstrumentedFile = (input) => {
+	const files = MutableHashMap.fromIterable(input.project.files);
+	MutableHashMap.set(files, input.file.name, input.file);
+	const filesToMutate = MutableHashMap.fromIterable(input.project.filesToMutate);
+	Boolean$1.match(input.file.mutate !== false, {
+		onTrue: () => MutableHashMap.set(filesToMutate, input.file.name, input.file),
+		onFalse: () => MutableHashMap.remove(filesToMutate, input.file.name)
+	});
+	return {
+		...input.project,
+		files,
+		filesToMutate
+	};
+};
+//#endregion
+//#region src/run/instrument.cell.ts
 const enteringInstrumentPhase = (raw, body) => withPhaseSpan("instrument", { fileCount: raw.filesToMutate.length }, () => Effect$1.gen(function* () {
 	yield* phaseEntered("instrument");
 	return yield* body;
 }));
-const writeInstrument = (raw) => enteringInstrumentPhase(raw, Effect$1.as(offerSkipsIfAny(raw.instrumentResult.skipped, raw.prev.frameworkClaimants), {
+const writeInstrument = (raw) => enteringInstrumentPhase(raw, Effect$1.as(offerSkipsIfAny({
+	skipped: raw.instrumentResult.skipped,
+	claimants: raw.prev.frameworkClaimants
+}), {
 	...raw.prev,
 	project: raw.instrumentedProject,
 	mutants: raw.instrumentResult.mutants,
@@ -6880,37 +6954,13 @@ const writeInstrument = (raw) => enteringInstrumentPhase(raw, Effect$1.as(offerS
 		checkers: raw.concurrency.checkers
 	}
 }));
-const sandboxDirectoriesOf = (command, basePath) => Boolean$1.match(command.options.inPlace, {
-	onTrue: () => ({
-		workingDirectory: basePath,
-		backupDirectory: command.temporaryDirectoryPath
-	}),
-	onFalse: () => ({
-		workingDirectory: command.temporaryDirectoryPath,
-		backupDirectory: ""
-	})
-});
-const mergeInstrumentedFile = (project, file) => {
-	const files = MutableHashMap.fromIterable(project.files);
-	MutableHashMap.set(files, file.name, file);
-	const filesToMutate = MutableHashMap.fromIterable(project.filesToMutate);
-	Boolean$1.match(file.mutate !== false, {
-		onTrue: () => MutableHashMap.set(filesToMutate, file.name, file),
-		onFalse: () => MutableHashMap.remove(filesToMutate, file.name)
-	});
-	return {
-		...project,
-		files,
-		filesToMutate
-	};
-};
-const withInstrumentedFiles = (project, instrumented) => Arr.reduce([...instrumented], project, (current, { name, content }) => Option$1.match(MutableHashMap.get(current.files, name), {
-	onNone: () => current,
-	onSome: (existing) => mergeInstrumentedFile(current, {
+const withInstrumentedFiles = (project, instrumented) => Arr.reduce([...instrumented], project, (current, { name, content }) => Option$1.getOrElse(Option$1.map(MutableHashMap.get(current.files, name), (existing) => mergeInstrumentedFile({
+	project: current,
+	file: {
 		...existing,
 		content
-	})
-}));
+	}
+})), () => current));
 const instrumentCell = Sandwich.named("stryker.instrument")((command) => Effect$1.gen(function* () {
 	yield* Scope.Scope;
 	const env = yield* RunEnvironment;
@@ -6934,7 +6984,10 @@ const instrumentCell = Sandwich.named("stryker.instrument")((command) => Effect$
 		cause
 	})));
 	const instrumentedProject = withInstrumentedFiles(command.project, instrumentResult.files);
-	const directories = sandboxDirectoriesOf(command, env.basePath);
+	const directories = sandboxDirectoriesOf({
+		command,
+		basePath: env.basePath
+	});
 	const sandbox = yield* makeSandbox({
 		options: command.options,
 		project: instrumentedProject,
@@ -6962,14 +7015,6 @@ const instrumentCell = Sandwich.named("stryker.instrument")((command) => Effect$
 })).decide(planInstrumentation).write({
 	InPlaceInstrument: (_decision, raw) => writeInstrument(raw),
 	EphemeralInstrument: (_decision, raw) => writeInstrument(raw),
-	InstrumentError: ({ stage, reason }, raw) => enteringInstrumentPhase(raw, Effect$1.fail(StageError.make({
-		stage,
-		reason,
-		cause: InstrumentError.make({
-			stage,
-			reason
-		})
-	}))),
 	CommandRejected: ({ issue }) => Effect$1.fail(StageError.make({
 		stage: "instrument",
 		reason: issue
@@ -6994,7 +7039,11 @@ var MutationTestCommand = class extends S.TaggedClass()("MutationTestCommand", {
 var MutationTestError = class extends S.TaggedError()("MutationTestError", {
 	stage: S.Literal("mutationTest"),
 	reason: S.String
-}) {};
+}) {
+	get message() {
+		return this.reason;
+	}
+};
 const MutationTestDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/MutationTestDecision");
 var MutationTestProceed = class extends S.TaggedClass()("MutationTestProceed", {}) {
 	[MutationTestDecisionTypeId] = MutationTestDecisionTypeId;
@@ -7028,13 +7077,18 @@ const admitMutationTest = Workflow.make({
 	decide: decide$2
 });
 //#endregion
-//#region src/Checker/Checker.resource.ts
+//#region src/Checker/Checker.blueprint.ts
+const TypeId = Symbol.for("~systemfsoftware/stryker-js/CheckerBlueprint");
 const checkerProcessCrashes = Metric.counter("stryker.checker.process_crashes", {
 	description: "Checker worker processes that never became usable",
 	incremental: true
 });
 const TEMP_DIR_PREFIX = "stryker-checker-";
 const nodeArgsOf = (options) => Match.value(options.checkers[0]?.nodeArgs).pipe(Match.when(Match.undefined, () => options.checkerNodeArgs), Match.orElse((args) => args));
+const serviceOf = (handle) => ({
+	check: (checkerName, mutants) => check(handle, checkerName, mutants),
+	group: (checkerName, mutants) => group(handle, checkerName, mutants)
+});
 const acquire = (spec) => Effect$1.gen(function* () {
 	const client = yield* makeWorkerClient({
 		rpcs: Plugin_exports.CheckerRpcs,
@@ -7044,9 +7098,13 @@ const acquire = (spec) => Effect$1.gen(function* () {
 		execArgv: [...nodeArgsOf(spec.options)],
 		tempDirPrefix: TEMP_DIR_PREFIX
 	}).pipe(Effect$1.mapError((error) => Match.value(error).pipe(Match.tag("ChildProcessCrashedError", "OutOfMemoryError", (crash) => crash), Match.tag("WorkerBootTimeoutError", () => connectionCrashed(`Checker worker failed to start: its boot window closed before it accepted the RPC connection`)), Match.exhaustive)), Effect$1.tapError(() => Metric.update(checkerProcessCrashes, 1)));
-	return makeCheckerHandle(client);
+	return serviceOf(makeCheckerHandle(client));
 });
-const scoped = (spec) => acquire(spec);
+const Checkers = Blueprint.make()(TypeId).steps({
+	steps: {},
+	targets: { scoped: acquire }
+});
+const scoped = (spec) => Checkers.of(spec).scoped;
 //#endregion
 //#region src/incremental-diff.workflow.ts
 const REMEMBERED_STATUS = /* @__PURE__ */ new Set([
@@ -7351,7 +7409,7 @@ const planMutantTests = Workflow.make({
 	decide
 });
 //#endregion
-//#region src/run/mutation-test.cell.ts
+//#region src/run/mutation-test.parts.ts
 const relativeFileNameOf = (fileName, basePath) => RelativeNormalizedFileName.fromAbsolute(fileName, basePath).fileName;
 const readCurrentRelativeFiles = (project, basePath) => Effect$1.gen(function* () {
 	const entries = yield* (yield* ProjectFiles).readAllOriginal(MutableHashMap.values(project.files));
@@ -7368,7 +7426,7 @@ const reportingInputOf = (prev, env, results) => ({
 	reporterStage: prev.reporterStage,
 	formatRegistry: prev.formatRegistry
 });
-const sandboxFilePairsOf = (sandbox, fileNames) => Result.all(fileNames.map((fileName) => Result.map(sandbox.sandboxFileFor(fileName), (sandboxFileName) => [fileName, sandboxFileName])));
+const sandboxFilePairsOf = (sandbox, fileNames) => Result.all(fileNames.map((fileName) => Result.map(sandboxFileFor(sandbox, fileName), (sandboxFileName) => [fileName, sandboxFileName])));
 const sandboxFilesOf = (sandbox, fileNames) => Effect$1.fromResult(sandboxFilePairsOf(sandbox, fileNames)).pipe(Effect$1.mapError((cause) => StageError.make({
 	stage: "mutationTest",
 	reason: "Failed to resolve sandbox file",
@@ -7422,8 +7480,9 @@ const toReportedMutant = (mutant) => Object.assign(mutant, {
 	static: mutant.static
 });
 const CHECKER_ACQUIRE_RETRIES = 2;
+const TEST_RUNNER_POOL_IDLE_TIME_TO_LIVE = Duration.minutes(1);
 const isCheckerCrash = (error) => Match.value(error).pipe(Match.tag("ChildProcessCrashedError", "OutOfMemoryError", () => true), Match.orElse(() => false));
-const configuredPluginOf = (configured) => Match.value(configured).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
+const configuredPluginOf = (configured) => Match.value(testRunnerConfigOf(configured)).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
 const workerSpawnOf = (stage, loaded, kind, configured) => Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
 	sources: loaded.pluginSources,
 	kind,
@@ -7617,13 +7676,17 @@ const checkerBreachToStageError = (error) => Match.value(error).pipe(Match.tag("
 	cause: breach
 })), Match.exhaustive);
 const invalidateSlot = (pool, slot, error) => Effect$1.flatMap(Pool.invalidate(pool, slot), () => Effect$1.fail(error));
-const checkSlotPlans = (pool, slot, checker, checkerName, currentPlans) => checkGroupedPlans(checker, checkerName, currentPlans).pipe(Effect$1.catchTags({
-	OutOfMemoryError: (error) => invalidateSlot(pool, slot, error),
-	ChildProcessCrashedError: (error) => invalidateSlot(pool, slot, error),
-	CheckerFailed: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
-	CheckerAnsweredUnrequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
-	CheckerSkippedRequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail)
+const onCheckerSlot = (pool, checkerIndex, run) => Pool.use(pool, (slot) => Option$1.match(Option$1.fromUndefinedOr(slot[checkerIndex]), {
+	onNone: () => Effect$1.die(/* @__PURE__ */ new Error(`checker slot has no entry at index ${checkerIndex}`)),
+	onSome: ({ checker }) => run(checker).pipe(Effect$1.catchTags({
+		OutOfMemoryError: (error) => invalidateSlot(pool, slot, error),
+		ChildProcessCrashedError: (error) => invalidateSlot(pool, slot, error),
+		CheckerFailed: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
+		CheckerAnsweredUnrequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
+		CheckerSkippedRequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail)
+	}))
 }));
+const checkGroupsConcurrently = (pool, checkerIndex, checkerName, currentPlans) => Effect$1.flatMap(onCheckerSlot(pool, checkerIndex, (checker) => groupPlans(checker, checkerName, currentPlans)), (groups) => Effect$1.map(Effect$1.forEach(groups, (group) => onCheckerSlot(pool, checkerIndex, (checker) => checkPlans(checker, checkerName, group)), { concurrency: "unbounded" }), (perGroup) => perGroup.flat()));
 const isFailedCheck = (check) => check[1].status !== "passed";
 const splitCheckedPlans = (checked, reporting) => {
 	const failures = checked.filter(isFailedCheck);
@@ -7633,18 +7696,15 @@ const splitCheckedPlans = (checked, reporting) => {
 		results
 	}));
 };
-const stepOneChecker = (pool, slot, checker, checkerName, currentPlans, reporting) => checkSlotPlans(pool, slot, checker, checkerName, currentPlans).pipe(Effect$1.flatMap((checked) => splitCheckedPlans(checked, reporting)));
+const stepOneChecker = (pool, checkerIndex, checkerName, currentPlans, reporting) => checkGroupsConcurrently(pool, checkerIndex, checkerName, currentPlans).pipe(Effect$1.flatMap((checked) => splitCheckedPlans(checked, reporting)));
 const emptyRunResults = [];
-const runConfiguredCheckers = (pool, plans, reporting) => Effect$1.scoped(Effect$1.gen(function* () {
-	const slot = yield* Pool.get(pool);
-	return yield* Effect$1.reduce(slot, () => ({
-		passedPlans: plans,
-		checkerResults: emptyRunResults
-	}), (acc, { checkerName, checker }) => Effect$1.map(stepOneChecker(pool, slot, checker, checkerName, acc.passedPlans, reporting), (split) => ({
-		passedPlans: split.passed,
-		checkerResults: [...acc.checkerResults, ...split.results]
-	})));
-}));
+const runConfiguredCheckers = (pool, plans, reporting) => Effect$1.flatMap(Pool.use(pool, (slot) => Effect$1.succeed(slot.map(({ checkerName }) => checkerName))), (checkerNames) => Effect$1.reduce(checkerNames, () => ({
+	passedPlans: plans,
+	checkerResults: emptyRunResults
+}), (acc, checkerName, checkerIndex) => Effect$1.map(stepOneChecker(pool, checkerIndex, checkerName, acc.passedPlans, reporting), (split) => ({
+	passedPlans: split.passed,
+	checkerResults: [...acc.checkerResults, ...split.results]
+}))));
 const checkPlansWithConfiguredCheckers = (checkerPool, plans, reporting) => Option$1.match(Option$1.fromNullishOr(checkerPool), {
 	onNone: () => Effect$1.succeed({
 		passedPlans: plans,
@@ -7652,6 +7712,14 @@ const checkPlansWithConfiguredCheckers = (checkerPool, plans, reporting) => Opti
 	}),
 	onSome: (pool) => runConfiguredCheckers(pool, plans, reporting)
 });
+const checkerResourcesInOwnScope = (acquire) => Effect$1.gen(function* () {
+	const checkerScope = yield* Scope.make();
+	yield* Effect$1.addFinalizer(() => Scope.close(checkerScope, Exit.void));
+	return {
+		resources: yield* acquire.pipe(Scope.provide(checkerScope)),
+		releaseInBackground: Scope.close(checkerScope, Exit.void).pipe(Effect$1.forkScoped({ uninterruptible: true }))
+	};
+});
 const isPlannable = (mutant) => Result.isSuccess(S.decodeResult(CheckerMutantFromMutant)(mutant));
 const DROPPED_IDS_IN_WARNING = 5;
 const configuredTestFilesOf = (run) => run.options.testFiles.length === 0 ? [] : run.project.testFiles;
@@ -7676,7 +7744,7 @@ const stopWallClock = (result) => Boolean$1.match(wallClockTimeoutStopsRun(resul
 	})),
 	onFalse: () => Effect$1.void
 });
-const writeMutationTestNoTests = () => Effect$1.gen(function* () {
+const writeMutationTestNoTests = Effect$1.gen(function* () {
 	const env = yield* RunEnvironment;
 	const now = yield* Clock.currentTimeMillis;
 	const elapsed = Duration.millis(now - env.runStartedAt);
@@ -7687,7 +7755,7 @@ const writeMutationTestNoTests = () => Effect$1.gen(function* () {
 		verdict: null
 	};
 });
-const writeMutationTestDryRunOnly = () => Effect$1.gen(function* () {
+const writeMutationTestDryRunOnly = Effect$1.gen(function* () {
 	yield* phaseEntered("mutation-test");
 	yield* Effect$1.logInfo("The dry-run has been completed successfully. No mutations have been executed.");
 	return {
@@ -7697,14 +7765,15 @@ const writeMutationTestDryRunOnly = () => Effect$1.gen(function* () {
 });
 const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 	const prev = raw.prev;
+	const testRunnerCapacity = prev.concurrency.testRunners + prev.concurrency.checkers;
 	const { dropped, plannable: plannableMutants } = partitionPlannable(prev.mutants);
 	yield* reportDroppedMutants(dropped);
 	yield* phaseEntered("mutation-test");
 	const idGenerator = yield* IdGenerator;
 	const env = yield* RunEnvironment;
-	const checkerPool = yield* makeCheckerPool(prev, env.basePath);
+	const scopedCheckers = yield* checkerResourcesInOwnScope(makeCheckerPool(prev, env.basePath));
 	const testFiles = yield* Effect$1.map(sandboxFilesOf(prev.sandbox, configuredTestFilesOf(prev)), (pairs) => pairs.map(([, sandboxFileName]) => sandboxFileName));
-	const testRunnerPool = yield* Pool.make({
+	const testRunnerPool = yield* Pool.makeWithTTL({
 		acquire: buildTestRunner({
 			options: prev.options,
 			fileDescriptions: prev.project.fileDescriptions,
@@ -7722,7 +7791,9 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 				idGenerator
 			})));
 		})),
-		size: prev.concurrency.testRunners
+		min: prev.concurrency.testRunners,
+		max: testRunnerCapacity,
+		timeToLive: TEST_RUNNER_POOL_IDLE_TIME_TO_LIVE
 	});
 	const reporting = yield* MutationReporting;
 	const sandboxFileByName = Object.fromEntries(yield* sandboxFilesOf(prev.sandbox, [...MutableHashMap.keys(prev.project.filesToMutate)]));
@@ -7765,7 +7836,8 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 	})).pipe(Effect$1.ignoreCause);
 	const progressQueue = yield* RunEvents;
 	yield* Queue.offer(progressQueue, PlanKnown.make({ total: allPlansForReporter.length + noCoverageResults.length }));
-	const { passedPlans, checkerResults } = yield* checkPlansWithConfiguredCheckers(checkerPool, sortedPlans, reporting);
+	const { passedPlans, checkerResults } = yield* checkPlansWithConfiguredCheckers(scopedCheckers.resources, sortedPlans, reporting);
+	const checkerRelease = yield* scopedCheckers.releaseInBackground;
 	const testRunnerStream = Stream.fromIterable(passedPlans);
 	const plannedTotal = sortedPlans.length + noCoverageResults.length + rememberedResults.length;
 	const completedRef = yield* Ref.make(0);
@@ -7866,7 +7938,7 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 		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])));
+	})), { concurrency: Math.max(1, testRunnerCapacity) }).pipe(Stream.runCollect, Effect$1.map((chunk) => [...chunk])));
 	const allResults = [
 		...rememberedResults,
 		...noCoverageResults,
@@ -7874,16 +7946,24 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 		...runResults
 	];
 	const outcomeResult = yield* reporting.reportAll(reportingInputOf(prev, env, allResults));
+	yield* Fiber.await(checkerRelease);
 	const doneNow = yield* Clock.currentTimeMillis;
 	const elapsed = Duration.millis(doneNow - env.runStartedAt);
 	yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
 	return outcomeResult;
 }).pipe(Effect$1.mapError((cause) => mapMutationTestCause(cause)));
-const writeMutationTestOutcome = (raw, outcome) => withPhaseSpan("mutationTest", {
+const writeMutationTestOutcome = ({ raw, outcome }) => withPhaseSpan("mutationTest", {
 	mutantCount: raw.prev.mutants.length,
 	skippedMutantCount: partitionPlannable(raw.prev.mutants).dropped.length,
 	testCount: raw.prev.dryRunResult.tests.length
 }, () => outcome);
+const mapMutationTestCause = (cause) => Match.value({ cause }).pipe(Match.when({ cause: isStageError }, ({ cause }) => cause), Match.orElse(({ cause }) => StageError.make({
+	stage: "mutationTest",
+	reason: "Mutation testing failed",
+	cause
+})));
+//#endregion
+//#region src/run/mutation-test.cell.ts
 const mutationTestCell$1 = Sandwich.named("stryker.mutation_test")((command) => Effect$1.gen(function* () {
 	yield* Scope.Scope;
 	const prev = command;
@@ -7896,9 +7976,18 @@ const mutationTestCell$1 = Sandwich.named("stryker.mutation_test")((command) =>
 		prev
 	};
 })).decide(admitMutationTest).write({
-	MutationTestDryRunOnly: (_decision, raw) => writeMutationTestOutcome(raw, writeMutationTestDryRunOnly()),
-	MutationTestNoTests: (_decision, raw) => writeMutationTestOutcome(raw, writeMutationTestNoTests()),
-	MutationTestProceed: (_decision, raw) => writeMutationTestOutcome(raw, writeMutationTestProceed(raw)),
+	MutationTestDryRunOnly: (_decision, raw) => writeMutationTestOutcome({
+		raw,
+		outcome: writeMutationTestDryRunOnly
+	}),
+	MutationTestNoTests: (_decision, raw) => writeMutationTestOutcome({
+		raw,
+		outcome: writeMutationTestNoTests
+	}),
+	MutationTestProceed: (_decision, raw) => writeMutationTestOutcome({
+		raw,
+		outcome: writeMutationTestProceed(raw)
+	}),
 	MutationTestError: ({ stage, reason }) => Effect$1.fail(StageError.make({
 		stage,
 		reason,
@@ -7912,11 +8001,6 @@ const mutationTestCell$1 = Sandwich.named("stryker.mutation_test")((command) =>
 		reason: issue
 	}))
 });
-const mapMutationTestCause = (cause) => Match.value({ cause }).pipe(Match.when({ cause: isStageError }, ({ cause }) => cause), Match.orElse(({ cause }) => StageError.make({
-	stage: "mutationTest",
-	reason: "Mutation testing failed",
-	cause
-})));
 //#endregion
 //#region src/framework-claimant.service.ts
 const dependencyNamesOf = (dependencies) => Object.keys(dependencies ?? {});
@@ -8342,7 +8426,7 @@ const pluginUrlsFromOptions = (options) => [
 	...options.plugins,
 	...options.appendPlugins,
 	...options.ignorers,
-	...Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => [runner.plugin]), Match.orElse(() => [])),
+	...Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => [runner.plugin]), Match.when(isVmRunner, () => [vmRunnerPluginUrl()]), Match.orElse(() => [])),
 	...options.checkers.map((checker) => checker.plugin)
 ];
 //#endregion
@@ -8463,24 +8547,48 @@ const planPrepare = Workflow.make({
 	decide: (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.parts.ts
+const announceSummary = (input) => Match.value(input.env.resolvedMode.mode).pipe(Match.when("human", () => announceHumanSummary({
+	allowConsoleColors: input.env.allowConsoleColors,
+	summary: input.summary
+})), Match.orElse(() => Effect$1.logInfo(input.summary)));
+const announceHumanSummary = (input) => Boolean$1.match(input.allowConsoleColors, {
+	onTrue: () => Console.log(`${AnsiCode.fields.green.literal}${input.summary}${AnsiCode.fields.reset.literal}`),
+	onFalse: () => Console.log(input.summary)
+});
+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 = dual(2, (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));
+const failOnEmptyProject = (fileCount) => Match.value(fileCount).pipe(Match.when(0, () => Effect$1.fail(StageError.make({
+	stage: "prepare",
+	reason: "No input files found.",
+	cause: PrepareError.make({
+		stage: "prepare",
+		reason: "No input files found."
+	})
+}))), Match.orElse(() => Effect$1.void));
+//#endregion
 //#region src/run/prepare.cell.ts
 const NO_PLUGIN_DESCRIPTORS = [];
 const schemaPropertiesOf = (document) => Option$1.getOrElse(Option$1.fromNullishOr(document.properties), () => ({}));
-const buildMergedSchema = (core, contributions) => Boolean$1.match(contributions.length === 0, {
-	onTrue: () => core,
-	onFalse: () => ({
-		...core,
-		properties: contributions.reduce((merged, contribution) => ({
-			...merged,
-			...schemaPropertiesOf(contribution)
-		}), schemaPropertiesOf(core))
-	})
-});
-const announceSummary = (env, summary) => Match.value(env.resolvedMode.mode).pipe(Match.when("human", () => announceHumanSummary(env.allowConsoleColors, summary)), Match.orElse(() => Effect$1.logInfo(summary)));
-const announceHumanSummary = (allowConsoleColors, summary) => Boolean$1.match(allowConsoleColors, {
-	onTrue: () => Console.log(`${AnsiCode.fields.green.literal}${summary}${AnsiCode.fields.reset.literal}`),
-	onFalse: () => Console.log(summary)
-});
+const buildMergedSchema = (core, contributions) => contributions.reduce((merged, contribution) => ({
+	...merged,
+	properties: {
+		...schemaPropertiesOf(merged),
+		...schemaPropertiesOf(contribution)
+	}
+}), core);
 const readPrepare = (command) => Effect$1.gen(function* () {
 	yield* Scope.Scope;
 	const env = yield* RunEnvironment;
@@ -8531,9 +8639,10 @@ const readPrepare = (command) => Effect$1.gen(function* () {
 	}])]);
 	const frameworkClaimants = yield* installedFrameworkClaimants(env.basePath);
 	return {
+		now: yield* Clock.currentTimeMillis,
 		mode: env.resolvedMode.mode,
 		reporters: [...options.reporters],
-		fileCount: MutableHashMap.size(command.project.files),
+		fileCount: pipe(command.project.files, MutableHashMap.size),
 		availableReporters: [...HashMap.values(reporterChoicesByName)].map((choice) => choice.name),
 		env,
 		queue,
@@ -8548,22 +8657,17 @@ const readPrepare = (command) => Effect$1.gen(function* () {
 	};
 });
 const writePrepare = (reporters, raw) => withPhaseSpan("prepare", {}, (span) => Effect$1.gen(function* () {
-	const mutateCount = MutableHashMap.size(raw.project.filesToMutate);
-	yield* announceSummary(raw.env, `Found ${mutateCount} of ${MutableHashMap.size(raw.project.files)} file(s) to be mutated.`);
+	const mutateCount = pipe(raw.project.filesToMutate, MutableHashMap.size);
+	yield* announceSummary({
+		env: raw.env,
+		summary: `Found ${mutateCount} of ${pipe(raw.project.files, MutableHashMap.size)} file(s) to be mutated.`
+	});
 	yield* validateReporterNames(raw.options.reporters, [...HashMap.values(raw.reporterChoicesByName)].map((choice) => choice.name)).pipe(Effect$1.mapError((cause) => StageError.make({
 		stage: "prepare",
 		reason: cause.message,
 		cause
 	})));
-	const failOnEmptyProject = (fileCount) => Match.value(fileCount).pipe(Match.when(0, () => Effect$1.fail(StageError.make({
-		stage: "prepare",
-		reason: "No input files found.",
-		cause: PrepareError.make({
-			stage: "prepare",
-			reason: "No input files found."
-		})
-	}))), Match.orElse(() => Effect$1.void));
-	yield* failOnEmptyProject(raw.project.files.pipe(MutableHashMap.size));
+	yield* failOnEmptyProject(pipe(raw.project.files, MutableHashMap.size));
 	const temporaryDirectoryPath = yield* Effect$1.map(Layer.build(TemporaryDirectory.layer(raw.options)), (temporaryDirectory) => Context.get(temporaryDirectory, TemporaryDirectory).path).pipe(Effect$1.mapError((cause) => StageError.make({
 		stage: "prepare",
 		reason: "Failed to create temporary directory",
@@ -8572,7 +8676,7 @@ const writePrepare = (reporters, raw) => withPhaseSpan("prepare", {}, (span) =>
 	const reporterInputs = yield* reporterInputsOf(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;
+	const { now } = raw;
 	yield* Queue.offer(raw.queue, PhaseEntered.make({
 		phase: "prepare",
 		elapsedMs: now - raw.env.runStartedAt
@@ -8588,20 +8692,6 @@ const writePrepare = (reporters, raw) => withPhaseSpan("prepare", {}, (span) =>
 		frameworkClaimants: raw.frameworkClaimants
 	};
 }));
-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 = dual(2, (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));
 const prepareCell = Sandwich.named("stryker.prepare")(readPrepare).decide(planPrepare).write({
 	HumanReporters: ({ reporters }, raw) => writePrepare(reporters, raw),
 	MachineReporters: ({ reporters }, raw) => writePrepare(reporters, raw),
@@ -8636,4 +8726,4 @@ const strykerCell = dual((args) => Predicate$1.isObject(args[0]), (options, targ
 	})
 })), Effect$1.scoped));
 //#endregion
-export { ImportedModuleSchema as $, VerdictMutant as A, FileMatcher as B, readConfig as C, RunEvents as D, IdGenerator as E, makeWorkerClient as F, ConfigFileUnsupportedError as G, ConfigFileInvalidError as H, WorkerLauncher as I, ExtendsStepDone as J, ConfigDocumentSchema as K, make$2 as L, MetricsResultFromReport as M, reporterWorkerFactory as N, RunIdentity as O, spawnReporterWorker as P, ExtendsStepStateSchema as Q, StrykerError as R, mergeConfigs as S, RunEnvironment as T, ConfigFileNotFoundError as U, ConfigError as V, ConfigFileUnreadableError as W, ExtendsStepRefused as X, ExtendsStepRead as Y, ExtendsStepResolve as Z, describeErrors as _, RunEventDrainLive as a, survivorsPriorReport as at, initialExtendsStepState as b, isVmRunner as c, OutOfMemoryError as ct, nodePlatformLayer as d, CheckerSkippedRequested as dt, MergeCommand as et, layerWorkerProtocol as f, decideExtendsStep as g, classifyWorkerExit as h, RunEventDrain as i, forkOptionsSchema as it, VerdictThresholds as j, VerdictEnvelope as k, vmTestRunner as l, WorkerBootTimeoutError as lt, ClassifyWorkerExitDecision as m, strykerCell as n, ReadConfigCommand as nt, makeRunEventStream as o, checkGroupedPlans as ot, ClassifyWorkerExitCommand as p, ExtendsStepDocumentSchema as q, buildTestRunner as r, extendsPropertySchema as rt, RunEventWireLine as s, ChildProcessCrashedError as st, mutationTestCell as t, MergeResult as tt, IncrementalReportSchema as u, CheckerAnsweredUnrequested as ut, forkCoreSchema as v, validateOptions as w, loadConfigCell as x, importModule as y, isCommandRunner as z };
+export { ExtendsStepDone as $, RunEvents as A, make$2 as B, forkCoreSchema as C, validateOptions as D, mergeConfigs as E, MetricsResultFromReport as F, ConfigFileInvalidError as G, isCommandRunner as H, reporterWorkerFactory as I, ConfigFileUnsupportedError as J, ConfigFileNotFoundError as K, spawnReporterWorker as L, VerdictEnvelope as M, VerdictMutant as N, RunEnvironment as O, VerdictThresholds as P, ExtendsStepDocumentSchema as Q, makeWorkerClient as R, describeErrors as S, initialExtendsStepState as T, FileMatcher as U, StrykerError as V, ConfigError as W, defaultOptions as X, createDefaultOptions as Y, ConfigDocumentSchema as Z, ClassifyWorkerExitDecision as _, isVmRunner as a, MergeCommand as at, readConfig as b, vmTestRunnerConfig as c, extendsPropertySchema as ct, makeRunEventStream as d, checkGroupedPlans as dt, ExtendsStepRead as et, RunEventWireLine as f, ChildProcessCrashedError as ft, ClassifyWorkerExitCommand as g, CheckerSkippedRequested as gt, layerWorkerProtocol as h, CheckerAnsweredUnrequested as ht, makeChildProcessTestRunner as i, ImportedModuleSchema as it, RunIdentity as j, IdGenerator as k, RunEventDrain as l, forkOptionsSchema as lt, nodePlatformLayer as m, WorkerBootTimeoutError as mt, strykerCell as n, ExtendsStepResolve as nt, testRunnerConfigOf as o, MergeResult as ot, IncrementalReportSchema as p, OutOfMemoryError as pt, ConfigFileUnreadableError as q, buildTestRunner as r, ExtendsStepStateSchema as rt, vmRunnerPluginUrl as s, ReadConfigCommand as st, mutationTestCell as t, ExtendsStepRefused as tt, RunEventDrainLive as u, survivorsPriorReport as ut, classifyWorkerExit as v, importModule as w, decideExtendsStep as x, loadConfigCell as y, WorkerLauncher as z };