@systemfsoftware/stryker-js 11.0.0 → 12.0.0

package/dist/{run-stages.cell-CPpkn7og.mjs → run-stages.cell-MyhsNxH2.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-BxsyHwHr.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,8 +59,8 @@ 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 * as Equivalence from "effect/Equivalence";
 import { Session } from "@systemfsoftware/stryker-vm-harness";
 import * as Console from "effect/Console";
 import * as Formatter from "effect/Formatter";
@@ -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$11 = 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$11);
+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",
@@ -418,7 +419,11 @@ const checkCell = Sandwich.named("stryker.checker.check_plans")(readCheckCommand
 	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),
+	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",
@@ -479,6 +484,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 +718,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$10 = Symbol.for("~systemfsoftware/stryker-js/PooledTestRunner");
+const PooledTestRunner = Handle.make()(TypeId$10);
+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 +749,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 +759,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 +776,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 +792,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 +816,11 @@ const withEnvironmentReload = dual(2, (inner, retire) => Effect$1.gen(function*
 				reloadEnvironment: plan.reloadEnvironment
 			}));
 		})
-	};
+	});
 }));
+//#endregion
+//#region src/command-runner.blueprint.ts
+const TypeId$9 = 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 +872,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 +880,23 @@ const commandRunner = dual(2, (context, spawner) => {
 		dryRun: () => commandRunnerDryRun(config).pipe(provided),
 		mutantRun: (options) => commandRunnerMutantRun(config, options).pipe(provided)
 	});
+};
+const CommandRunners = Blueprint.make()(TypeId$9).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
@@ -1203,7 +1243,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 +1266,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$8 = 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$8).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 +1320,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$7 = Symbol.for("~systemfsoftware/stryker-js/SpawnedSocketWorker");
+const SpawnedSocketWorker = Handle.make()(TypeId$7);
+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$6 = 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$2 = (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 +1350,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$6).steps({
+	steps: {},
+	targets: { scoped: scopedOf$2 }
+});
+const makeWorkerClient = (params) => WorkerClients().of(params).scoped;
 const ReporterStageTypeId = Symbol.for("@systemfsoftware/stryker-js/ReporterStage");
 const carriesAttachments = (stage) => "attachments" in stage;
 const makeReporterStage = (attachments) => {
@@ -1677,7 +1740,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.0.0";
 //#endregion
 //#region src/stryker-package.schema.ts
 var StrykerPackage = class extends S.Class("StrykerPackage")({
@@ -2108,7 +2171,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;
 };
@@ -2525,7 +2589,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 +2643,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 +2681,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 +2701,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 +2723,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 +2744,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 +2756,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 +2773,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 +2880,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 +2925,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 +3135,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 +3302,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 +3610,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 +3630,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 +3696,10 @@ const classifyWorkerExit = Workflow.make({
 	decide: decide$8
 });
 //#endregion
-//#region src/worker-protocol.resource.ts
+//#region src/worker-protocol.blueprint.ts
+const TypeId$5 = 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,6 +3738,11 @@ 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$5).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));
@@ -3897,7 +3979,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 +3998,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 +4010,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 +4019,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 +4042,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 +4094,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,6 +4145,9 @@ const admitIncrementalReport = Workflow.make({
 	error: S.Never,
 	decide: (command) => Result.succeed(decide$6(command))
 });
+//#endregion
+//#region src/VmRunner.blueprint.ts
+const TypeId$4 = Symbol.for("~systemfsoftware/stryker-js/VmTestRunner");
 const isVmRunner = (name) => typeof name === "string" && name.toLowerCase() === "vm";
 const vmRunnerCapabilities = { reloadEnvironment: true };
 const HOST_TIMEOUT_SLACK_MS = 1e3;
@@ -4178,12 +4268,17 @@ const pooledVmRunner = (config, scope) => {
 		})))
 	});
 };
