@systemfsoftware/stryker-js 12.0.0 → 12.1.1

package/dist/{run-stages.cell-MyhsNxH2.mjs → run-stages.cell-CtFLJCm0.mjs}

@@ -1,4 +1,4 @@
-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 { A as Plugin_exports, D as VerdictReached, E as SkippedReported, F as ErrorText_exports, I as Format_exports, L as Instrument_exports, M as Reporter_exports, N as TestRunner_exports, O as Checker_exports, P as Trace_exports$1, R as Mutant_exports, _ as PluginsReported, b as RunFailed$1, c as Heartbeat, f as OutputMode, i as FormatRegistryResolved, j as Report_exports, k as Options_exports, l as HelpRendered, m as PlanKnown, n as StageError, p as PhaseEntered, t as PrepareError, u as ModeSignal, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-BaK_pxuK.mjs";
 import { t as mergeConfig } from "./merge-config-ByZJPeQZ.mjs";
 import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Boolean$1 from "effect/Boolean";
@@ -61,13 +61,13 @@ import * as NodeFileSystem$1 from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath$1 from "@effect/platform-node-shared/NodePath";
 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";
 import * as Runtime from "effect/Runtime";
 import * as Order from "effect/Order";
 import * as CliError from "effect/unstable/cli/CliError";
 import { sha256 } from "@noble/hashes/sha2.js";
+import "effect/Deferred";
 import * as Pool from "effect/Pool";
 import * as Semaphore from "effect/Semaphore";
 //#region src/admit-checker-answer.workflow.ts
@@ -178,14 +178,14 @@ var WorkerBootTimeoutError = class extends Schema.TaggedError()("WorkerBootTimeo
 };
 //#endregion
 //#region src/Checker/Checker.handle.ts
-const TypeId$11 = Symbol.for("~systemfsoftware/stryker-js/Checker");
+const TypeId$10 = Symbol.for("~systemfsoftware/stryker-js/Checker");
 const checkerDuration = Metric.timer("stryker.checker.duration", { description: "Checker worker RPC duration in milliseconds" });
 const checkerMutantsChecked = Metric.counter("stryker.checker.mutants.checked", { description: "Total number of mutants a checker worker answered for" });
 const checkerRpcFailures = Metric.counter("stryker.checker.rpc_failures", {
 	description: "Checker worker RPC calls that did not complete, excluding interruptions",
 	incremental: true
 });
-const CheckerHandle = Handle.make()(TypeId$11);
+const CheckerHandle = Handle.make()(TypeId$10);
 const isCheckerHandle = CheckerHandle.is;
 const connectionCrashed = (cause) => ChildProcessCrashedError.make({
 	pid: 0,
@@ -418,7 +418,7 @@ const checkCell = Sandwich.named("stryker.checker.check_plans")(readCheckCommand
 	CheckerSkippedRequested: (breach) => Effect$1.fail(CheckerSkippedRequested.make(breach)),
 	CommandRejected: ({ issue }, raw) => Effect$1.fail(commandFailed(issue, raw))
 });
-const checkGroupedCell = Sandwich.named("stryker.checker.group_plans")(readGroupCommand).decide(admitCheckerAnswer).write({
+const groupCell = Sandwich.named("stryker.checker.group_plans")(readGroupCommand).decide(admitCheckerAnswer).write({
 	CheckGroupDecision: ({ groups }, raw) => writeDecidedGroups({
 		plans: raw.plans,
 		checkerName: raw.checkerName,
@@ -432,16 +432,20 @@ const checkGroupedCell = Sandwich.named("stryker.checker.group_plans")(readGroup
 	CheckerAnsweredUnrequested: (breach) => Effect$1.fail(CheckerAnsweredUnrequested.make(breach)),
 	CheckerSkippedRequested: (breach) => Effect$1.fail(CheckerSkippedRequested.make(breach)),
 	CommandRejected: ({ issue }, raw) => Effect$1.fail(commandFailed(issue, raw))
-}).pipe(Cell.flatMap((groups) => Cell.mapInput(Cell.collect(checkCell, (perGroup) => perGroup.flat()), (input) => groups.map((group) => ({
+});
+const checkGroupedCell = groupCell.pipe(Cell.flatMap((groups) => Cell.mapInput(Cell.collect(checkCell, (perGroup) => perGroup.flat()), (input) => groups.map((group) => ({
 	...input,
 	plans: group
 })))));
-const checkGroupedPlans = dual(3, (checker, checkerName, plans) => checkGroupedCell.run({
+const checkRequestOf = (checker, checkerName, plans) => ({
 	checker,
 	checkerName,
 	plans,
 	lookup: lookupOf(partitionMutantsForWire(plans))
-}));
+});
+const groupPlans = dual(3, (checker, checkerName, plans) => groupCell.run(checkRequestOf(checker, checkerName, plans)));
+const checkPlans = dual(3, (checker, checkerName, plans) => checkCell.run(checkRequestOf(checker, checkerName, plans)));
+const checkGroupedPlans = dual(3, (checker, checkerName, plans) => checkGroupedCell.run(checkRequestOf(checker, checkerName, plans)));
 //#endregion
 //#region src/Config.schema.ts
 const ConfigDocumentSchema = S.Record(S.String, S.Unknown);
@@ -718,8 +722,8 @@ const interpretDryRunResult = Workflow.make({
 });
 //#endregion
 //#region src/pooled-test-runner.handle.ts
-const TypeId$10 = Symbol.for("~systemfsoftware/stryker-js/PooledTestRunner");
-const PooledTestRunner = Handle.make()(TypeId$10);
+const TypeId$9 = Symbol.for("~systemfsoftware/stryker-js/PooledTestRunner");
+const PooledTestRunner = Handle.make()(TypeId$9);
 PooledTestRunner.is;
 const make$3 = (runner) => PooledTestRunner.make({
 	capabilities: runner.capabilities,
@@ -820,7 +824,7 @@ const withEnvironmentReload = dual(2, (inner, retire) => Effect$1.gen(function*
 }));
 //#endregion
 //#region src/command-runner.blueprint.ts
-const TypeId$9 = Symbol.for("~systemfsoftware/stryker-js/CommandRunner");
+const TypeId$8 = Symbol.for("~systemfsoftware/stryker-js/CommandRunner");
 const ALL_TESTS_NAME = "All tests";
 const isCommandRunner = (name) => typeof name === "string" && name.toLowerCase() === "command";
 const commandRunnerCapabilities = { reloadEnvironment: true };
@@ -881,7 +885,7 @@ const pooledRunnerOf = (config, spawner) => {
 		mutantRun: (options) => commandRunnerMutantRun(config, options).pipe(provided)
 	});
 };
-const CommandRunners = Blueprint.make()(TypeId$9).steps({
+const CommandRunners = Blueprint.make()(TypeId$8).steps({
 	steps: {},
 	targets: { runner: (spec) => (spawner) => pooledRunnerOf({
 		workingDir: spec.workingDir,
@@ -1036,7 +1040,7 @@ const resolveConfig = Workflow.make({
 const ExitDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/ExitDecision");
 var ClassifyExitCommand = class extends S.TaggedClass()("ClassifyExitCommand", {
 	pending: S.Array(Plugin_exports.ExitClass),
-	score: S.NullOr(S.Finite),
+	score: Report_exports.MutationScore,
 	breakingThreshold: S.NullOr(S.Finite)
 }) {
 	static [Workflow.InstrumentationBrand] = {};
@@ -1071,9 +1075,12 @@ const PRECEDENCE = [
 ];
 const precedenceOf = (pending) => Arr.findFirst(PRECEDENCE, (candidate) => pending.includes(candidate));
 const decisionOf$1 = (exitClass) => Match.value(exitClass).pipe(Match.when("VerdictFail", () => ExitVerdictFailed.make({})), Match.when("ConfigError", () => ExitConfigErrored.make({})), Match.when("RuntimeError", () => ExitRuntimeErrored.make({})), Match.when("InternalError", () => ExitInternalErrored.make({})), Match.exhaustive);
-const verdictExitClass = (score, breakingThreshold) => Option$1.match(Option$1.all([Option$1.fromNullishOr(score), Option$1.fromNullishOr(breakingThreshold)]), {
-	onNone: () => null,
-	onSome: ([actual, threshold]) => Match.value(actual < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)
+const verdictExitClass = (score, breakingThreshold) => Match.valueTags(score, {
+	Unscored: () => null,
+	Scored: ({ percentage }) => Option$1.match(Option$1.fromNullishOr(breakingThreshold), {
+		onNone: () => null,
+		onSome: (threshold) => Match.value(percentage < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)
+	})
 });
 const decide$9 = (command) => Option$1.match(Option$1.fromNullishOr(verdictExitClass(command.score, command.breakingThreshold)), {
 	onNone: () => Option$1.match(precedenceOf(command.pending), {
@@ -1266,13 +1273,13 @@ 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 TypeId$8 = Symbol.for("~systemfsoftware/stryker-js-plugin-runtime/WorkerServer");
+const TypeId$7 = Symbol.for("~systemfsoftware/stryker-js-plugin-runtime/WorkerServer");
 const workerServerLayerOf = (params) => Layer.unwrap(Effect$1.gen(function* () {
 	const socket = yield* SocketServer.SocketServer;
 	yield* restrictSocket(socket.address);
 	return RpcServer.layer(params.rpcs).pipe(Layer.provide(params.handlers), Layer.provide(params.schemaServices), Layer.provide(RpcServer.layerProtocolSocketServer), Layer.provide(RpcSerialization.layerNdjson), Layer.provide(traceContextServer));
 }));
-Blueprint.make()(TypeId$8).steps({
+Blueprint.make()(TypeId$7).steps({
 	steps: {},
 	targets: { layer: workerServerLayerOf }
 }).is;
@@ -1320,8 +1327,8 @@ var Worker_exports = /* @__PURE__ */ __exportAll$1({
 });
 //#endregion
 //#region src/spawned-socket-worker.handle.ts
-const TypeId$7 = Symbol.for("~systemfsoftware/stryker-js/SpawnedSocketWorker");
-const SpawnedSocketWorker = Handle.make()(TypeId$7);
+const TypeId$6 = Symbol.for("~systemfsoftware/stryker-js/SpawnedSocketWorker");
+const SpawnedSocketWorker = Handle.make()(TypeId$6);
 SpawnedSocketWorker.is;
 const make$2 = (worker) => SpawnedSocketWorker.make({
 	pid: worker.pid,
@@ -1333,9 +1340,9 @@ const clientLayer = (self) => SpawnedSocketWorker.slot(self).clientLayer;
 var WorkerLauncher = class extends Context.Service()("@systemfsoftware/stryker-js/WorkerLauncher.service/WorkerLauncher") {};
 //#endregion
 //#region src/worker-client.blueprint.ts
-const TypeId$6 = Symbol.for("~systemfsoftware/stryker-js/WorkerClient");
+const TypeId$5 = Symbol.for("~systemfsoftware/stryker-js/WorkerClient");
 const connectRetry = Schedule.max([Schedule.spaced(50), Schedule.recurs(100)]);
-const scopedOf$2 = (params) => Effect$1.gen(function* () {
+const scopedOf$1 = (params) => Effect$1.gen(function* () {
 	const launcher = yield* WorkerLauncher;
 	const optionsJson = yield* S.encodeEffect(Worker_exports.WorkerOptionsWire)(params.options).pipe(Effect$1.orDie);
 	const worker = yield* launcher.spawn({
@@ -1350,9 +1357,9 @@ const scopedOf$2 = (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({
+const WorkerClients = () => Blueprint.make()(TypeId$5).steps({
 	steps: {},
-	targets: { scoped: scopedOf$2 }
+	targets: { scoped: scopedOf$1 }
 });
 const makeWorkerClient = (params) => WorkerClients().of(params).scoped;
 const ReporterStageTypeId = Symbol.for("@systemfsoftware/stryker-js/ReporterStage");
@@ -1702,7 +1709,10 @@ var VerdictEnvelope = class VerdictEnvelope extends S.Class("VerdictEnvelope")({
 			runId,
 			mode,
 			signal,
-			score: Option$1.getOrNull(Option$1.filter(Option$1.some(metrics.mutationScore), (score) => metrics.totalMutants > 0 && Number.isFinite(score))),
+			score: Report_exports.MutationScore.match(metrics.mutationScore, {
+				Scored: ({ percentage }) => percentage,
+				Unscored: () => null
+			}),
 			thresholds: {
 				high: report.thresholds.high,
 				low: report.thresholds.low,
@@ -1740,7 +1750,7 @@ var RunEvents = class extends Context.Service()("@systemfsoftware/stryker-js/run
 var RunIdentity = class extends Context.Service()("@systemfsoftware/stryker-js/run-events.service/RunIdentity") {};
 //#endregion
 //#region package.json
-var version = "12.0.0";
+var version = "12.1.1";
 //#endregion
 //#region src/stryker-package.schema.ts
 var StrykerPackage = class extends S.Class("StrykerPackage")({
@@ -2032,22 +2042,28 @@ const mutationTestReport = (deps, input) => (results) => Effect$1.gen(function*
 		identities
 	};
 });
-const determineExitCode = (input) => (metrics) => Effect$1.gen(function* () {
-	const { mutationScore } = metrics.metrics;
+const determineExitCode = (input) => (metrics) => {
 	const breaking = input.options.thresholds.break;
-	const formattedScore = mutationScore.toFixed(2);
-	return yield* Option$1.match(Option$1.fromNullishOr(Result.match(classifyExit(ClassifyExitCommand.make({
+	const score = metrics.metrics.mutationScore;
+	const failure = Option$1.fromNullishOr(Result.match(classifyExit(ClassifyExitCommand.make({
 		pending: [],
-		score: mutationScore,
+		score,
 		breakingThreshold: breaking
 	})), {
 		onFailure: (refused) => refused,
 		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("ExitVerdictFailed", () => "VerdictFail"), Match.orElse(() => null))
-	})), {
-		onNone: () => Effect$1.map(Match.value(breaking).pipe(Match.when(null, () => Effect$1.logDebug("No breaking threshold configured. Won't fail the build no matter how low your mutation score is. Set `thresholds.break` to change this behavior.")), Match.orElse((threshold) => Effect$1.logInfo(`Final mutation score of ${formattedScore} is greater than or equal to break threshold ${String(threshold)}`))), () => null),
-		onSome: (failure) => Effect$1.map(Effect$1.andThen(Effect$1.logError(`Final mutation score ${formattedScore} under breaking threshold ${String(breaking)}, setting exit code to 1 (failure).`), Effect$1.logInfo("(improve mutation score or set `thresholds.break = null` to prevent this error in the future)")), () => failure)
+	}));
+	return Report_exports.MutationScore.match(score, {
+		Scored: ({ percentage }) => Option$1.match(failure, {
+			onNone: () => Effect$1.as(logScoredPass(breaking, percentage), null),
+			onSome: (exitClass) => Effect$1.as(logBroken(breaking, percentage), exitClass)
+		}),
+		Unscored: () => Effect$1.as(logUnscored(breaking), Option$1.getOrNull(failure))
 	});
-});
+};
+const logScoredPass = (breaking, percentage) => Match.value(breaking).pipe(Match.when(null, () => Effect$1.logDebug("No breaking threshold configured. Won't fail the build no matter how low your mutation score is. Set `thresholds.break` to change this behavior.")), Match.orElse((threshold) => Effect$1.logInfo(`Final mutation score of ${percentage.toFixed(2)} is greater than or equal to break threshold ${String(threshold)}`)));
+const logUnscored = (breaking) => Match.value(breaking).pipe(Match.when(null, () => Effect$1.void), Match.orElse((threshold) => Effect$1.logInfo(`No valid mutant was tested, so there is no mutation score to hold against break threshold ${String(threshold)}`)));
+const logBroken = (breaking, percentage) => Effect$1.andThen(Effect$1.logError(`Final mutation score ${percentage.toFixed(2)} under breaking threshold ${String(breaking)}, setting exit code to 1 (failure).`), Effect$1.logInfo("(improve mutation score or set `thresholds.break = null` to prevent this error in the future)"));
 const emitVerdict = (deps, input) => (report) => Effect$1.gen(function* () {
 	const envelope = VerdictEnvelope.build(report, input.resolvedMode.mode, input.resolvedMode.signal, input.runId, input.basePath, deps.path);
 	yield* Queue.offer(deps.events, VerdictReached.make({
@@ -2079,7 +2095,7 @@ const reportAll = (deps, input) => Effect$1.gen(function* () {
 	const verdict = yield* determineExitCode(input)(metrics);
 	const finalVerdict = Result.match(classifyExit(ClassifyExitCommand.make({
 		pending: [verdict, terminalDrain].filter((candidate) => candidate !== null),
-		score: null,
+		score: Report_exports.MutationScore.cases.Unscored.make({}),
 		breakingThreshold: null
 	})), {
 		onFailure: (refused) => refused,
@@ -2431,8 +2447,12 @@ const mutantReportSection = (report, metrics, render) => Boolean$1.match(render.
 	},
 	onFalse: () => EMPTY_SECTIONS
 });
+const hasFullScore = (metrics) => Match.valueTags(metrics.mutationScore, {
+	Scored: ({ percentage }) => percentage === 100,
+	Unscored: () => false
+});
 const partialScoresVisible = (metrics, render) => Boolean$1.match(render.skipFull, {
-	onTrue: () => metrics.childResults.some((child) => child.metrics.mutationScore !== 100),
+	onTrue: () => metrics.childResults.some((child) => !hasFullScore(child.metrics)),
 	onFalse: () => true
 });
 const drawsScoreTable = (metrics, render) => Boolean$1.match(render.reportScoreTable, {
@@ -2440,14 +2460,14 @@ const drawsScoreTable = (metrics, render) => Boolean$1.match(render.reportScoreT
 	onFalse: () => false
 });
 const mutationScoreOf = (scoreType, metrics) => Match.value(scoreType).pipe(Match.when("total", () => metrics.mutationScore), Match.when("covered", () => metrics.mutationScoreBasedOnCoveredCode), Match.exhaustive);
-const scoreText = (scoreType, row) => {
-	const score = mutationScoreOf(scoreType, row.metrics);
-	return Boolean$1.match(Number.isNaN(score), {
-		onTrue: () => "n/a",
-		onFalse: () => score.toFixed(2)
-	});
-};
-const thresholdTone = (thresholds, score) => Match.value(score).pipe(Match.when((present) => Number.isNaN(present), () => "muted"), Match.when((present) => present >= thresholds.high, () => "positive"), Match.when((present) => present >= thresholds.low, () => "warning"), Match.orElse(() => "negative"));
+const scoreText = (scoreType, row) => Match.valueTags(mutationScoreOf(scoreType, row.metrics), {
+	Scored: ({ percentage }) => percentage.toFixed(2),
+	Unscored: () => "n/a"
+});
+const thresholdTone = (thresholds, score) => Match.valueTags(score, {
+	Scored: ({ percentage }) => Match.value(percentage).pipe(Match.when((value) => value >= thresholds.high, () => "positive"), Match.when((value) => value >= thresholds.low, () => "warning"), Match.orElse(() => "negative")),
+	Unscored: () => "muted"
+});
 const scoreTone = (thresholds, scoreType, allowColor) => Boolean$1.match(allowColor, {
 	onTrue: () => (row) => thresholdTone(thresholds, mutationScoreOf(scoreType, row.metrics)),
 	onFalse: () => () => "plain"
@@ -2544,7 +2564,7 @@ const createColumns = (metricsResult, render) => [
 const leafRules = (columns) => columns.flatMap((column) => column.leaves.map((leaf) => [rule("-", slotWidthOf(leaf))]));
 const leafHeaders = (columns) => columns.flatMap((column) => column.leaves.map((leaf) => placedLine(leaf.header, leaf.style, leaf.netWidth)));
 const fullRowVisible = (render, row) => Boolean$1.match(render.skipFull, {
-	onTrue: () => row.metrics.mutationScore !== 100,
+	onTrue: () => !hasFullScore(row.metrics),
 	onFalse: () => true
 });
 const bodyRow = (columns, row, ancestorCount) => rowOfLines(columns.flatMap((column) => column.leaves.map((leaf) => [placedCell(leaf.cell(row, ancestorCount), leaf.style, leaf.netWidth, leaf.tone(row))])));
@@ -2650,41 +2670,33 @@ const readClearTextReport = (input) => Effect$1.map(Stream.fromAsyncIterable(inp
 }));
 const tint = (color, text) => `${AnsiCode.fields[color].literal}${text}${AnsiCode.fields.reset.literal}`;
 const TINT_BY_TONE = {
-	"plain": (text) => text,
-	"identifier": (text) => tint("cyan", text),
-	"emphasis": (text) => tint("yellow", text),
-	"positive": (text) => tint("green", text),
-	"warning": (text) => tint("yellow", text),
-	"negative": (text) => tint("red", text),
-	"muted": (text) => tint("grey", text)
-};
-const runsMergeable = (left, right) => Arr.every([
-	left.tone === right.tone,
-	left.leftPad === right.leftPad,
-	left.rightPad === right.rightPad,
-	left.repeat === 1,
-	right.repeat === 1
-], (holds) => holds);
-const mergeInto = (runs, span) => Option$1.match(Arr.last(runs), {
-	onNone: () => [span],
-	onSome: (last) => Boolean$1.match(runsMergeable(last, span), {
-		onTrue: () => [...runs.slice(0, -1), {
-			...last,
-			text: `${last.text}${span.text}`
-		}],
-		onFalse: () => [...runs, span]
-	})
+	plain: (text) => text,
+	identifier: (text) => tint("cyan", text),
+	emphasis: (text) => tint("yellow", text),
+	positive: (text) => tint("green", text),
+	warning: (text) => tint("yellow", text),
+	negative: (text) => tint("red", text),
+	muted: (text) => tint("grey", text)
+};
+const bytesOf = (span) => `${" ".repeat(span.leftPad)}${span.text.repeat(span.repeat)}${" ".repeat(span.rightPad)}`;
+const appendSpan = (runs, span) => Option$1.match(Option$1.filter(Arr.last(runs), (last) => last.tone === span.tone), {
+	onNone: () => [...runs, {
+		tone: span.tone,
+		bytes: bytesOf(span)
+	}],
+	onSome: (last) => [...runs.slice(0, -1), {
+		tone: last.tone,
+		bytes: `${last.bytes}${bytesOf(span)}`
+	}]
 });
-const runsOf = (line) => Arr.reduce(line, [], mergeInto);
-const renderSpan = (span) => TINT_BY_TONE[span.tone](`${" ".repeat(span.leftPad)}${span.text.repeat(span.repeat)}${" ".repeat(span.rightPad)}`);
-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 renderLine = (line) => Arr.reduce(line, Arr.empty(), appendSpan).map((run) => TINT_BY_TONE[run.tone](run.bytes)).join("");
+const renderChunk = (chunk) => `${chunk.map(renderLine).join("\n")}\n`;
+const writeChunks = (output, channel, chunks) => Effect$1.mapError(output.write(channel, chunks.map(renderChunk)), failAsClearText);
 const clearTextReportCell = Sandwich.named("stryker.report.clearText")(readClearTextReport).decide(renderClearTextReport).write({
-	ClearTextReportRendered: (rendered, _raw) => Effect$1.gen(function* () {
+	ClearTextReportRendered: (rendered) => Effect$1.gen(function* () {
 		const output = yield* ReporterOutput;
 		yield* writeChunks(output, "stdout", rendered.stdout);
-		yield* Effect$1.forEach(rendered.stderr, (chunk) => writeChunks(output, "stderr", [chunk]), { discard: true });
+		yield* writeChunks(output, "stderr", rendered.stderr);
 	}),
 	ClearTextReportSuppressed: () => Effect$1.void,
 	CommandRejected: ({ issue }) => Effect$1.fail(failAsClearText(issue))
@@ -3697,7 +3709,7 @@ const classifyWorkerExit = Workflow.make({
 });
 //#endregion
 //#region src/worker-protocol.blueprint.ts
-const TypeId$5 = Symbol.for("~systemfsoftware/stryker-js/WorkerProtocol");
+const TypeId$4 = Symbol.for("~systemfsoftware/stryker-js/WorkerProtocol");
 const droppedConnection = RpcClientError.make({ reason: Socket.SocketReadError.make({ cause: /* @__PURE__ */ new Error("worker connection dropped with the request in flight") }) });
 const layerOf = (socket) => Layer.effect(RpcClient.Protocol, Effect$1.gen(function* () {
 	const handlers = MutableHashMap.empty();
@@ -3738,7 +3750,7 @@ const layerOf = (socket) => Layer.effect(RpcClient.Protocol, Effect$1.gen(functi
 		send: (clientId, request, transferables) => track(clientId, request).pipe(Effect$1.andThen(inner.send(clientId, request, transferables)))
 	});
 }));
-const WorkerProtocol = Blueprint.make()(TypeId$5).steps({
+const WorkerProtocol = Blueprint.make()(TypeId$4).steps({
 	steps: {},
 	targets: { layer: (spec) => layerOf(spec.socket) }
 });
@@ -3746,7 +3758,7 @@ const layerWorkerProtocol = (socket) => WorkerProtocol.of({ socket }).layer;
 //#endregion
 //#region src/drivers/node.ts
 const restrictToOwnerOrWarn = (fs, file) => fs.chmod(file, 384).pipe(Effect$1.tapError((cause) => Effect$1.logWarning(`Could not restrict "${file}" to its owner; the worker directory's own mode still protects it.`).pipe(Effect$1.annotateLogs("cause", cause))), Effect$1.catchTag("PlatformError", () => Effect$1.void));
-const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.gen(function* () {
+const nodeWorkerLauncherLayer = (childEnv) => Layer.effect(WorkerLauncher, Effect$1.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -3765,6 +3777,7 @@ const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.gen(functi
 			env: {
 				STRYKER_WORKER_DIR: workerDir,
 				STRYKER_SOCKET: socketPath,
+				...childEnv,
 				...params.env
 			},
 			stderr: "inherit"
@@ -3804,7 +3817,8 @@ const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.gen(functi
 const nodeFsPathLayer$1 = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer);
 const nodeSpawnerLayer = NodeChildProcessSpawner.layer.pipe(Layer.provide(nodeFsPathLayer$1));
 const nodeBase = Layer.mergeAll(nodeFsPathLayer$1, nodeSpawnerLayer, NodeStdio.layer);
-const nodePlatformLayer = Layer.mergeAll(nodeWorkerLauncherLayer.pipe(Layer.provide(Layer.merge(nodeBase, NodeCrypto.layer))), nodeBase);
+const makeNodePlatformLayer = (options) => Layer.mergeAll(nodeWorkerLauncherLayer(options.childEnv).pipe(Layer.provide(Layer.merge(nodeBase, NodeCrypto.layer))), nodeBase);
+const nodePlatformLayer = makeNodePlatformLayer({ childEnv: {} });
 //#endregion
 //#region src/IncrementalDiff.schema.ts
 const PositionSchema$1 = S.Struct({
@@ -4146,138 +4160,6 @@ const admitIncrementalReport = Workflow.make({
 	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;
-const messageOf$1 = (cause) => cause instanceof Error ? cause.message : new Error("the vm test runner failed", { cause }).message;
-const testResultOf = (test) => {
-	const base = {
-		id: test.id,
-		name: test.name,
-		timeSpentMs: test.timeSpentMs
-	};
-	return Match.value(test.status).pipe(Match.when("failed", () => ({
-		...base,
-		status: "failed",
-		failureMessage: test.failureMessage ?? ""
-	})), Match.when("skipped", () => ({
-		...base,
-		status: "skipped"
-	})), Match.orElse(() => ({
-		...base,
-		status: "success"
-	})));
-};
-const dryRunResultOf = (response) => {
-	const tests = response.tests.map(testResultOf);
-	return Option$1.match(Option$1.fromUndefinedOr(response.mutantCoverage), {
-		onNone: () => ({
-			status: "complete",
-			tests
-		}),
-		onSome: (mutantCoverage) => ({
-			status: "complete",
-			tests,
-			mutantCoverage
-		})
-	});
-};
-const respond = (response) => Match.value(response).pipe(Match.discriminator("status")("init-failed", (failed) => Effect$1.fail(TestRunner_exports.TestRunnerFailed.make({
-	runnerName: "vm",
-	phase: "init",
-	cause: failed.message
-}))), Match.discriminator("status")("timeout", () => Effect$1.succeed({ status: "timeout" })), Match.discriminator("status")("error", (errored) => Effect$1.succeed({
-	status: "error",
-	errorMessage: errored.errorMessage
-})), Match.discriminator("status")("complete", (complete) => Effect$1.succeed(dryRunResultOf(complete))), Match.exhaustive);
-const pooledVmRunner = (config, scope) => {
-	let client;
-	let sessionTestFiles = config.testFiles;
-	const sessionOptions = () => ({
-		sandboxWorkingDirectory: config.sandboxWorkingDirectory,
-		testFiles: sessionTestFiles
-	});
-	const spawnClient = Effect$1.try({
-		try: () => {
-			const spawned = Session.createVmWorkerClient(sessionOptions(), { onExit: () => {
-				if (client === spawned) client = void 0;
-			} });
-			return spawned;
-		},
-		catch: (cause) => TestRunner_exports.TestRunnerFailed.make({
-			runnerName: "vm",
-			phase: "init",
-			cause: `the vm test runner could not start its worker: ${messageOf$1(cause)}`
-		})
-	});
-	const dropClient = Effect$1.suspend(() => {
-		const current = client;
-		client = void 0;
-		return current === void 0 ? Effect$1.void : Effect$1.promise(() => current.terminate());
-	});
-	const run = (request) => Effect$1.gen(function* () {
-		if (client === void 0) {
-			const spawned = yield* spawnClient;
-			yield* Scope.addFinalizer(scope, Effect$1.promise(() => spawned.terminate()));
-			client = spawned;
-		}
-		const current = client;
-		const answer = yield* Effect$1.tryPromise({
-			try: () => current.run(request),
-			catch: (cause) => ({
-				status: "error",
-				errorMessage: messageOf$1(cause)
-			})
-		}).pipe(Effect$1.catch((failed) => Effect$1.succeed(failed)), Effect$1.timeoutOrElse({
-			duration: request.timeoutMs + HOST_TIMEOUT_SLACK_MS,
-			orElse: () => dropClient.pipe(Effect$1.as({ status: "timeout" }))
-		}));
-		return yield* respond(answer);
-	}).pipe(Effect$1.onInterrupt(() => dropClient));
-	const shouldAdoptTestFiles = () => config.testFiles.length === 0 && client === void 0;
-	const adoptedTestFiles = (testFiles) => testFiles ?? [];
-	const testFilterFieldOf = (testFilter) => testFilter === void 0 ? {} : { testFilter: [...testFilter] };
-	const hitLimitFieldOf = (hitLimit) => hitLimit === void 0 ? {} : { hitLimit };
-	const mutantRequestOf = (options) => ({
-		kind: "mutant",
-		timeoutMs: options.timeout,
-		activeMutantId: String(options.activeMutant.id),
-		...testFilterFieldOf(options.testFilter),
-		...hitLimitFieldOf(options.hitLimit),
-		reloadEnvironment: options.reloadEnvironment
-	});
-	return make$3({
-		capabilities: Effect$1.succeed(vmRunnerCapabilities),
-		init: Effect$1.void,
-		dryRun: (options) => {
-			if (shouldAdoptTestFiles()) sessionTestFiles = adoptedTestFiles(options.testFiles);
-			return run({
-				kind: "dry",
-				timeoutMs: options.timeout,
-				reloadEnvironment: true
-			});
-		},
-		mutantRun: (options) => run(mutantRequestOf(options)).pipe(Effect$1.map((dryRunResult) => interpretDryRunResult(InterpretDryRunResultCommand.make({ dryRunResult }))), Effect$1.flatMap((decided) => Result.match(decided, {
-			onFailure: (failure) => Effect$1.fail(failure),
-			onSuccess: (decision) => Effect$1.succeed(decision.asResult)
-		})), Effect$1.catchTag("TestRunnerFailed", (failure) => Effect$1.succeed({
-			status: "error",
-			errorMessage: failure.cause
-		})))
-	});
-};
-const 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.parts.ts
 const ALWAYS_IGNORE = Object.freeze([
 	"node_modules",
@@ -4290,23 +4172,9 @@ const ALWAYS_IGNORE = Object.freeze([
 ]);
 const IGNORE_PATTERN_CHARACTER = "!";
 const DEFAULT_GLOB = "**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}";
-const VITEST_DEFAULT_TEST_FILE_PATTERNS = ["**/*.{test,spec}.{js,jsx,ts,tsx,cjs,cjsx,cts,ctsx,mjs,mjsx,mts,mtsx}"];
-const defaultTestFileIgnores = (tempDirName) => [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/.{idea,git,cache,output,temp}/**",
-	`**/${tempDirName}/**`
-];
-const shouldDiscoverTestFiles = (options) => options.testFiles.length === 0 && isVmRunner(options.testRunner);
-const testFileSelectionOf = (options) => Boolean.match(shouldDiscoverTestFiles(options), {
-	onTrue: () => ({
-		testFilePatterns: VITEST_DEFAULT_TEST_FILE_PATTERNS,
-		testFileIgnores: defaultTestFileIgnores(options.tempDirName)
-	}),
-	onFalse: () => ({
-		testFilePatterns: options.testFiles,
-		testFileIgnores: []
-	})
+const testFileSelectionOf = (options) => ({
+	testFilePatterns: options.testFiles,
+	testFileIgnores: []
 });
 const normalizeFileName = (value) => value.replace(/\\/g, "/");
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -4818,8 +4686,11 @@ const formatTotal = (total) => Option$1.match(Option$1.fromNullishOr(total), {
 	onSome: (val) => String(val)
 });
 const formatStderrEvent = (event) => Match.value(event).pipe(Match.tag("plan", (e) => `plan ${e.total} mutants`), Match.tag("phase", (e) => `phase ${e.phase}`), Match.tag("tick", (e) => `${e.completed}/${formatTotal(e.total)} elapsed ${e.elapsedMs}ms`), Match.tag("verdict", (e) => `score ${formatScore(e.score)} killed ${e.counts.killed} survived ${e.counts.survived}`), Match.tag("error", (e) => `error ${e.error}`), Match.tag("stream", () => null), Match.tag("mutant", () => null), Match.tag("help", () => null), Match.tag("plugins", () => null), Match.tag("formats", () => null), Match.tag("skipped", () => null), Match.exhaustive);
-const stderrLineFor = (state, event) => Match.value(state.terminalSeen).pipe(Match.when(true, () => null), Match.when(false, () => formatStderrEvent(event)), Match.exhaustive);
-const shouldFrame = (state) => Match.value(state.mode).pipe(Match.when("machine", () => !state.terminalSeen), Match.when("human", () => false), Match.exhaustive);
+const stderrLineFor = (state, event) => Boolean$1.match(Boolean$1.and(state.mode === "human", !state.terminalSeen), {
+	onTrue: () => formatStderrEvent(event),
+	onFalse: () => null
+});
+const shouldFrame = (state) => !state.terminalSeen;
 const decideFrame = (command) => {
 	const nextState = noteState(command.state, command.event);
 	const stderrLine = stderrLineFor(command.state, command.event);
@@ -4878,7 +4749,10 @@ const formatTemplate = (template, args) => {
 };
 const headOf = (args) => Option$1.fromNullishOr(args[0]);
 const formatArgs = (args) => Option$1.match(Option$1.filter(headOf(args), Predicate$1.isString), {
-	onSome: (first) => formatTemplate(first, args.slice(1)),
+	onSome: (first) => Boolean$1.match(args.length === 1, {
+		onTrue: () => first,
+		onFalse: () => formatTemplate(first, args.slice(1))
+	}),
 	onNone: () => args.map(inspectValue).join(" ")
 });
 const DEFAULT_CONSOLE_LABEL = "default";
@@ -5530,7 +5404,7 @@ var RunEventDrain = class RunEventDrain extends Context.Service()("@systemfsoftw
 	static layer = Layer.effect(RunEventDrain, Effect$1.gen(function* () {
 		const stdio = yield* Stdio.Stdio;
 		return RunEventDrain.of({
-			drainFramed: (framed) => drainOf(stdio, framed),
+			drainFramed: (framed, toStdout) => drainOf(stdio, framed, toStdout),
 			setProgressStreamFile: () => Effect$1.void
 		});
 	}));
@@ -5543,25 +5417,29 @@ var RunEventDrain = class RunEventDrain extends Context.Service()("@systemfsoftw
 };
 const RunEventDrainLive = RunEventDrain.layer;
 const encodeUtf8 = (line) => new TextEncoder().encode(line);
-const drainStdoutAndFile = (fs, path, stdio, fileName, framed) => Effect$1.gen(function* () {
+const runToSink = (stdio, lines, toStdout) => Boolean$1.match(toStdout, {
+	onTrue: () => Stream.run(lines, stdio.stdout({ endOnDone: true })),
+	onFalse: () => Stream.runDrain(lines)
+});
+const drainToSinks = (fs, path, stdio, fileName, toStdout, framed) => Effect$1.gen(function* () {
 	yield* fs.makeDirectory(path.dirname(fileName), { recursive: true });
 	yield* Effect$1.scoped(Effect$1.gen(function* () {
 		const handle = yield* fs.open(fileName, { flag: "w" });
 		const withFile = framed.pipe(Stream.tap((line) => handle.writeAll(encodeUtf8(line)).pipe(Effect$1.flatMap(() => handle.sync))));
-		yield* Stream.run(withFile, stdio.stdout({ endOnDone: true })).pipe(Effect$1.ignore);
+		yield* runToSink(stdio, withFile, toStdout).pipe(Effect$1.ignore);
 	}));
 }).pipe(Effect$1.orDie);
 const drainFileOf = (stdio, fs, path) => Effect$1.gen(function* () {
 	const fileNameRef = yield* Ref.make(DEFAULT_PROGRESS_STREAM_FILE);
 	return RunEventDrain.of({
-		drainFramed: (framed) => Effect$1.gen(function* () {
+		drainFramed: (framed, toStdout) => Effect$1.gen(function* () {
 			const fileName = yield* Ref.get(fileNameRef);
-			yield* drainStdoutAndFile(fs, path, stdio, fileName, framed);
+			yield* drainToSinks(fs, path, stdio, fileName, toStdout, framed);
 		}).pipe(Effect$1.tapCause((cause) => Effect$1.logError("stryker.output.drain_file_failed", cause)), Effect$1.ignoreCause),
 		setProgressStreamFile: (fileName) => Ref.set(fileNameRef, fileName)
 	});
 });
-const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect$1.withSpan("stryker.output.drain"), Effect$1.tapCause((cause) => Effect$1.logError("stryker.output.drain_failed", cause)), Effect$1.ignoreCause);
+const drainOf = (stdio, framed, toStdout) => runToSink(stdio, framed, toStdout).pipe(Effect$1.withSpan("stryker.output.drain"), Effect$1.tapCause((cause) => Effect$1.logError("stryker.output.drain_failed", cause)), Effect$1.ignoreCause);
 const writeStderr = (stdio, line) => Stream.run(Stream.succeed(`${line}\n`), stdio.stderr({ endOnDone: false })).pipe(Effect$1.ignore);
 const emitNullScoreVerdict = (params) => {
 	const { stream, mode, thresholds, basePath, pathService } = params;
@@ -5708,7 +5586,8 @@ const makeRunEventStream = (resolved) => Effect$1.gen(function* () {
 		open: Effect$1.gen(function* () {
 			yield* Option$1.match(yield* Ref.get(drainFiberRef), {
 				onNone: () => Effect$1.gen(function* () {
-					const drainFiber = yield* drain.drainFramed(framed).pipe(Effect$1.forkDetach);
+					const mode = (yield* Ref.get(stateRef)).mode;
+					const drainFiber = yield* drain.drainFramed(framed, mode === "machine").pipe(Effect$1.forkDetach);
 					yield* Ref.set(drainFiberRef, Option$1.some(drainFiber));
 				}),
 				onSome: () => Effect$1.void
@@ -5730,7 +5609,11 @@ const makeRunEventStream = (resolved) => Effect$1.gen(function* () {
 var DryRunError = class extends S.TaggedError()("DryRunError", {
 	stage: S.Literals(["dryRun", "dryRunNoTests"]),
 	reason: S.String
-}) {};
+}) {
+	get message() {
+		return this.reason;
+	}
+};
 var FailedTestSummary = class extends S.Class("FailedTestSummary")({
 	name: S.String,
 	failureMessage: S.String
@@ -5865,6 +5748,15 @@ const originalFileFor = dual(2, (self, sandboxFileName) => {
 	const slot = SandboxHandle.slot(self);
 	return originalFileNameOf(sandboxFileName, self.workingDirectory, slot.basePath, slot.pathService);
 });
+const VM_RUNNER_SPECIFIER = "@systemfsoftware/stryker-js-vm-runner";
+const vmRunnerOptions = { pool: "threads" };
+const vmRunnerPluginUrl = () => import.meta.resolve(VM_RUNNER_SPECIFIER);
+const isVmRunner = (name) => typeof name === "string" && name.toLowerCase() === "vm";
+const vmTestRunnerConfig = () => ({
+	plugin: vmRunnerPluginUrl(),
+	options: { ...vmRunnerOptions }
+});
+const testRunnerConfigOf = (configured) => Match.value(configured).pipe(Match.when(isVmRunner, vmTestRunnerConfig), Match.orElse((unchanged) => unchanged));
 //#endregion
 //#region src/TestRunner.blueprint.ts
 const TypeId$2 = Symbol.for("~systemfsoftware/stryker-js/TestRunner");
@@ -5891,11 +5783,15 @@ const toRunnerFailure = (runnerName, phase) => (error) => Match.value(error).pip
 * can see.
 */
 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 options = {
+		...params.options,
+		testRunner: testRunnerConfigOf(params.options.testRunner)
+	};
+	const runnerName = Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
+	const execArgv = Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => Match.value(runner.nodeArgs).pipe(Match.when(Match.undefined, () => options.testRunnerNodeArgs), Match.orElse((args) => args))), Match.orElse(() => options.testRunnerNodeArgs));
 	const client = yield* makeWorkerClient({
 		rpcs: Plugin_exports.TestRunnerRpcs,
-		options: params.options,
+		options,
 		entrypoint: params.workerEntrypoint,
 		workingDirectory: params.sandboxWorkingDirectory,
 		execArgv: [...execArgv],
@@ -5919,10 +5815,7 @@ const TestRunners = Blueprint.make()(TypeId$2).steps({
 });
 const makeChildProcessTestRunner = (params) => TestRunners.of(params).scoped;
 const commandRunnerEffect = (context) => ChildProcessSpawner.ChildProcessSpawner.pipe(Effect$1.map((spawner) => commandRunner(context, spawner).pipe(withTimeout, withRetry)));
-const inProcessRunner = (context) => Match.value(context.options.testRunner).pipe(Match.when(isCommandRunner, () => Option$1.some(commandRunnerEffect(context))), Match.when(isVmRunner, () => Option$1.some(vmTestRunner({
-	testFiles: context.testFiles,
-	sandboxWorkingDirectory: context.sandboxWorkingDirectory
-}))), Match.orElse(() => Option$1.none()));
+const inProcessRunner = (context) => Match.value(context.options.testRunner).pipe(Match.when(isCommandRunner, () => Option$1.some(commandRunnerEffect(context))), Match.orElse(() => Option$1.none()));
 const buildTestRunner = dual(2, (context, childProcessRunner) => Option$1.match(inProcessRunner(context), {
 	onSome: (inProcess) => inProcess,
 	onNone: () => Effect$1.gen(function* () {
@@ -6081,7 +5974,7 @@ const resolveConfiguredPlugin = Workflow.make({
 //#endregion
 //#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 configuredPluginOf$1 = (configured) => Match.value(testRunnerConfigOf(configured)).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
 const workerSpawnOf$1 = (stage, loaded, kind, configured) => Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
 	sources: loaded.pluginSources,
 	kind,
@@ -6095,7 +5988,11 @@ const optionalSandboxPathsOf = (command) => Boolean$1.match(command.options.test
 	onTrue: () => Result.succeed(void 0),
 	onFalse: () => sandboxPathsOf(command.sandbox, command.project.testFiles)
 });
-const buildDryRunFiles = (command) => Result.flatMap(sandboxPathsOf(command.sandbox, [...MutableHashMap.keys(command.project.filesToMutate)]), (files) => Result.map(optionalSandboxPathsOf(command), (testFiles) => ({
+const mutatedFileNamesOf = (command) => {
+	const mutated = MutableHashSet.fromIterable(command.mutants.map((mutant) => mutant.fileName));
+	return [...MutableHashMap.keys(command.project.filesToMutate)].filter((name) => MutableHashSet.has(mutated, name));
+};
+const buildDryRunFiles = (command) => Result.flatMap(sandboxPathsOf(command.sandbox, mutatedFileNamesOf(command)), (files) => Result.map(optionalSandboxPathsOf(command), (testFiles) => ({
 	files,
 	testFiles
 })));
@@ -6326,14 +6223,11 @@ const dryRunCell = Sandwich.named("stryker.dry_run")(readDryRun).decide(dryRun).
 });
 //#endregion
 //#region src/plan-instrumentation.workflow.ts
-var InstrumentError = class extends S.TaggedError()("InstrumentError", {
-	stage: S.Literal("instrument"),
-	reason: S.String
-}) {};
+const Count = S.Int.check(S.isGreaterThanOrEqualTo(0));
 var InstrumentCommand = class extends S.TaggedClass()("InstrumentCommand", {
-	fileCount: S.Finite,
+	fileCount: Count,
 	inPlace: S.Boolean,
-	pluginCount: S.Finite
+	pluginCount: Count
 }) {
 	static [Workflow.InstrumentationBrand] = {
 		fileCount: "stryker.instrument.file_count",
@@ -6344,32 +6238,28 @@ const InstrumentDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/Instrum
 var InPlaceInstrument = class extends S.TaggedClass()("InPlaceInstrument", {
 	workingDirectoryHint: S.String,
 	backupDirectoryHint: S.String,
-	fileCount: S.Finite
+	fileCount: Count
 }) {
 	[InstrumentDecisionTypeId] = InstrumentDecisionTypeId;
 };
 var EphemeralInstrument = class extends S.TaggedClass()("EphemeralInstrument", {
 	workingDirectoryHint: S.String,
-	fileCount: S.Finite
+	fileCount: Count
 }) {
 	[InstrumentDecisionTypeId] = InstrumentDecisionTypeId;
 };
-const commandShape = (command) => Match.value(command.fileCount === 0).pipe(Match.when(true, () => "empty"), Match.when(false, () => Match.value(command.inPlace).pipe(Match.when(true, () => "inPlace"), Match.when(false, () => "ephemeral"), Match.exhaustive)), Match.exhaustive);
-const decide$3 = (command) => Match.value(commandShape(command)).pipe(Match.when("empty", () => Result.fail(InstrumentError.make({
-	stage: "instrument",
-	reason: "No files to instrument."
-}))), Match.when("inPlace", () => Result.succeed(InPlaceInstrument.make({
+const decide$3 = (command) => Match.value(command.inPlace).pipe(Match.when(true, () => Result.succeed(InPlaceInstrument.make({
 	workingDirectoryHint: "inPlace",
 	backupDirectoryHint: "backup",
 	fileCount: command.fileCount
-}))), Match.when("ephemeral", () => Result.succeed(EphemeralInstrument.make({
+}))), Match.when(false, () => Result.succeed(EphemeralInstrument.make({
 	workingDirectoryHint: "temp",
 	fileCount: command.fileCount
 }))), Match.exhaustive);
 const planInstrumentation = Workflow.make({
 	command: InstrumentCommand,
 	decision: S.Union([InPlaceInstrument, EphemeralInstrument]),
-	error: InstrumentError,
+	error: S.Never,
 	decide: decide$3
 });
 //#endregion
@@ -7117,14 +7007,6 @@ const instrumentCell = Sandwich.named("stryker.instrument")((command) => Effect$
 })).decide(planInstrumentation).write({
 	InPlaceInstrument: (_decision, raw) => writeInstrument(raw),
 	EphemeralInstrument: (_decision, raw) => writeInstrument(raw),
-	InstrumentError: ({ stage, reason }, raw) => enteringInstrumentPhase(raw, Effect$1.fail(StageError.make({
-		stage,
-		reason,
-		cause: InstrumentError.make({
-			stage,
-			reason
-		})
-	}))),
 	CommandRejected: ({ issue }) => Effect$1.fail(StageError.make({
 		stage: "instrument",
 		reason: issue
@@ -7149,7 +7031,11 @@ var MutationTestCommand = class extends S.TaggedClass()("MutationTestCommand", {
 var MutationTestError = class extends S.TaggedError()("MutationTestError", {
 	stage: S.Literal("mutationTest"),
 	reason: S.String
-}) {};
+}) {
+	get message() {
+		return this.reason;
+	}
+};
 const MutationTestDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/MutationTestDecision");
 var MutationTestProceed = class extends S.TaggedClass()("MutationTestProceed", {}) {
 	[MutationTestDecisionTypeId] = MutationTestDecisionTypeId;
@@ -7586,8 +7472,9 @@ const toReportedMutant = (mutant) => Object.assign(mutant, {
 	static: mutant.static
 });
 const CHECKER_ACQUIRE_RETRIES = 2;
+const TEST_RUNNER_POOL_IDLE_TIME_TO_LIVE = Duration.minutes(1);
 const isCheckerCrash = (error) => Match.value(error).pipe(Match.tag("ChildProcessCrashedError", "OutOfMemoryError", () => true), Match.orElse(() => false));
-const configuredPluginOf = (configured) => Match.value(configured).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
+const configuredPluginOf = (configured) => Match.value(testRunnerConfigOf(configured)).pipe(Match.when(Options_exports.isCustomTestRunner, (custom) => ConfiguredPluginModulePath.make({ modulePath: custom.plugin })), Match.orElse((name) => ConfiguredPluginName.make({ name })));
 const workerSpawnOf = (stage, loaded, kind, configured) => Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
 	sources: loaded.pluginSources,
 	kind,
@@ -7781,13 +7668,17 @@ const checkerBreachToStageError = (error) => Match.value(error).pipe(Match.tag("
 	cause: breach
 })), Match.exhaustive);
 const invalidateSlot = (pool, slot, error) => Effect$1.flatMap(Pool.invalidate(pool, slot), () => Effect$1.fail(error));
-const checkSlotPlans = (pool, slot, checker, checkerName, currentPlans) => checkGroupedPlans(checker, checkerName, currentPlans).pipe(Effect$1.catchTags({
-	OutOfMemoryError: (error) => invalidateSlot(pool, slot, error),
-	ChildProcessCrashedError: (error) => invalidateSlot(pool, slot, error),
-	CheckerFailed: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
-	CheckerAnsweredUnrequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
-	CheckerSkippedRequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail)
+const onCheckerSlot = (pool, checkerIndex, run) => Pool.use(pool, (slot) => Option$1.match(Option$1.fromUndefinedOr(slot[checkerIndex]), {
+	onNone: () => Effect$1.die(/* @__PURE__ */ new Error(`checker slot has no entry at index ${checkerIndex}`)),
+	onSome: ({ checker }) => run(checker).pipe(Effect$1.catchTags({
+		OutOfMemoryError: (error) => invalidateSlot(pool, slot, error),
+		ChildProcessCrashedError: (error) => invalidateSlot(pool, slot, error),
+		CheckerFailed: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
+		CheckerAnsweredUnrequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail),
+		CheckerSkippedRequested: (error) => error.pipe(checkerBreachToStageError, Effect$1.fail)
+	}))
 }));
+const checkGroupsConcurrently = (pool, checkerIndex, checkerName, currentPlans) => Effect$1.flatMap(onCheckerSlot(pool, checkerIndex, (checker) => groupPlans(checker, checkerName, currentPlans)), (groups) => Effect$1.map(Effect$1.forEach(groups, (group) => onCheckerSlot(pool, checkerIndex, (checker) => checkPlans(checker, checkerName, group)), { concurrency: "unbounded" }), (perGroup) => perGroup.flat()));
 const isFailedCheck = (check) => check[1].status !== "passed";
 const splitCheckedPlans = (checked, reporting) => {
 	const failures = checked.filter(isFailedCheck);
@@ -7797,18 +7688,15 @@ const splitCheckedPlans = (checked, reporting) => {
 		results
 	}));
 };
-const stepOneChecker = (pool, slot, checker, checkerName, currentPlans, reporting) => checkSlotPlans(pool, slot, checker, checkerName, currentPlans).pipe(Effect$1.flatMap((checked) => splitCheckedPlans(checked, reporting)));
+const stepOneChecker = (pool, checkerIndex, checkerName, currentPlans, reporting) => checkGroupsConcurrently(pool, checkerIndex, checkerName, currentPlans).pipe(Effect$1.flatMap((checked) => splitCheckedPlans(checked, reporting)));
 const emptyRunResults = [];
-const runConfiguredCheckers = (pool, plans, reporting) => Effect$1.scoped(Effect$1.gen(function* () {
-	const slot = yield* Pool.get(pool);
-	return yield* Effect$1.reduce(slot, () => ({
-		passedPlans: plans,
-		checkerResults: emptyRunResults
-	}), (acc, { checkerName, checker }) => Effect$1.map(stepOneChecker(pool, slot, checker, checkerName, acc.passedPlans, reporting), (split) => ({
-		passedPlans: split.passed,
-		checkerResults: [...acc.checkerResults, ...split.results]
-	})));
-}));
+const runConfiguredCheckers = (pool, plans, reporting) => Effect$1.flatMap(Pool.use(pool, (slot) => Effect$1.succeed(slot.map(({ checkerName }) => checkerName))), (checkerNames) => Effect$1.reduce(checkerNames, () => ({
+	passedPlans: plans,
+	checkerResults: emptyRunResults
+}), (acc, checkerName, checkerIndex) => Effect$1.map(stepOneChecker(pool, checkerIndex, checkerName, acc.passedPlans, reporting), (split) => ({
+	passedPlans: split.passed,
+	checkerResults: [...acc.checkerResults, ...split.results]
+}))));
 const checkPlansWithConfiguredCheckers = (checkerPool, plans, reporting) => Option$1.match(Option$1.fromNullishOr(checkerPool), {
 	onNone: () => Effect$1.succeed({
 		passedPlans: plans,
@@ -7816,6 +7704,14 @@ const checkPlansWithConfiguredCheckers = (checkerPool, plans, reporting) => Opti
 	}),
 	onSome: (pool) => runConfiguredCheckers(pool, plans, reporting)
 });
+const checkerResourcesInOwnScope = (acquire) => Effect$1.gen(function* () {
+	const checkerScope = yield* Scope.make();
+	yield* Effect$1.addFinalizer(() => Scope.close(checkerScope, Exit.void));
+	return {
+		resources: yield* acquire.pipe(Scope.provide(checkerScope)),
+		releaseInBackground: Scope.close(checkerScope, Exit.void).pipe(Effect$1.forkScoped({ uninterruptible: true }))
+	};
+});
 const isPlannable = (mutant) => Result.isSuccess(S.decodeResult(CheckerMutantFromMutant)(mutant));
 const DROPPED_IDS_IN_WARNING = 5;
 const configuredTestFilesOf = (run) => run.options.testFiles.length === 0 ? [] : run.project.testFiles;
@@ -7861,14 +7757,15 @@ const writeMutationTestDryRunOnly = Effect$1.gen(function* () {
 });
 const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 	const prev = raw.prev;
+	const testRunnerCapacity = prev.concurrency.testRunners + prev.concurrency.checkers;
 	const { dropped, plannable: plannableMutants } = partitionPlannable(prev.mutants);
 	yield* reportDroppedMutants(dropped);
 	yield* phaseEntered("mutation-test");
 	const idGenerator = yield* IdGenerator;
 	const env = yield* RunEnvironment;
-	const checkerPool = yield* makeCheckerPool(prev, env.basePath);
+	const scopedCheckers = yield* checkerResourcesInOwnScope(makeCheckerPool(prev, env.basePath));
 	const testFiles = yield* Effect$1.map(sandboxFilesOf(prev.sandbox, configuredTestFilesOf(prev)), (pairs) => pairs.map(([, sandboxFileName]) => sandboxFileName));
-	const testRunnerPool = yield* Pool.make({
+	const testRunnerPool = yield* Pool.makeWithTTL({
 		acquire: buildTestRunner({
 			options: prev.options,
 			fileDescriptions: prev.project.fileDescriptions,
@@ -7886,7 +7783,9 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 				idGenerator
 			})));
 		})),
-		size: prev.concurrency.testRunners
+		min: prev.concurrency.testRunners,
+		max: testRunnerCapacity,
+		timeToLive: TEST_RUNNER_POOL_IDLE_TIME_TO_LIVE
 	});
 	const reporting = yield* MutationReporting;
 	const sandboxFileByName = Object.fromEntries(yield* sandboxFilesOf(prev.sandbox, [...MutableHashMap.keys(prev.project.filesToMutate)]));
@@ -7929,7 +7828,8 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 	})).pipe(Effect$1.ignoreCause);
 	const progressQueue = yield* RunEvents;
 	yield* Queue.offer(progressQueue, PlanKnown.make({ total: allPlansForReporter.length + noCoverageResults.length }));
-	const { passedPlans, checkerResults } = yield* checkPlansWithConfiguredCheckers(checkerPool, sortedPlans, reporting);
+	const { passedPlans, checkerResults } = yield* checkPlansWithConfiguredCheckers(scopedCheckers.resources, sortedPlans, reporting);
+	const checkerRelease = yield* scopedCheckers.releaseInBackground;
 	const testRunnerStream = Stream.fromIterable(passedPlans);
 	const plannedTotal = sortedPlans.length + noCoverageResults.length + rememberedResults.length;
 	const completedRef = yield* Ref.make(0);
@@ -8030,7 +7930,7 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 		yield* offerStreamTested(reported, finished, prepared);
 		yield* persist(reported);
 		return reported;
-	})), { concurrency: Math.max(1, prev.concurrency.testRunners) }).pipe(Stream.runCollect, Effect$1.map((chunk) => [...chunk])));
+	})), { concurrency: Math.max(1, testRunnerCapacity) }).pipe(Stream.runCollect, Effect$1.map((chunk) => [...chunk])));
 	const allResults = [
 		...rememberedResults,
 		...noCoverageResults,
@@ -8038,6 +7938,7 @@ const writeMutationTestProceed = (raw) => Effect$1.gen(function* () {
 		...runResults
 	];
 	const outcomeResult = yield* reporting.reportAll(reportingInputOf(prev, env, allResults));
+	yield* Fiber.await(checkerRelease);
 	const doneNow = yield* Clock.currentTimeMillis;
 	const elapsed = Duration.millis(doneNow - env.runStartedAt);
 	yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
@@ -8517,7 +8418,7 @@ const pluginUrlsFromOptions = (options) => [
 	...options.plugins,
 	...options.appendPlugins,
 	...options.ignorers,
-	...Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => [runner.plugin]), Match.orElse(() => [])),
+	...Match.value(options.testRunner).pipe(Match.when(Options_exports.isCustomTestRunner, (runner) => [runner.plugin]), Match.when(isVmRunner, () => [vmRunnerPluginUrl()]), Match.orElse(() => [])),
 	...options.checkers.map((checker) => checker.plugin)
 ];
 //#endregion
@@ -8817,4 +8718,4 @@ const strykerCell = dual((args) => Predicate$1.isObject(args[0]), (options, targ
 	})
 })), Effect$1.scoped));
 //#endregion
-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 };
+export { ExtendsStepDone as $, RunEvents as A, make$2 as B, forkCoreSchema as C, validateOptions as D, mergeConfigs as E, MetricsResultFromReport as F, ConfigFileInvalidError as G, isCommandRunner as H, reporterWorkerFactory as I, ConfigFileUnsupportedError as J, ConfigFileNotFoundError as K, spawnReporterWorker as L, VerdictEnvelope as M, VerdictMutant as N, RunEnvironment as O, VerdictThresholds as P, ExtendsStepDocumentSchema as Q, makeWorkerClient as R, describeErrors as S, initialExtendsStepState as T, FileMatcher as U, StrykerError as V, ConfigError as W, defaultOptions as X, createDefaultOptions as Y, ConfigDocumentSchema as Z, ClassifyWorkerExitDecision as _, isVmRunner as a, MergeCommand as at, readConfig as b, vmTestRunnerConfig as c, extendsPropertySchema as ct, makeRunEventStream as d, checkGroupedPlans as dt, ExtendsStepRead as et, RunEventWireLine as f, ChildProcessCrashedError as ft, ClassifyWorkerExitCommand as g, CheckerSkippedRequested as gt, layerWorkerProtocol as h, CheckerAnsweredUnrequested as ht, makeChildProcessTestRunner as i, ImportedModuleSchema as it, RunIdentity as j, IdGenerator as k, RunEventDrain as l, forkOptionsSchema as lt, nodePlatformLayer as m, WorkerBootTimeoutError as mt, strykerCell as n, ExtendsStepResolve as nt, testRunnerConfigOf as o, MergeResult as ot, IncrementalReportSchema as p, OutOfMemoryError as pt, ConfigFileUnreadableError as q, buildTestRunner as r, ExtendsStepStateSchema as rt, vmRunnerPluginUrl as s, ReadConfigCommand as st, mutationTestCell as t, ExtendsStepRefused as tt, RunEventDrainLive as u, survivorsPriorReport as ut, classifyWorkerExit as v, importModule as w, decideExtendsStep as x, loadConfigCell as y, WorkerLauncher as z };