@systemfsoftware/stryker-js 16.0.1 → 17.0.1

package/dist/{merge-config-b06M-Ccx.d.mts → merge-config-52qu-jD7.d.mts}

@@ -1,4 +1,4 @@
-import { i as mod_d_exports$5 } from "./index-DEphx668.mjs";
+import { i as mod_d_exports$5 } from "./index-y-Pg3XgT.mjs";
 import * as S from "effect/Schema";
 //#region src/config/stryker-config.schema.d.ts
 type StrykerConfig = mod_d_exports$5.PartialStrykerOptions;

package/dist/{merge-config-BYhhPA7r.mjs → merge-config-ruui2TPS.mjs}

@@ -1032,6 +1032,9 @@ const MutantRunResultSchema = S.Union([
 		errorMessage: S.String
 	})
 ]);
+var MutantRunStarted = class extends S.TaggedClass()("MutantRunStarted", {}) {};
+var MutantRunSettled = class extends S.TaggedClass()("MutantRunSettled", { result: MutantRunResultSchema }) {};
+const MutantRunEventSchema = S.Union([MutantRunStarted, MutantRunSettled]);
 const CoverageAnalysisSchema = S.Literals([
 	"off",
 	"all",
@@ -1247,8 +1250,9 @@ const dryRun = Rpc.make("dryRun", {
 }).middleware(TraceContextMiddleware);
 const mutantRun = Rpc.make("mutantRun", {
 	payload: TestRunnerMutantRunRequest,
-	success: MutantRunResultSchema,
-	error: TestRunnerFailed
+	success: MutantRunEventSchema,
+	error: TestRunnerFailed,
+	stream: true
 }).middleware(TraceContextMiddleware);
 const check = Rpc.make("check", {
 	payload: CheckerRequest,
@@ -1399,7 +1403,10 @@ var TestRunner_exports = /* @__PURE__ */ __exportAll({
 	HitLimitReason: () => HitLimitReason,
 	HitLimitReasonPrefix: () => HitLimitReasonPrefix,
 	HitLimitReasonText: () => HitLimitReasonText,
+	MutantRunEventSchema: () => MutantRunEventSchema,
 	MutantRunResultSchema: () => MutantRunResultSchema,
+	MutantRunSettled: () => MutantRunSettled,
+	MutantRunStarted: () => MutantRunStarted,
 	MutantRunStatus: () => MutantRunStatus,
 	TestId: () => TestId,
 	TestResultSchema: () => TestResultSchema,

package/dist/promises.d.mts

@@ -1,5 +1,5 @@
-import { i as mod_d_exports$5 } from "./index-DEphx668.mjs";
-import { l as MutationTestDone } from "./RunEnvironment.service-F8LgeCqh.mjs";
+import { i as mod_d_exports$5 } from "./index-y-Pg3XgT.mjs";
+import { l as MutationTestDone } from "./RunEnvironment.service-Cluh-Bxt.mjs";
 //#region src/drivers/promise.d.ts
 export declare const run: ((targetMutatePatterns?: readonly string[]) => (options: mod_d_exports$5.PartialStrykerOptions) => Promise<MutationTestDone>) & ((options: mod_d_exports$5.PartialStrykerOptions, targetMutatePatterns?: readonly string[]) => Promise<MutationTestDone>);
 //#endregion

package/dist/promises.mjs

@@ -1,4 +1,4 @@
-import { C as nodePlatformLayer, t as strykerCell } from "./run-stages-DYuRm353.mjs";
+import { C as nodePlatformLayer, t as strykerCell } from "./run-stages-CpYiJ2Mz.mjs";
 import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 //#region src/drivers/promise.ts

package/dist/{run-stages-DYuRm353.mjs → run-stages-CpYiJ2Mz.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll$4 } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { a as MutatorCatalog_exports, c as Plugin_exports, d as TestRunner_exports, f as Trace_exports$1, i as Mutant_exports, l as Report_exports, n as mergeConfigs, o as MutatorProvider_exports, r as Checker_exports, s as Options_exports, t as mergeConfig, u as Reporter_exports } from "./merge-config-BYhhPA7r.mjs";
+import { a as MutatorCatalog_exports, c as Plugin_exports, d as TestRunner_exports, f as Trace_exports$1, i as Mutant_exports, l as Report_exports, n as mergeConfigs, o as MutatorProvider_exports, r as Checker_exports, s as Options_exports, t as mergeConfig, u as Reporter_exports } from "./merge-config-ruui2TPS.mjs";
 import { n as StageError, t as PrepareError } from "./Run.schema-DuaneDGd.mjs";
 import { Blueprint, Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
@@ -11346,7 +11346,7 @@ const strykerOutputFilesOf = (options) => [
 ];
 //#endregion
 //#region package.json
-var version = "16.0.1";
+var version = "17.0.1";
 //#endregion
 //#region src/stryker-package.schema.ts
 var StrykerPackage = class extends S.Class("StrykerPackage")({
@@ -11835,7 +11835,7 @@ const writeIncrementalReport = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationRe
 	const runInputsDigest = yield* runInputsDigestOf(deps.fs, deps.path, input.basePath, input.options);
 	const json = yield* S.encodeEffect(S.fromJsonString(S.Unknown, { space: 2 }))({
 		incrementalVersion: "3",
-		verdictSemanticsVersion: 3,
+		verdictSemanticsVersion: 4,
 		mutantSetPolicy: input.options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		...report,
@@ -11885,7 +11885,7 @@ const slimIncrementalReport = Effect$1.fn(SpanTaxonomy_exports.Spans.mutationRep
 	const runInputsDigest = yield* runInputsDigestOf(deps.fs, deps.path, input.basePath, input.options);
 	return {
 		incrementalVersion: "3",
-		verdictSemanticsVersion: 3,
+		verdictSemanticsVersion: 4,
 		mutantSetPolicy: input.options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		schemaVersion: Report_exports.WrittenSchemaVersion.literal,
@@ -14873,7 +14873,7 @@ const readProject = Effect$1.fn(SpanTaxonomy_exports.Spans.projectReadFromDisk.n
 		_tag: "AdmitIncrementalReportCommand",
 		report: reportRead.report,
 		expectedIncrementalVersion: "3",
-		verdictSemanticsVersion: 3,
+		verdictSemanticsVersion: 4,
 		mutantSetPolicy: options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		options,
@@ -15926,6 +15926,43 @@ const make$1 = (runner) => PooledTestRunner.make({
 	dryRun: runner.dryRun,
 	mutantRun: runner.mutantRun
 });
+const wallClockTimeoutResult = {
+	status: "timeout",
+	reason: TestRunner_exports.WallClockTimeoutReason.literal
+};
+const endedWithoutResult = () => TestRunner_exports.TestRunnerFailed.make({
+	runnerName: "test runner",
+	phase: "mutantRun",
+	cause: "the mutant run ended without reporting a result"
+});
+const deadlineArmedMutantRun = dual(2, (events, timeoutMs) => Effect$1.scoped(Effect$1.gen(function* () {
+	const started = yield* Deferred.make();
+	const settled = yield* Deferred.make();
+	const pump = events.pipe(Stream.runForEach((event) => Match$1.value(event).pipe(Match$1.tag("MutantRunStarted", () => Deferred.succeed(started, void 0)), Match$1.tag("MutantRunSettled", ({ result }) => Deferred.succeed(settled, result)), Match$1.exhaustive, Effect$1.asVoid)), Effect$1.onExit((exit) => Exit.match(exit, {
+		onFailure: (cause) => Deferred.failCause(settled, cause),
+		onSuccess: () => Deferred.fail(settled, endedWithoutResult())
+	}).pipe(Effect$1.asVoid)));
+	yield* Effect$1.forkScoped(pump);
+	const deadline = Effect$1.raceFirst(Deferred.await(started).pipe(Effect$1.as(true)), Deferred.await(settled).pipe(Effect$1.as(false))).pipe(Effect$1.timeoutOption(WORKER_BOOT_TIMEOUT), Effect$1.flatMap(Option$1.match({
+		onNone: () => Effect$1.succeed(wallClockTimeoutResult),
+		onSome: (began) => began ? Effect$1.sleep(Duration.millis(timeoutMs)).pipe(Effect$1.as(wallClockTimeoutResult)) : Deferred.await(settled)
+	})));
+	return yield* Effect$1.raceFirst(deadline, Deferred.await(settled));
+})));
+/**
+* The dry run keeps the configured absolute budget. A mutant run is bounded from
+* its own start by {@link deadlineArmedMutantRun}, so it is not wrapped here.
+*/
+const withDryRunTimeout = (inner) => make$1({
+	...inner,
+	dryRun: (options) => inner.dryRun(options).pipe(Effect$1.timeoutOrElse({
+		duration: Duration.millis(options.timeout),
+		orElse: () => Effect$1.succeed({
+			status: "timeout",
+			reason: TestRunner_exports.WallClockTimeoutReason.literal
+		})
+	}))
+});
 const withTimeout = (inner) => make$1({
 	...inner,
 	dryRun: (options) => inner.dryRun(options).pipe(Effect$1.timeoutOrElse({
@@ -16148,7 +16185,7 @@ const scopedOf = Effect$1.fnUntraced(function* (params) {
 		capabilities: client.capabilities().pipe(Effect$1.mapError(toRunnerFailure(runnerName, "capabilities"))),
 		init: Effect$1.void,
 		dryRun: (options) => client.dryRun({ options }).pipe(Effect$1.mapError(toRunnerFailure(runnerName, "dryRun"))),
-		mutantRun: (options) => client.mutantRun({ options }).pipe(Effect$1.mapError(toRunnerFailure(runnerName, "mutantRun")))
+		mutantRun: (options) => deadlineArmedMutantRun(client.mutantRun({ options }).pipe(Stream.mapError(toRunnerFailure(runnerName, "mutantRun"))), options.timeout)
 	});
 });
 const TestRunners = Blueprint.make()(TypeId$5).steps({
@@ -16160,7 +16197,7 @@ const commandRunnerEffect = (context) => ChildProcessSpawner.ChildProcessSpawner
 const inProcessRunner = (context) => Match$1.value(context.options.testRunner).pipe(Match$1.when(isCommandRunner, () => Option$1.some(commandRunnerEffect(context))), Match$1.orElse(() => Option$1.none()));
 const decorateChildRunner = Effect$1.fnUntraced(function* (context, childProcessRunner) {
 	const base = yield* childProcessRunner;
-	const timed = withTimeout(base);
+	const timed = withDryRunTimeout(base);
 	const limited = yield* withMaxReuse(context.options, context.retire)(timed);
 	const reloading = yield* withEnvironmentReload(context.retire)(limited);
 	return withRetry(reloading);
@@ -17372,7 +17409,7 @@ const explainFileSkip = Workflow.make({
 	decide: (command) => Match$1.value(skipKnownOrUnknownOf(explainedOf(command))).pipe(Match$1.tag("SkipKnownExplained", (known) => Result.succeed(known)), Match$1.tag("SkipUnknownExplained", (unknown) => Result.succeed(unknown)), Match$1.exhaustive)
 });
 //#endregion
-//#region src/run/instrument.cell.ts
+//#region src/run/instrument.ts
 const reportSkippedFiles = Effect$1.fn(SpanTaxonomy_exports.Spans.instrumentReportSkips.name)(function* (input) {
 	const files = input.skipped.map((skip) => Result.match(explainFileSkip(ExplainFileSkipCommand.make({
 		extension: skip.extension,
@@ -17394,13 +17431,6 @@ const offerSkipsIfAny = Effect$1.fn(SpanTaxonomy_exports.Spans.instrumentOfferSk
 		onFalse: () => reportSkippedFiles(input)
 	});
 });
-const sandboxDirectoriesOf = (input) => Option$1.getOrElse(Option$1.map(Option$1.filter(Option$1.some(input), () => input.command.options.inPlace), (inPlace) => ({
-	workingDirectory: inPlace.basePath,
-	backupDirectory: inPlace.command.temporaryDirectoryPath
-})), () => ({
-	workingDirectory: input.command.temporaryDirectoryPath,
-	backupDirectory: ""
-}));
 const mergeInstrumentedFile = (input) => {
 	const files = MutableHashMap.fromIterable(input.project.files);
 	MutableHashMap.set(files, input.file.name, input.file);
@@ -17415,20 +17445,6 @@ const mergeInstrumentedFile = (input) => {
 		filesToMutate
 	};
 };
-const enteringInstrumentPhase = (raw, body) => withPhaseSpan(SpanTaxonomy_exports.Spans.instrumentPhase, { fileCount: raw.filesToMutate.length }, () => Effect$1.andThen(phaseEntered("instrument"), body));
-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,
-	sandbox: raw.sandbox,
-	concurrency: {
-		testRunners: raw.concurrency.testRunners,
-		checkers: raw.concurrency.checkers
-	}
-}));
 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: {
@@ -17436,9 +17452,7 @@ const withInstrumentedFiles = (project, instrumented) => Arr.reduce([...instrume
 		content
 	}
 })), () => current));
-const readInstrument = Effect$1.fn(SpanTaxonomy_exports.Spans.instrumentGather.name)(function* (command) {
-	yield* Scope.Scope;
-	const env = yield* RunEnvironment;
+const instrumentFiles = Effect$1.fnUntraced(function* (command) {
 	const files = yield* ProjectFiles;
 	const filesToMutate = yield* Effect$1.map(files.readAll(MutableHashMap.values(command.project.filesToMutate)), (readFiles) => readFiles.map(([file, content]) => ({
 		content,
@@ -17460,7 +17474,39 @@ const readInstrument = Effect$1.fn(SpanTaxonomy_exports.Spans.instrumentGather.n
 		reason: "Instrumenter failed",
 		cause
 	})));
-	const instrumentedProject = withInstrumentedFiles(command.project, instrumentResult.files);
+	return {
+		filesToMutate,
+		instrumentResult,
+		instrumentedProject: withInstrumentedFiles(command.project, instrumentResult.files)
+	};
+});
+const enteringInstrumentPhase = dual(2, (fileCount, body) => withPhaseSpan(SpanTaxonomy_exports.Spans.instrumentPhase, { fileCount }, () => Effect$1.andThen(phaseEntered("instrument"), body)));
+//#endregion
+//#region src/run/instrument.cell.ts
+const sandboxDirectoriesOf = (input) => Option$1.getOrElse(Option$1.map(Option$1.filter(Option$1.some(input), () => input.command.options.inPlace), (inPlace) => ({
+	workingDirectory: inPlace.basePath,
+	backupDirectory: inPlace.command.temporaryDirectoryPath
+})), () => ({
+	workingDirectory: input.command.temporaryDirectoryPath,
+	backupDirectory: ""
+}));
+const writeInstrument = (raw) => enteringInstrumentPhase(raw.filesToMutate.length, Effect$1.as(offerSkipsIfAny({
+	skipped: raw.instrumentResult.skipped,
+	claimants: raw.prev.frameworkClaimants
+}), {
+	...raw.prev,
+	project: raw.instrumentedProject,
+	mutants: raw.instrumentResult.mutants,
+	sandbox: raw.sandbox,
+	concurrency: {
+		testRunners: raw.concurrency.testRunners,
+		checkers: raw.concurrency.checkers
+	}
+}));
+const readInstrument = Effect$1.fn(SpanTaxonomy_exports.Spans.instrumentGather.name)(function* (command) {
+	yield* Scope.Scope;
+	const env = yield* RunEnvironment;
+	const { filesToMutate, instrumentResult, instrumentedProject } = yield* instrumentFiles(command);
 	const directories = sandboxDirectoriesOf({
 		command,
 		basePath: env.basePath
@@ -18137,7 +18183,7 @@ const closureAnalysisOf = (input) => Effect$1.option(analyzeImportClosure({
 	rootDir: input.basePath,
 	projectFiles: Arr.dedupe([...MutableHashMap.keys(input.project.files), ...input.project.testFiles]),
 	testFiles: [...input.project.testFiles],
-	globalInputs: input.globalTestInputs.map((file) => originalFileFor(input.sandbox, file))
+	globalInputs: input.globalTestInputs.map((file) => input.originalFileOf(file))
 }).pipe(Effect$1.tapCause((cause) => Effect$1.logWarning(`Import closure analysis failed; refusing to reuse prior verdicts: ${Cause.pretty(cause)}`))));
 const closureDigestsOf = (input) => Effect$1.map(closureAnalysisOf(input), (analysis) => Option$1.match(analysis, {
 	onNone: () => ({
@@ -18162,7 +18208,7 @@ const readIncrementalReuseCommand = Effect$1.fn(SpanTaxonomy_exports.Spans.incre
 		previousRecords: [...previousRecords],
 		closureDigestsByMutantId: closures.digests,
 		closureAnalysisFailed: closures.failed,
-		verdictSemanticsVersion: 3,
+		verdictSemanticsVersion: 4,
 		mutantSetPolicy: input.options.mutator.mutantSetPolicy,
 		runInputsDigest,
 		force: input.force,
@@ -19184,7 +19230,7 @@ const proceedPipeline = Effect$1.fnUntraced(function* (raw) {
 		force: prev.options.force,
 		options: prev.options,
 		globalTestInputs: prev.dryRunResult.globalTestInputs ?? [],
-		sandbox: prev.sandbox
+		originalFileOf: (file) => originalFileFor(prev.sandbox, file)
 	});
 	const rememberedResults = reuse.rememberedResults;
 	yield* Queue.offer(progressQueue, RunEvent_exports.ReuseReported.make({
@@ -19339,6 +19385,156 @@ const mutationTestCell$1 = Sandwich.named(SpanTaxonomy_exports.Spans.mutationTes
 	}))
 });
 //#endregion
+//#region src/reporter-wiring.service.ts
+const spawnPluginReporterFactory = Effect$1.fn(SpanTaxonomy_exports.Spans.reporterWiringSpawnPluginReporterFactory.name)(function* (name, loaded, projectBasePath, options) {
+	const entry = yield* Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
+		sources: loaded.pluginSources,
+		kind: "Reporter",
+		configured: ConfiguredPluginName.make({ name })
+	}))), (missing) => StageError.make({
+		stage: "prepare",
+		reason: missing.reason,
+		cause: PluginNotFoundError.make({ descriptor: missing.descriptor })
+	}));
+	const client = yield* spawnReporterWorker({
+		entrypoint: entry.entrypoint,
+		projectBasePath,
+		execArgv: [],
+		options,
+		tempDirPrefix: "stryker-reporter-"
+	}).pipe(Effect$1.mapError((cause) => StageError.make({
+		stage: "prepare",
+		reason: `Failed to start the reporter worker "${name}"`,
+		cause
+	})));
+	return reporterWorkerFactory(client);
+});
+const selectReporterChoices = (names, choicesByName) => Arr.map(Arr.reduce(names, Arr.empty(), (chosen, name) => Option$1.match(HashMap.get(choicesByName, name.toLowerCase()), {
+	onNone: () => chosen,
+	onSome: (choice) => Option$1.match(Arr.findFirst(chosen, ([key]) => key === name.toLowerCase()), {
+		onNone: () => [...chosen, [name.toLowerCase(), choice]],
+		onSome: () => chosen
+	})
+})), ([, choice]) => choice);
+const reporterInputsOf = dual(5, (names, choicesByName, loaded, projectBasePath, options) => Effect$1.forEach(selectReporterChoices(names, choicesByName), (choice) => Option$1.match(choice.builtinFactory, {
+	onSome: (builtin) => Effect$1.succeed({
+		name: choice.name,
+		factory: builtin
+	}),
+	onNone: () => Effect$1.map(spawnPluginReporterFactory(choice.name, loaded, projectBasePath, options), (factory) => ({
+		name: choice.name,
+		factory
+	}))
+}), { concurrency: 1 }));
+//#endregion
+//#region src/keep-temp-dir.workflow.ts
+const KeepTempDirTypeId = Symbol.for("@systemfsoftware/stryker-js/KeepTempDir");
+const CleanTempDirOption = S.Literals([
+	"always",
+	false,
+	true
+]);
+var TempDirKept = class extends S.TaggedClass()("TempDirKept", {}) {
+	[KeepTempDirTypeId] = KeepTempDirTypeId;
+};
+var TempDirRemoved = class extends S.TaggedClass()("TempDirRemoved", {}) {
+	[KeepTempDirTypeId] = KeepTempDirTypeId;
+};
+var KeepTempDirCommand = class extends S.TaggedClass()("KeepTempDirCommand", {
+	cleanTempDir: CleanTempDirOption,
+	failed: S.Boolean
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const keptIff = (kept) => Match$1.value(kept).pipe(Match$1.when(true, () => TempDirKept.make({})), Match$1.when(false, () => TempDirRemoved.make({})), Match$1.exhaustive);
+const decide$1 = (command) => Match$1.value(command.cleanTempDir).pipe(Match$1.when(false, () => TempDirKept.make({})), Match$1.when(true, () => keptIff(command.failed)), Match$1.when("always", () => TempDirRemoved.make({})), Match$1.exhaustive, Result.succeed);
+const keepTempDir = Workflow.make({
+	command: KeepTempDirCommand,
+	decision: S.Union([TempDirKept, TempDirRemoved]),
+	error: S.Never,
+	decide: decide$1
+});
+//#endregion
+//#region src/Sandbox.service.ts
+const removesTempDir = (exit, cleanTempDir) => Result.match(keepTempDir(KeepTempDirCommand.make({
+	cleanTempDir,
+	failed: Exit.isFailure(exit)
+})), {
+	onFailure: () => false,
+	onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("TempDirRemoved", () => true), Match$1.tag("TempDirKept", () => false), Match$1.exhaustive)
+});
+const removeEmptyParentDirectory = Effect$1.fn(SpanTaxonomy_exports.Spans.sandboxRemoveEmptyParent.name)(function* (parent, fs) {
+	const siblings = yield* fs.readDirectory(parent);
+	yield* Boolean$1.match(siblings.length === 0, {
+		onTrue: () => fs.remove(parent, {
+			recursive: true,
+			force: true
+		}),
+		onFalse: () => Effect$1.void
+	});
+});
+const removeTempDirectory = Effect$1.fn(SpanTaxonomy_exports.Spans.sandboxRemoveTempDir.name)(function* (tmp, parent, fs) {
+	yield* Effect$1.logDebug(`Deleting stryker temp directory ${tmp}`);
+	yield* fs.remove(tmp, {
+		recursive: true,
+		force: true
+	});
+	const parentExists = yield* fs.exists(parent);
+	yield* Boolean$1.match(parentExists, {
+		onTrue: () => removeEmptyParentDirectory(parent, fs),
+		onFalse: () => Effect$1.void
+	});
+});
+const makeTemporaryDirectory = Effect$1.fn(SpanTaxonomy_exports.Spans.sandboxMakeTempDir.name)(function* (options) {
+	const fs = yield* FileSystem.FileSystem;
+	const parent = (yield* Path.Path).resolve(options.tempDirName);
+	yield* fs.makeDirectory(parent, { recursive: true });
+	const prefix = Boolean$1.match(options.inPlace, {
+		onTrue: () => "backup-",
+		onFalse: () => "sandbox-"
+	});
+	const tmp = yield* fs.makeTempDirectory({
+		directory: parent,
+		prefix
+	});
+	yield* Effect$1.logDebug(`Using temp directory "${tmp}"`);
+	yield* Effect$1.addFinalizer((exit) => Boolean$1.match(removesTempDir(exit, options.cleanTempDir), {
+		onTrue: () => removeTempDirectory(tmp, parent, fs),
+		onFalse: () => Effect$1.logDebug(`Keeping stryker temp directory ${tmp}`)
+	}).pipe(Effect$1.orDie));
+	return { path: tmp };
+});
+var TemporaryDirectory = class TemporaryDirectory extends Context.Service()("@systemfsoftware/stryker-js/Sandbox.service/TemporaryDirectory") {
+	static layer(options) {
+		return Layer.effect(TemporaryDirectory, makeTemporaryDirectory(options));
+	}
+};
+//#endregion
+//#region src/run/plan-prepare.workflow.ts
+const PrepareDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/PrepareDecision");
+var PrepareDecoded = class extends S.Class("PrepareDecoded")({
+	mode: S.Literals(["human", "machine"]),
+	reporters: S.Array(S.String),
+	fileCount: S.Finite
+}) {
+	static [Workflow.InstrumentationBrand] = {
+		mode: "stryker.prepare.mode",
+		fileCount: "stryker.prepare.file_count"
+	};
+};
+var HumanReporters$1 = class extends S.TaggedClass()("HumanReporters", { reporters: S.Array(S.String) }) {
+	[PrepareDecisionTypeId] = PrepareDecisionTypeId;
+};
+var MachineReporters$1 = class extends S.TaggedClass()("MachineReporters", { reporters: S.Array(S.String) }) {
+	[PrepareDecisionTypeId] = PrepareDecisionTypeId;
+};
+const planPrepare = Workflow.make({
+	command: PrepareDecoded,
+	decision: S.Union([HumanReporters$1, MachineReporters$1]),
+	error: S.Never,
+	decide: (decoded) => Match$1.value(decoded.mode).pipe(Match$1.when("human", () => Result.succeed(HumanReporters$1.make({ reporters: decoded.reporters }))), Match$1.when("machine", () => Result.succeed(MachineReporters$1.make({ reporters: decoded.reporters }))), Match$1.exhaustive)
+});
+//#endregion
 //#region src/plan-mutator-catalogs.workflow.ts
 const STOCK_NAMESPACE = "stryker";
 const CatalogEntrySchema = S.Struct({
@@ -19491,7 +19687,7 @@ const optInRefusalOf = (index, command) => Option$1.match(refusedNameIn(index.op
 		name
 	}))
 });
-const decide$1 = (command) => {
+const decide = (command) => {
 	const index = indexOf(command.catalogs);
 	return Result.map(Result.flatMap(excludedRefusalOf(index, command), () => optInRefusalOf(index, command)), () => MutatorSelectionDecoded.make({
 		excludedMutations: [...command.excludedMutations],
@@ -19502,7 +19698,7 @@ const decodeMutatorSelection = Workflow.make({
 	command: DecodeMutatorSelectionCommand,
 	decision: MutatorSelectionDecoded,
 	error: MutatorSelectionRefused,
-	decide: decide$1
+	decide
 });
 //#endregion
 //#region src/framework-claimant.service.ts
@@ -19975,131 +20171,6 @@ const pluginUrlsFromOptions = (options) => [
 	...options.checkers.map((checker) => checker.plugin)
 ];
 //#endregion
-//#region src/reporter-wiring.service.ts
-const spawnPluginReporterFactory = Effect$1.fn(SpanTaxonomy_exports.Spans.reporterWiringSpawnPluginReporterFactory.name)(function* (name, loaded, projectBasePath, options) {
-	const entry = yield* Effect$1.mapError(Effect$1.fromResult(resolveConfiguredPlugin(WorkerSpawnCommand.make({
-		sources: loaded.pluginSources,
-		kind: "Reporter",
-		configured: ConfiguredPluginName.make({ name })
-	}))), (missing) => StageError.make({
-		stage: "prepare",
-		reason: missing.reason,
-		cause: PluginNotFoundError.make({ descriptor: missing.descriptor })
-	}));
-	const client = yield* spawnReporterWorker({
-		entrypoint: entry.entrypoint,
-		projectBasePath,
-		execArgv: [],
-		options,
-		tempDirPrefix: "stryker-reporter-"
-	}).pipe(Effect$1.mapError((cause) => StageError.make({
-		stage: "prepare",
-		reason: `Failed to start the reporter worker "${name}"`,
-		cause
-	})));
-	return reporterWorkerFactory(client);
-});
-const selectReporterChoices = (names, choicesByName) => Arr.map(Arr.reduce(names, Arr.empty(), (chosen, name) => Option$1.match(HashMap.get(choicesByName, name.toLowerCase()), {
-	onNone: () => chosen,
-	onSome: (choice) => Option$1.match(Arr.findFirst(chosen, ([key]) => key === name.toLowerCase()), {
-		onNone: () => [...chosen, [name.toLowerCase(), choice]],
-		onSome: () => chosen
-	})
-})), ([, choice]) => choice);
-const reporterInputsOf = dual(5, (names, choicesByName, loaded, projectBasePath, options) => Effect$1.forEach(selectReporterChoices(names, choicesByName), (choice) => Option$1.match(choice.builtinFactory, {
-	onSome: (builtin) => Effect$1.succeed({
-		name: choice.name,
-		factory: builtin
-	}),
-	onNone: () => Effect$1.map(spawnPluginReporterFactory(choice.name, loaded, projectBasePath, options), (factory) => ({
-		name: choice.name,
-		factory
-	}))
-}), { concurrency: 1 }));
-//#endregion
-//#region src/keep-temp-dir.workflow.ts
-const KeepTempDirTypeId = Symbol.for("@systemfsoftware/stryker-js/KeepTempDir");
-const CleanTempDirOption = S.Literals([
-	"always",
-	false,
-	true
-]);
-var TempDirKept = class extends S.TaggedClass()("TempDirKept", {}) {
-	[KeepTempDirTypeId] = KeepTempDirTypeId;
-};
-var TempDirRemoved = class extends S.TaggedClass()("TempDirRemoved", {}) {
-	[KeepTempDirTypeId] = KeepTempDirTypeId;
-};
-var KeepTempDirCommand = class extends S.TaggedClass()("KeepTempDirCommand", {
-	cleanTempDir: CleanTempDirOption,
-	failed: S.Boolean
-}) {
-	static [Workflow.InstrumentationBrand] = {};
-};
-const keptIff = (kept) => Match$1.value(kept).pipe(Match$1.when(true, () => TempDirKept.make({})), Match$1.when(false, () => TempDirRemoved.make({})), Match$1.exhaustive);
-const decide = (command) => Match$1.value(command.cleanTempDir).pipe(Match$1.when(false, () => TempDirKept.make({})), Match$1.when(true, () => keptIff(command.failed)), Match$1.when("always", () => TempDirRemoved.make({})), Match$1.exhaustive, Result.succeed);
-const keepTempDir = Workflow.make({
-	command: KeepTempDirCommand,
-	decision: S.Union([TempDirKept, TempDirRemoved]),
-	error: S.Never,
-	decide
-});
-//#endregion
-//#region src/Sandbox.service.ts
-const removesTempDir = (exit, cleanTempDir) => Result.match(keepTempDir(KeepTempDirCommand.make({
-	cleanTempDir,
-	failed: Exit.isFailure(exit)
-})), {
-	onFailure: () => false,
-	onSuccess: (decision) => Match$1.value(decision).pipe(Match$1.tag("TempDirRemoved", () => true), Match$1.tag("TempDirKept", () => false), Match$1.exhaustive)
-});
-const removeEmptyParentDirectory = Effect$1.fn(SpanTaxonomy_exports.Spans.sandboxRemoveEmptyParent.name)(function* (parent, fs) {
-	const siblings = yield* fs.readDirectory(parent);
-	yield* Boolean$1.match(siblings.length === 0, {
-		onTrue: () => fs.remove(parent, {
-			recursive: true,
-			force: true
-		}),
-		onFalse: () => Effect$1.void
-	});
-});
-const removeTempDirectory = Effect$1.fn(SpanTaxonomy_exports.Spans.sandboxRemoveTempDir.name)(function* (tmp, parent, fs) {
-	yield* Effect$1.logDebug(`Deleting stryker temp directory ${tmp}`);
-	yield* fs.remove(tmp, {
-		recursive: true,
-		force: true
-	});
-	const parentExists = yield* fs.exists(parent);
-	yield* Boolean$1.match(parentExists, {
-		onTrue: () => removeEmptyParentDirectory(parent, fs),
-		onFalse: () => Effect$1.void
-	});
-});
-const makeTemporaryDirectory = Effect$1.fn(SpanTaxonomy_exports.Spans.sandboxMakeTempDir.name)(function* (options) {
-	const fs = yield* FileSystem.FileSystem;
-	const parent = (yield* Path.Path).resolve(options.tempDirName);
-	yield* fs.makeDirectory(parent, { recursive: true });
-	const prefix = Boolean$1.match(options.inPlace, {
-		onTrue: () => "backup-",
-		onFalse: () => "sandbox-"
-	});
-	const tmp = yield* fs.makeTempDirectory({
-		directory: parent,
-		prefix
-	});
-	yield* Effect$1.logDebug(`Using temp directory "${tmp}"`);
-	yield* Effect$1.addFinalizer((exit) => Boolean$1.match(removesTempDir(exit, options.cleanTempDir), {
-		onTrue: () => removeTempDirectory(tmp, parent, fs),
-		onFalse: () => Effect$1.logDebug(`Keeping stryker temp directory ${tmp}`)
-	}).pipe(Effect$1.orDie));
-	return { path: tmp };
-});
-var TemporaryDirectory = class TemporaryDirectory extends Context.Service()("@systemfsoftware/stryker-js/Sandbox.service/TemporaryDirectory") {
-	static layer(options) {
-		return Layer.effect(TemporaryDirectory, makeTemporaryDirectory(options));
-	}
-};
-//#endregion
 //#region src/run/admit-non-empty-project.workflow.ts
 const NonEmptyProjectTypeId = Symbol.for("@systemfsoftware/stryker-js/NonEmptyProjectDecision");
 var NonEmptyProjectCommand = class extends S.TaggedClass()("NonEmptyProjectCommand", { fileCount: S.Int }) {
@@ -20122,31 +20193,6 @@ const admitNonEmptyProject = Workflow.make({
 	}))
 });
 //#endregion
-//#region src/run/plan-prepare.workflow.ts
-const PrepareDecisionTypeId = Symbol.for("@systemfsoftware/stryker-js/PrepareDecision");
-var PrepareDecoded = class extends S.Class("PrepareDecoded")({
-	mode: S.Literals(["human", "machine"]),
-	reporters: S.Array(S.String),
-	fileCount: S.Finite
-}) {
-	static [Workflow.InstrumentationBrand] = {
-		mode: "stryker.prepare.mode",
-		fileCount: "stryker.prepare.file_count"
-	};
-};
-var HumanReporters$1 = class extends S.TaggedClass()("HumanReporters", { reporters: S.Array(S.String) }) {
-	[PrepareDecisionTypeId] = PrepareDecisionTypeId;
-};
-var MachineReporters$1 = class extends S.TaggedClass()("MachineReporters", { reporters: S.Array(S.String) }) {
-	[PrepareDecisionTypeId] = PrepareDecisionTypeId;
-};
-const planPrepare = Workflow.make({
-	command: PrepareDecoded,
-	decision: S.Union([HumanReporters$1, MachineReporters$1]),
-	error: S.Never,
-	decide: (decoded) => Match$1.value(decoded.mode).pipe(Match$1.when("human", () => Result.succeed(HumanReporters$1.make({ reporters: decoded.reporters }))), Match$1.when("machine", () => Result.succeed(MachineReporters$1.make({ reporters: decoded.reporters }))), Match$1.exhaustive)
-});
-//#endregion
 //#region src/run/plan-reporters.workflow.ts
 const ReporterPlanTypeId = Symbol.for("@systemfsoftware/stryker-js/ReporterPlanDecision");
 const STREAM_REPORTER = StreamReporterSchema.literal;
@@ -20187,7 +20233,7 @@ const planReporters = Workflow.make({
 	decide: (command) => Match$1.value(command.mode).pipe(Match$1.when("human", () => Result.succeed(HumanReporters.make({ reporters: [...humanReportersFrom(command.configured)] }))), Match$1.when("machine", () => Result.succeed(MachineReporters.make({ reporters: [...machineReportersFrom(command.configured)] }))), Match$1.exhaustive)
 });
 //#endregion
-//#region src/run/prepare.cell.ts
+//#region src/run/prepare.ts
 const announceSummary = Effect$1.fn(SpanTaxonomy_exports.Spans.prepareAnnounceSummary.name)(function* (input) {
 	yield* Match$1.value(input.env.resolvedMode.mode).pipe(Match$1.when("human", () => Boolean$1.match(input.env.allowConsoleColors, {
 		onTrue: () => Console.log(`${AnsiCode.fields.green.literal}${input.summary}${AnsiCode.fields.reset.literal}`),
@@ -20300,7 +20346,7 @@ const readPrepare = Effect$1.fn(SpanTaxonomy_exports.Spans.prepareGather.name)(f
 		frameworkClaimants
 	};
 });
-const applyPrepare = Effect$1.fn(SpanTaxonomy_exports.Spans.prepareApply.name)(function* (span, reporters, raw) {
+const admitPreparedProject = (raw) => Effect$1.gen(function* () {
 	const mutateCount = pipe(raw.project.filesToMutate, MutableHashMap.size);
 	yield* announceSummary({
 		env: raw.env,
@@ -20321,7 +20367,12 @@ const applyPrepare = Effect$1.fn(SpanTaxonomy_exports.Spans.prepareApply.name)(f
 			reason: "No input files found."
 		})
 	}))), () => Result.succeed(void 0));
-	yield* Effect$1.fromResult(emptyProjectGuard);
+	return yield* Effect$1.fromResult(emptyProjectGuard);
+});
+//#endregion
+//#region src/run/prepare.cell.ts
+const applyPrepare = Effect$1.fn(SpanTaxonomy_exports.Spans.prepareApply.name)(function* (span, reporters, raw) {
+	yield* admitPreparedProject(raw);
 	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",