-const vmTestRunner = (config) => Effect$1.gen(function* () {
+const scopedOf$1 = (config) => Effect$1.gen(function* () {
 	const scope = yield* Effect$1.scope;
 	return pooledVmRunner(config, scope);
 });
+const VmRunners = Blueprint.make()(TypeId$4).steps({
+	steps: {},
+	targets: { scoped: scopedOf$1 }
+});
+const vmTestRunner = (config) => VmRunners.of(config).scoped;
 //#endregion
-//#region src/read-project.cell.ts
+//#region src/read-project.parts.ts
 const ALWAYS_IGNORE = Object.freeze([
 	"node_modules",
 	".git",
@@ -4596,7 +4691,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 +4714,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 +4724,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",
@@ -5006,7 +5112,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 +5141,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 +5166,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 +5198,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,
@@ -5490,7 +5609,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,
@@ -5612,6 +5731,10 @@ var DryRunError = class extends S.TaggedError()("DryRunError", {
 	stage: S.Literals(["dryRun", "dryRunNoTests"]),
 	reason: S.String
 }) {};
+var FailedTestSummary = class extends S.Class("FailedTestSummary")({
+	name: S.String,
+	failureMessage: S.String
+}) {};
 var DryRunCommand = class extends S.TaggedClass()("DryRunCommand", {
 	status: S.Literals([
 		"Complete",
@@ -5620,6 +5743,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 +5761,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 +5773,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 +5831,43 @@ 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);
+});
+//#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,7 +5890,7 @@ 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 scopedOf = (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 client = yield* makeWorkerClient({
@@ -5750,6 +5913,11 @@ 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,
@@ -5911,8 +6079,8 @@ 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)));
+//#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(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,
@@ -5936,11 +6104,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 +6121,7 @@ const commandEncodedFailed = (failed, allowEmpty) => ({
 	status: "Error",
 	testCount: 0,
 	failedTestCount: 0,
+	failedTests: [],
 	allowEmpty,
 	errorMessage: failed.errorMessage
 });
@@ -5956,6 +6130,7 @@ const commandEncodedTimedOut = (timedOut, allowEmpty) => ({
 	status: "Timeout",
 	testCount: 0,
 	failedTestCount: 0,
+	failedTests: [],
 	allowEmpty,
 	...Option$1.match(Option$1.fromNullishOr(timedOut.reason), {
 		onNone: () => ({}),
@@ -5987,7 +6162,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 +6285,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,
@@ -6406,37 +6593,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 +6619,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 +6879,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 +6910,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 +6994,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 +7013,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 +7056,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 +7086,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,
@@ -7028,13 +7183,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 +7204,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 Checkers = Blueprint.make()(TypeId).steps({
+	steps: {},
+	targets: { scoped: acquire }
 });
-const scoped = (spec) => acquire(spec);
+const scoped = (spec) => Checkers.of(spec).scoped;
 //#endregion
 //#region src/incremental-diff.workflow.ts
 const REMEMBERED_STATUS = /* @__PURE__ */ new Set([
@@ -7351,7 +7515,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 +7532,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",
@@ -7676,7 +7840,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 +7851,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 {
@@ -7879,11 +8043,18 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 	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 +8067,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 +8092,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 ?? {});
@@ -8463,24 +8638,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 +8730,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 +8748,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 +8767,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 +8783,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 +8817,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 { ExtendsStepResolve as $, VerdictMutant as A, FileMatcher as B, mergeConfigs as C, RunEvents as D, IdGenerator as E, makeWorkerClient as F, ConfigFileUnsupportedError as G, ConfigFileInvalidError as H, WorkerLauncher as I, ConfigDocumentSchema as J, createDefaultOptions as K, make$2 as L, MetricsResultFromReport as M, reporterWorkerFactory as N, RunIdentity as O, spawnReporterWorker as P, ExtendsStepRefused as Q, StrykerError as R, initialExtendsStepState as S, RunEnvironment as T, ConfigFileNotFoundError as U, ConfigError as V, ConfigFileUnreadableError as W, ExtendsStepDone as X, ExtendsStepDocumentSchema as Y, ExtendsStepRead as Z, readConfig as _, RunEventDrainLive as a, extendsPropertySchema as at, forkCoreSchema as b, isVmRunner as c, checkGroupedPlans as ct, nodePlatformLayer as d, WorkerBootTimeoutError as dt, ExtendsStepStateSchema as et, layerWorkerProtocol as f, CheckerAnsweredUnrequested as ft, loadConfigCell as g, classifyWorkerExit as h, RunEventDrain as i, ReadConfigCommand as it, VerdictThresholds as j, VerdictEnvelope as k, vmTestRunner as l, ChildProcessCrashedError as lt, ClassifyWorkerExitDecision as m, strykerCell as n, MergeCommand as nt, makeRunEventStream as o, forkOptionsSchema as ot, ClassifyWorkerExitCommand as p, CheckerSkippedRequested as pt, defaultOptions as q, buildTestRunner as r, MergeResult as rt, RunEventWireLine as s, survivorsPriorReport as st, mutationTestCell as t, ImportedModuleSchema as tt, IncrementalReportSchema as u, OutOfMemoryError as ut, decideExtendsStep as v, validateOptions as w, importModule as x, describeErrors as y, isCommandRunner as z };