@systemfsoftware/stryker-js 10.0.0 → 10.0.1

package/dist/{src-Bu4i-Lt2.mjs → src-CMHnl87m.mjs}

@@ -1,4 +1,4 @@
-import { $ as WorkerPluginKind, F as MutationTestingPlanReady, G as TRACEPARENT_HEADER, I as NonNegativeInt, J as TestRunnerFailed, K as TRACESTATE_HEADER, L as PropagatedTrace, M as MutantTested, N as MutationTestReportReady, O as Metrics, P as MutationTestResultSchema$1, Q as WorkerEntryUrl, S as CheckerMutantWire, T as DryRunCompleted, U as ReporterRpcs, V as ReporterFailed, W as StrykerOptionsSchema, X as TraceContextMiddleware, Y as TestRunnerRpcs, Z as TraceContextReference, _ as RunStarted, c as PhaseEntered, dt as errorToString, et as formatTraceparent, f as RunEvent, ft as instrument, it as INSTRUMENTER_CONSTANTS, k as MetricsResultSchema, l as PlanKnown, m as RunMutantTested, n as StageError, nt as parseTraceparent, ot as Mutant, pt as normalizeFileName$4, r as Heartbeat, rt as toMutantRunResult, t as PrepareError, tt as isCustomTestRunner, ut as disableTypeChecks, v as VerdictReached, w as CheckerRpcs } from "./Run.schema-C0Cxsfe9.mjs";
+import { $ as WorkerPluginKind, F as MutationTestingPlanReady, G as TRACEPARENT_HEADER, I as NonNegativeInt, J as TestRunnerFailed, K as TRACESTATE_HEADER, L as PropagatedTrace, M as MutantTested, N as MutationTestReportReady, O as Metrics, P as MutationTestResultSchema$1, Q as WorkerEntryUrl, S as CheckerMutantWire, T as DryRunCompleted, U as ReporterRpcs, V as ReporterFailed, W as StrykerOptionsSchema, X as TraceContextMiddleware, Y as TestRunnerRpcs, Z as TraceContextReference, _ as RunStarted, c as PhaseEntered, dt as errorToString, et as formatTraceparent, f as RunEvent, ft as instrument, it as INSTRUMENTER_CONSTANTS, k as MetricsResultSchema, l as PlanKnown, m as RunMutantTested, n as StageError, nt as parseTraceparent, ot as Mutant, pt as normalizeFileName$4, r as Heartbeat, rt as toMutantRunResult, t as PrepareError, tt as isCustomTestRunner, ut as disableTypeChecks, v as VerdictReached, w as CheckerRpcs } from "./Run.schema-CgVfoOfk.mjs";
 import { t as mergeConfig } from "./merge-config-BrrNQWje.mjs";
 import * as Effect$1 from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
@@ -16,12 +16,12 @@ import * as Ref from "effect/Ref";
 import * as Result from "effect/Result";
 import * as S from "effect/Schema";
 import * as Stream from "effect/Stream";
-import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
+import { Cell, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Predicate from "effect/Predicate";
 import * as Array$1 from "effect/Array";
-import { Schema } from "effect";
+import { Schema, SchemaGetter } from "effect";
 import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
-import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaGetter$1 from "effect/SchemaGetter";
 import * as Exit from "effect/Exit";
 import * as Scope from "effect/Scope";
 import * as Duration from "effect/Duration";
@@ -52,7 +52,7 @@ import * as Equivalence from "effect/Equivalence";
 import * as Metric from "effect/Metric";
 import * as Pool from "effect/Pool";
 import * as Semaphore from "effect/Semaphore";
-import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as SchemaTransformation$1 from "effect/SchemaTransformation";
 import { randomBytes } from "@noble/hashes/utils.js";
 import * as Console from "effect/Console";
 import "effect/Sink";
@@ -142,8 +142,8 @@ const frameRunEvent = Workflow.total(FrameRunEventCommand, decideFrame);
 //#endregion
 //#region src/run-event-wire.schema.ts
 const RunEventWireLine = S.String.pipe(S.decodeTo(S.fromJsonString(RunEvent), {
-	decode: SchemaGetter.transform((line) => line.replace(/\n$/, "")),
-	encode: SchemaGetter.transform((json) => `${json}\n`)
+	decode: SchemaGetter$1.transform((line) => line.replace(/\n$/, "")),
+	encode: SchemaGetter$1.transform((json) => `${json}\n`)
 }));
 //#endregion
 //#region src/RunEvents.ts
@@ -915,9 +915,9 @@ Layer.succeed(TraceContextMiddleware, serverMiddleware);
 let wire;
 const workerOptionsWire = () => wire ??= S.fromJsonString(S.toCodecJson(StrykerOptionsSchema));
 const encodeWorkerOptions = (options) => S.encodeEffect(workerOptionsWire())(options).pipe(Effect$1.orDie);
-const decodeWorkerOptions = (raw) => S.decodeUnknownEffect(workerOptionsWire())(raw);
+const decodeWorkerOptions = (raw) => S.decodeEffect(workerOptionsWire())(raw);
 Effect$1.gen(function* () {
-	const workerDir = yield* Config.string("STRYKER_WORKER_DIR");
+	const workerDir = yield* Config.String("STRYKER_WORKER_DIR");
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const raw = yield* fs.readFileString(path.join(workerDir, "options.json"));
@@ -936,9 +936,9 @@ const otlpLayer = (serviceName, endpoint) => NodeSdk.layer(() => ({
 	spanProcessor: new SimpleSpanProcessor(new OTLPTraceExporter({ url: tracesUrl(endpoint) }))
 }));
 Layer.unwrap(Effect$1.gen(function* () {
-	if (!(yield* Config.boolean("OTEL_ENABLED").pipe(Config.withDefault(false)))) return Layer.empty;
-	const serviceName = yield* Config.string("OTEL_SERVICE_NAME").pipe(Config.withDefault(WORKER_SERVICE_NAME));
-	const endpoint = yield* Config.string("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.withDefault(DEFAULT_ENDPOINT));
+	if (!(yield* Config.Boolean("OTEL_ENABLED").pipe(Config.withDefault(false)))) return Layer.empty;
+	const serviceName = yield* Config.String("OTEL_SERVICE_NAME").pipe(Config.withDefault(WORKER_SERVICE_NAME));
+	const endpoint = yield* Config.String("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.withDefault(DEFAULT_ENDPOINT));
 	return otlpLayer(serviceName, endpoint);
 }));
 //#endregion
@@ -1202,7 +1202,7 @@ const makeWorkerClient = (params) => Effect$1.gen(function* () {
 });
 //#endregion
 //#region src/platform/node.ts
-const restrictToOwnerOrWarn = (fs, file) => fs.chmod(file, 384).pipe(Effect$1.catchTag("PlatformError", (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))));
+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));
 /**
 * The Node worker launcher: spawn a worker child with this runtime's
 * executable, host the RPC server's address as a `net` `path` endpoint (a
@@ -1217,12 +1217,12 @@ const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect$1.gen(functi
 	return { spawn: (params) => Effect$1.gen(function* () {
 		const workerDir = yield* fs.makeTempDirectoryScoped({ prefix: params.tempDirPrefix });
 		const workerId = yield* crypto.randomUUIDv4;
-		const socketPath = Match.value(process.platform).pipe(Match.when("win32", () => `\\\\.\\pipe\\stryker-worker-${workerId}`), Match.orElse(() => path.join(workerDir, "worker.sock")));
+		const socketPath = Match.value(globalThis.process.platform).pipe(Match.when("win32", () => `\\\\.\\pipe\\stryker-worker-${workerId}`), Match.orElse(() => path.join(workerDir, "worker.sock")));
 		const optionsFile = path.join(workerDir, "options.json");
 		yield* fs.writeFileString(optionsFile, params.optionsJson);
 		yield* restrictToOwnerOrWarn(fs, optionsFile);
 		const entrypointPath = yield* path.fromFileUrl(new URL(params.entrypoint));
-		const handle = yield* ChildProcess.make(process.execPath, [...params.execArgv, entrypointPath], {
+		const handle = yield* ChildProcess.make(globalThis.process.execPath, [...params.execArgv, entrypointPath], {
 			cwd: params.workingDirectory,
 			extendEnv: true,
 			env: {
@@ -1256,14 +1256,14 @@ const nodePlatformLayer = Layer.mergeAll(nodeWorkerLauncherLayer.pipe(Layer.prov
 * The in-memory runner's platform: the V8 sandbox module and the module
 * builtin that strips TypeScript and resolves a sandbox's `require`.
 *
-* Reached through `process.getBuiltinModule` rather than an `import` because a
+* Reached through `globalThis.process.getBuiltinModule` rather than an `import` because a
 * Node builtin import is forbidden in product code; the call is wrapped in
 * `Effect.promise` so a platform without `node:vm` fails as a defect — the
 * runner has no fallback to fall back to.
 */
 const nodeVmPlatformLayer = Layer.effect(VmRunner, Effect$1.sync(() => ({
-	module: process.getBuiltinModule("node:module"),
-	vm: process.getBuiltinModule("node:vm")
+	module: globalThis.process.getBuiltinModule("node:module"),
+	vm: globalThis.process.getBuiltinModule("node:vm")
 })));
 S.TaggedError()("CommandRunnerUnsupportedOption", { option: S.String });
 S.Struct({
@@ -2002,7 +2002,7 @@ function findConfigFile(configFileName) {
 	return Match.value(configFileName).pipe(Match.when(Match.string, (fileName) => configFileFor(fileName)), Match.orElse(() => discoverConfigFile()));
 }
 const resolveChildExtends = (configFile, child, configEnv) => Match.value("extends" in child).pipe(Match.when(true, () => resolveExtends(configFile, child, configEnv)), Match.orElse(() => Effect$1.succeed(child)));
-const isCiEnvironment = Config.string("CI").pipe(Effect$1.map((value) => Match.value(value.trim().toLowerCase()).pipe(Match.when("", () => false), Match.when("0", () => false), Match.when("false", () => false), Match.orElse(() => true))), Effect$1.orElseSucceed(() => false));
+const isCiEnvironment = Config.String("CI").pipe(Effect$1.map((value) => Match.value(value.trim().toLowerCase()).pipe(Match.when("", () => false), Match.when("0", () => false), Match.when("false", () => false), Match.orElse(() => true))), Effect$1.orElseSucceed(() => false));
 function loadOptionsFromConfigFile(cliOptions, configEnv) {
 	return findConfigFile(cliOptions["configFile"]).pipe(Effect$1.flatMap((configFile) => Match.value(configFile).pipe(Match.when(void 0, () => Effect$1.succeed({})), Match.orElse((found) => readConfigModule(found, configEnv).pipe(Effect$1.flatMap((child) => resolveChildExtends(found, child, configEnv)))))));
 }
@@ -2014,7 +2014,7 @@ function readConfig(cliOptions, invocation) {
 			isDryRun: cliOptions["dryRunOnly"] === true,
 			isCi: yield* isCiEnvironment
 		};
-		const cliRecord = yield* S.decodeUnknownEffect(ConfigDocumentSchema)(cliOptions).pipe(Effect$1.orDie);
+		const cliRecord = yield* S.decodeEffect(ConfigDocumentSchema)(cliOptions).pipe(Effect$1.orDie);
 		const fileRecord = yield* loadOptionsFromConfigFile(cliRecord, configEnv);
 		const fileOptions = yield* Result.match(S.decodeUnknownResult(ConfigDocumentSchema)(fileRecord), {
 			onFailure: (cause) => Effect$1.fail(ConfigFileInvalidError.make({
@@ -2046,9 +2046,13 @@ const PluginDescriptorSchema = Schema.Union([Schema.Struct({
 const PluginModuleSchema = Schema.Struct({ strykerPlugins: Schema.Array(PluginDescriptorSchema) });
 const isShouldIgnore = (value) => typeof value === "function";
 const ignoreNothing = () => void 0;
+const shouldIgnoreArbitrary = Schema.link()(Schema.Null, {
+	decode: SchemaGetter.transform(() => ignoreNothing),
+	encode: SchemaGetter.transform(() => null)
+});
 const IgnorerEntrySchema = Schema.Struct({
 	name: Schema.String,
-	shouldIgnore: Schema.declare(isShouldIgnore, { toArbitrary: () => (fc) => fc.constant(ignoreNothing) })
+	shouldIgnore: Schema.declare(isShouldIgnore, { toCodecArbitrary: () => shouldIgnoreArbitrary })
 });
 const IgnorerModuleSchema = Schema.Struct({ strykerIgnorers: Schema.Array(IgnorerEntrySchema) });
 const SchemaValidationContributionSchema = Schema.Struct({ strykerValidationSchema: Schema.Record(Schema.String, Schema.Unknown) });
@@ -2436,8 +2440,8 @@ const initFromPhaseSpan = (span) => {
 	};
 };
 const environmentTraceInit = () => Effect$1.gen(function* () {
-	const traceparent = yield* Config.string("TRACEPARENT").pipe(Effect$1.option);
-	const tracestate = yield* Config.string("TRACESTATE").pipe(Effect$1.option);
+	const traceparent = yield* Config.String("TRACEPARENT").pipe(Effect$1.option);
+	const tracestate = yield* Config.String("TRACESTATE").pipe(Effect$1.option);
 	return {
 		...traceparentInit(Option.getOrUndefined(traceparent)),
 		...tracestateInit(Option.getOrUndefined(tracestate))
@@ -2532,104 +2536,98 @@ const completeDryRunPassed = (raw) => Effect$1.gen(function* () {
 		timeOverhead: Duration.millis(overheadMillis)
 	};
 });
-const dryRunCell = Cell.layer({
-	read: (command) => Effect$1.gen(function* () {
-		yield* Scope.Scope;
-		const idGenerator = yield* IdGenerator;
-		const { files, testFiles } = buildDryRunFiles(command);
-		const dryRunTimeout = command.options.dryRunTimeoutMinutes * 60 * 1e3;
-		yield* Effect$1.logInfo("Starting dry run");
-		const { rawResult, capabilities, gross } = yield* Effect$1.scoped(Effect$1.gen(function* () {
-			const childRunnerEffect = Effect$1.suspend(() => {
-				const runnerConfigured = command.options.testRunner;
-				const runnerLabel = Match.value(runnerConfigured).pipe(Match.when(isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
-				return resolveConfiguredWorkerSpawn({
-					loaded: command.loadedPlugins,
-					kind: "TestRunner",
-					configured: runnerConfigured
-				}).pipe(Effect$1.mapError(missingWorkerEntry("dryRun", "test runner", runnerLabel)), Effect$1.flatMap(({ spawn }) => makeChildProcessTestRunner({
-					options: command.options,
-					fileDescriptions: command.project.fileDescriptions,
-					sandboxWorkingDirectory: command.sandbox.workingDirectory,
-					workerEntrypoint: spawn.entrypoint,
-					idGenerator
-				})));
-			});
-			const runner = yield* buildTestRunner({
+const dryRunCell = Sandwich.read((command) => Effect$1.gen(function* () {
+	yield* Scope.Scope;
+	const idGenerator = yield* IdGenerator;
+	const { files, testFiles } = buildDryRunFiles(command);
+	const dryRunTimeout = command.options.dryRunTimeoutMinutes * 60 * 1e3;
+	yield* Effect$1.logInfo("Starting dry run");
+	const { rawResult, capabilities, gross } = yield* Effect$1.scoped(Effect$1.gen(function* () {
+		const childRunnerEffect = Effect$1.suspend(() => {
+			const runnerConfigured = command.options.testRunner;
+			const runnerLabel = Match.value(runnerConfigured).pipe(Match.when(isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
+			return resolveConfiguredWorkerSpawn({
+				loaded: command.loadedPlugins,
+				kind: "TestRunner",
+				configured: runnerConfigured
+			}).pipe(Effect$1.mapError(missingWorkerEntry("dryRun", "test runner", runnerLabel)), Effect$1.flatMap(({ spawn }) => makeChildProcessTestRunner({
 				options: command.options,
 				fileDescriptions: command.project.fileDescriptions,
 				sandboxWorkingDirectory: command.sandbox.workingDirectory,
-				idGenerator,
-				retire: Effect$1.void,
-				testFiles: testFiles ?? []
-			}, childRunnerEffect);
-			const extra = Option.match(Option.fromUndefinedOr(testFiles), {
-				onNone: () => ({}),
-				onSome: (files) => ({ testFiles: files })
-			});
-			const timed = yield* Effect$1.timed(runner.dryRun({
-				timeout: dryRunTimeout,
-				coverageAnalysis: command.options.coverageAnalysis,
-				disableBail: command.options.disableBail,
-				files,
-				...extra
-			}).pipe(Effect$1.mapError((cause) => StageError.make({
-				stage: "dryRun",
-				reason: "Dry run failed",
-				cause
-			}))));
-			const gross = timed[0];
-			return {
-				rawResult: timed[1],
-				capabilities: yield* runner.capabilities.pipe(Effect$1.mapError((cause) => StageError.make({
-					stage: "dryRun",
-					reason: "Failed to get test runner capabilities",
-					cause
-				}))),
-				gross
-			};
-		})).pipe(Effect$1.mapError((cause) => {
-			if (S.is(StageError)(cause)) return cause;
-			return StageError.make({
+				workerEntrypoint: spawn.entrypoint,
+				idGenerator
+			})));
+		});
+		const runner = yield* buildTestRunner({
+			options: command.options,
+			fileDescriptions: command.project.fileDescriptions,
+			sandboxWorkingDirectory: command.sandbox.workingDirectory,
+			idGenerator,
+			retire: Effect$1.void,
+			testFiles: testFiles ?? []
+		}, childRunnerEffect);
+		const extra = Option.match(Option.fromUndefinedOr(testFiles), {
+			onNone: () => ({}),
+			onSome: (files) => ({ testFiles: files })
+		});
+		const timed = yield* Effect$1.timed(runner.dryRun({
+			timeout: dryRunTimeout,
+			coverageAnalysis: command.options.coverageAnalysis,
+			disableBail: command.options.disableBail,
+			files,
+			...extra
+		}).pipe(Effect$1.mapError((cause) => StageError.make({
+			stage: "dryRun",
+			reason: "Dry run failed",
+			cause
+		}))));
+		const gross = timed[0];
+		return {
+			rawResult: timed[1],
+			capabilities: yield* runner.capabilities.pipe(Effect$1.mapError((cause) => StageError.make({
 				stage: "dryRun",
-				reason: "Dry run failed to start test runner",
+				reason: "Failed to get test runner capabilities",
 				cause
-			});
-		}));
-		return {
-			prev: command,
-			rawResult,
-			capabilities,
+			}))),
 			gross
 		};
-	}),
-	decode: (raw) => Match.value(raw.rawResult).pipe(Match.when(isCompleteDryRun, (complete) => decodeCompleteDryRun(complete, raw.prev.options.allowEmpty)), Match.when(isFailedDryRun, (failed) => decodeFailedDryRun(failed, raw.prev.options.allowEmpty)), Match.orElse((timedOut) => decodeTimedOutDryRun(timedOut, raw.prev.options.allowEmpty))),
-	decide: dryRun,
-	encode: (outcome) => outcome,
-	write: (outcome, raw) => withPhaseSpan("dryRun", {}, () => Effect$1.gen(function* () {
-		const env = yield* RunEnvironment;
-		const now = yield* Clock.currentTimeMillis;
-		const queue = yield* RunEvents;
-		yield* Queue.offer(queue, PhaseEntered.make({
-			phase: "dry-run",
-			elapsedMs: now - env.runStartedAt
-		}));
-		const out = outcome;
-		if (Result.isFailure(out)) {
-			const err = out.failure;
-			return yield* StageError.make({
-				stage: err.stage,
-				reason: err.reason,
-				cause: err
-			});
-		}
-		return yield* Match.value(out.success).pipe(Match.tag("DryRunFailed", (decision) => Effect$1.fail(StageError.make({
+	})).pipe(Effect$1.mapError((cause) => {
+		if (S.is(StageError)(cause)) return cause;
+		return StageError.make({
 			stage: "dryRun",
-			reason: "There were failed tests in the initial test run.",
-			cause: decision
-		}))), Match.tag("DryRunPassed", () => completeDryRunPassed(raw)), Match.exhaustive);
-	}))
-});
+			reason: "Dry run failed to start test runner",
+			cause
+		});
+	}));
+	return {
+		prev: command,
+		rawResult,
+		capabilities,
+		gross
+	};
+})).decode(Sandwich.pure((raw) => Match.value(raw.rawResult).pipe(Match.when(isCompleteDryRun, (complete) => decodeCompleteDryRun(complete, raw.prev.options.allowEmpty)), Match.when(isFailedDryRun, (failed) => decodeFailedDryRun(failed, raw.prev.options.allowEmpty)), Match.orElse((timedOut) => decodeTimedOutDryRun(timedOut, raw.prev.options.allowEmpty))))).decide(dryRun).encode(Sandwich.pure((outcome) => Result.succeed(outcome))).write((outcome, raw) => withPhaseSpan("dryRun", {}, () => Effect$1.gen(function* () {
+	const env = yield* RunEnvironment;
+	const now = yield* Clock.currentTimeMillis;
+	const queue = yield* RunEvents;
+	yield* Queue.offer(queue, PhaseEntered.make({
+		phase: "dry-run",
+		elapsedMs: now - env.runStartedAt
+	}));
+	const out = outcome;
+	if (Result.isFailure(out)) {
+		const err = out.failure;
+		return yield* StageError.make({
+			stage: err.stage,
+			reason: err.reason,
+			cause: err
+		});
+	}
+	return yield* Match.value(out.success).pipe(Match.tag("DryRunFailed", (decision) => Effect$1.fail(StageError.make({
+		stage: "dryRun",
+		reason: "There were failed tests in the initial test run.",
+		cause: decision
+	}))), Match.tag("DryRunPassed", () => completeDryRunPassed(raw)), Match.exhaustive);
+})));
 //#endregion
 //#region src/plan-instrumentation.workflow.ts
 var InstrumentError = class extends S.TaggedError()("InstrumentError", {
@@ -2846,118 +2844,8 @@ const decide = (command) => Option.match(Option.fromUndefinedOr(command.report),
 });
 const admitIncrementalReport = Workflow.total(AdmitIncrementalReportCommand, (command) => Result.succeed(decide(command)));
 //#endregion
-//#region package.json
-var package_default = {
-	name: "@systemfsoftware/stryker-js",
-	version: "10.0.0",
-	repository: {
-		"type": "git",
-		"url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
-		"directory": "packages/stryker-js"
-	},
-	homepage: "https://github.com/systemfsoftware/stryker-js-effect",
-	bugs: { "url": "https://github.com/systemfsoftware/stryker-js-effect/issues" },
-	description: "The Stryker mutation testing tool — the stryker executable, the run engine, and the configuration surface.",
-	type: "module",
-	files: ["dist"],
-	bin: { "stryker": "./dist/main.mjs" },
-	scripts: {
-		"clean": "rimraf dist",
-		"build": "pnpm run typecheck && rimraf dist && tsdown --config tsdown.bin.config.ts && tsdown --config tsdown.config.ts",
-		"typecheck": "tsc --noEmit --incremental && tsc -p tsconfig.node.json --noEmit",
-		"test": "vitest run",
-		"mutation": "stryker run",
-		"attw": "attw --pack .",
-		"lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
-		"api:check": "api-extractor run",
-		"api:update": "api-extractor run --local",
-		"lint:tsgo": "effect-tsgo diagnostics --project tsconfig.json --format ${TSGO_FORMAT:-text}"
-	},
-	license: "Apache-2.0",
-	engines: { "node": ">=22.18.0" },
-	dependencies: {
-		"@effect/opentelemetry": "4.0.0-rc.112",
-		"@effect/platform-node": "catalog:",
-		"@effect/platform-node-shared": "catalog:",
-		"@noble/hashes": "catalog:",
-		"@opentelemetry/api": "^1.9.0",
-		"@opentelemetry/exporter-metrics-otlp-http": "^0.208.0",
-		"@opentelemetry/exporter-trace-otlp-http": "^0.208.0",
-		"@opentelemetry/sdk-metrics": "^2.2.0",
-		"@opentelemetry/sdk-trace-base": "^2.2.0",
-		"@systemfsoftware/effect-cell-types": "catalog:"
-	},
-	peerDependencies: { "effect": "catalog:" },
-	devDependencies: {
-		"@effect/tsgo": "catalog:",
-		"@effect/vitest": "catalog:",
-		"@microsoft/api-extractor": "catalog:",
-		"@oxc-parser/binding-wasm32-wasi": "catalog:",
-		"@std/jsonc": "catalog:",
-		"@systemfsoftware/all": "catalog:",
-		"@systemfsoftware/arethetypeswrong-cli": "catalog:",
-		"@systemfsoftware/effect-gherkin-spec": "catalog:",
-		"@systemfsoftware/effect-schema-law": "catalog:",
-		"@systemfsoftware/effect-schema-vite": "catalog:",
-		"@systemfsoftware/stryker-config": "workspace:^",
-		"@systemfsoftware/stryker-ignorer-effect-schema-declarations": "catalog:stryker",
-		"@systemfsoftware/stryker-ignorer-in-source-vitest-block": "catalog:stryker",
-		"@systemfsoftware/stryker-ignorer-interface": "workspace:^",
-		"@systemfsoftware/stryker-js": "catalog:stryker",
-		"@systemfsoftware/stryker-js-html-reporter": "workspace:^",
-		"@systemfsoftware/stryker-js-instrumenter": "workspace:^",
-		"@systemfsoftware/stryker-js-plugin-interface": "workspace:^",
-		"@systemfsoftware/stryker-js-plugin-runtime": "workspace:^",
-		"@systemfsoftware/stryker-js-typescript-checker": "catalog:stryker",
-		"@systemfsoftware/stryker-js-vitest-runner": "catalog:stryker",
-		"@systemfsoftware/stryker-test-contribution": "catalog:stryker",
-		"@systemfsoftware/tsconfig": "catalog:",
-		"@systemfsoftware/tsdown-config": "workspace:^",
-		"@systemfsoftware/vitest-config": "workspace:^",
-		"@types/node": "catalog:",
-		"@vitest/coverage-v8": "catalog:",
-		"concurrently": "catalog:",
-		"mutation-testing-elements": "catalog:stryker",
-		"oxc-parser": "catalog:",
-		"oxlint": "catalog:",
-		"oxlint-tsgolint": "catalog:",
-		"rimraf": "catalog:",
-		"tsdown": "catalog:",
-		"typescript": "catalog:",
-		"vitest": "catalog:"
-	},
-	publishConfig: {
-		"access": "public",
-		"provenance": true,
-		"exports": {
-			".": {
-				"types": "./dist/index.d.mts",
-				"default": "./dist/index.mjs"
-			},
-			"./config": {
-				"types": "./dist/config.d.mts",
-				"default": "./dist/config.mjs"
-			},
-			"./events": {
-				"types": "./dist/events.d.mts",
-				"default": "./dist/events.mjs"
-			},
-			"./promises": {
-				"types": "./dist/promises.d.mts",
-				"default": "./dist/promises.mjs"
-			},
-			"./package.json": "./package.json"
-		}
-	},
-	exports: { "./package.json": "./package.json" }
-};
-//#endregion
-//#region src/stryker-package.schema.ts
-const PackageJsonSchema = Schema.Struct({ version: Schema.String });
-//#endregion
 //#region src/stryker-package.ts
-const rawPackageJson = package_default;
-const strykerVersion = Schema.decodeUnknownSync(PackageJsonSchema)(rawPackageJson).version;
+const strykerVersion = "10.0.1";
 //#endregion
 //#region src/incremental-report.cell.ts
 const parseAndDecodeIncrementalReport = S.decodeUnknownResult(S.fromJsonString(IncrementalReportSchema));
@@ -2968,7 +2856,7 @@ const readIncrementalReportRaw = (input) => {
 		contents: void 0
 	});
 	return Effect$1.gen(function* () {
-		const contents = yield* (yield* FileSystem.FileSystem).readFileString(input.incrementalFile).pipe(Effect$1.catchTag("PlatformError", (error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect$1.logInfo(`No incremental result file found at ${input.incrementalFile}, a full mutation testing run will be performed.`).pipe(Effect$1.as(void 0))), Match.orElse(() => Effect$1.fail(error)))));
+		const contents = yield* (yield* FileSystem.FileSystem).readFileString(input.incrementalFile).pipe(Effect$1.tapError((error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect$1.logInfo(`No incremental result file found at ${input.incrementalFile}, a full mutation testing run will be performed.`)), Match.orElse(() => Effect$1.void))), Effect$1.catchTag("PlatformError", (error) => Match.value(error.reason).pipe(Match.tag("NotFound", () => Effect$1.undefined), Match.orElse(() => Effect$1.fail(error)))));
 		return {
 			incremental: true,
 			incrementalFile: input.incrementalFile,
@@ -2996,13 +2884,7 @@ const writeIncrementalReportOutcome = (outcome, raw) => Result.match(outcome, {
 		});
 	}), Match.exhaustive)
 });
-const incrementalReportCell = Cell.layer({
-	read: readIncrementalReportRaw,
-	decode: decodeIncrementalReportRaw,
-	decide: admitIncrementalReport,
-	encode: (outcome) => outcome,
-	write: writeIncrementalReportOutcome
-});
+const incrementalReportCell = Sandwich.read(readIncrementalReportRaw).decode(Sandwich.pure(decodeIncrementalReportRaw)).decide(admitIncrementalReport).encode(Sandwich.pure((outcome) => Result.succeed(outcome))).write(writeIncrementalReportOutcome);
 //#endregion
 //#region src/Project.ts
 const DEFAULT_GLOB$1 = "**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}";
@@ -3736,9 +3618,9 @@ const makeDisableTypeChecksPreprocessor = (options, impl) => (project) => Effect
 		const content = yield* Effect$1.map(impl(instrumenterFile), (instrumented) => instrumented.content).pipe(Effect$1.mapError((cause) => StrykerError.make({
 			message: "disableTypeChecks failed",
 			cause
-		})), Effect$1.catch((_error) => Effect$1.gen(function* () {
+		})), Effect$1.tapError(() => Effect$1.gen(function* () {
 			if (isWarningEnabled("preprocessorErrors", options.warnings)) yield* Effect$1.logWarning(`Unable to disable type checking for file "${name}". Shouldn't type checking be disabled for this file? Consider configuring a more restrictive "${optionsPath("disableTypeChecks")}" settings (or turn it completely off with \`false\`)`);
-		})));
+		})), Effect$1.orElseSucceed(() => void 0));
 		if (content !== void 0) return withContent(file, content);
 	})), Match.orElse(() => Effect$1.succeedNone)), { concurrency: 24 })).forEach(mergeUpdatedInto(project));
 });
@@ -3885,7 +3767,7 @@ const directoryChain = (from, pathService) => {
 	return [from, ...directoryChain(parent, pathService)];
 };
 const binDirectoriesFrom = (from, pathService) => directoryChain(pathService.resolve(from), pathService).map((directory) => pathService.join(directory, "node_modules", ".bin"));
-const inheritedPath = () => Config.string("PATH").pipe(Effect$1.option, Effect$1.map((value) => Option.getOrUndefined(value) ?? ""));
+const inheritedPath = () => Config.String("PATH").pipe(Effect$1.option, Effect$1.map((value) => Option.getOrUndefined(value) ?? ""));
 const failOnBuildFailure = (command, result) => Match.value(result.exitCode).pipe(Match.when((exitCode) => exitCode !== 0, (exitCode) => Effect$1.fail(StrykerError.make({ message: `Build command "${command}" failed with exit code ${String(exitCode)}.\n${result.stderr}` }))), Match.orElse(() => Effect$1.void));
 const runBuildCommandIn = (command, workingDirectory) => Effect$1.gen(function* () {
 	const pathService = yield* Path.Path;
@@ -4012,7 +3894,7 @@ const linkNodeModules = (nodeModules, workingDirectory, basePath, pathService) =
 	const resolvedTo = pathService.resolve(pathService.join(basePath, nodeModules));
 	const resolvedFrom = pathService.join(workingDirectory, nodeModules);
 	yield* Effect$1.logDebug(`Create symlink from ${resolvedTo} to ${resolvedFrom}`);
-	yield* symlinkJunction(resolvedTo, resolvedFrom).pipe(Effect$1.catch((_error) => Effect$1.logWarning(`Unexpected error while trying to symlink "${nodeModules}" in sandbox directory.`)));
+	yield* symlinkJunction(resolvedTo, resolvedFrom).pipe(Effect$1.tapError(() => Effect$1.logWarning(`Unexpected error while trying to symlink "${nodeModules}" in sandbox directory.`)), Effect$1.catchTag("PlatformError", () => Effect$1.void));
 });
 const linkFoundNodeModules = (options, workingDirectory, basePath, pathService) => Effect$1.gen(function* () {
 	const nodeModulesList = yield* findNodeModulesList(basePath, options.tempDirName);
@@ -4050,90 +3932,84 @@ const makeSandbox = (input) => Effect$1.gen(function* () {
 });
 //#endregion
 //#region src/run/instrument.cell.ts
-const instrumentCell = Cell.layer({
-	read: (command) => Effect$1.gen(function* () {
-		yield* Scope.Scope;
-		const env = yield* RunEnvironment;
-		const filesToMutate = yield* Effect$1.forEach([...MutableHashMap.values(command.project.filesToMutate)], (file) => toInstrumenterFile(file), { concurrency: 24 }).pipe(Effect$1.mapError((cause) => StageError.make({
+const instrumentCell = Sandwich.read((command) => Effect$1.gen(function* () {
+	yield* Scope.Scope;
+	const env = yield* RunEnvironment;
+	const filesToMutate = yield* Effect$1.forEach([...MutableHashMap.values(command.project.filesToMutate)], (file) => toInstrumenterFile(file), { concurrency: 24 }).pipe(Effect$1.mapError((cause) => StageError.make({
+		stage: "instrument",
+		reason: "Failed to read files to mutate",
+		cause
+	})));
+	const instrumentResult = yield* instrument(filesToMutate, {
+		ignorers: [...command.ignorers],
+		excludedMutations: [...command.options.mutator.excludedMutations]
+	}, env.basePath).pipe(Effect$1.mapError((cause) => StageError.make({
+		stage: "instrument",
+		reason: "Instrumenter failed",
+		cause
+	})));
+	const instrumentedProject = withInstrumentedFiles(command.project, instrumentResult.files);
+	const basePath = env.basePath;
+	let workingDirectory = command.temporaryDirectoryPath;
+	let backupDirectory = "";
+	if (command.options.inPlace) {
+		workingDirectory = basePath;
+		backupDirectory = command.temporaryDirectoryPath;
+	}
+	return {
+		prev: command,
+		filesToMutate,
+		instrumentResult,
+		instrumentedProject,
+		sandbox: yield* makeSandbox({
+			options: command.options,
+			project: instrumentedProject,
+			workingDirectory,
+			backupDirectory,
+			basePath
+		}).pipe(Effect$1.mapError((cause) => StageError.make({
 			stage: "instrument",
-			reason: "Failed to read files to mutate",
+			reason: "Sandbox initialization failed",
 			cause
-		})));
-		const instrumentResult = yield* instrument(filesToMutate, {
-			ignorers: [...command.ignorers],
-			excludedMutations: [...command.options.mutator.excludedMutations]
-		}, env.basePath).pipe(Effect$1.mapError((cause) => StageError.make({
+		}))),
+		concurrency: yield* makeConcurrency(command.options).pipe(Effect$1.mapError((cause) => StageError.make({
 			stage: "instrument",
-			reason: "Instrumenter failed",
+			reason: "Failed to compute concurrency",
 			cause
-		})));
-		const instrumentedProject = withInstrumentedFiles(command.project, instrumentResult.files);
-		const basePath = env.basePath;
-		let workingDirectory = command.temporaryDirectoryPath;
-		let backupDirectory = "";
-		if (command.options.inPlace) {
-			workingDirectory = basePath;
-			backupDirectory = command.temporaryDirectoryPath;
-		}
-		return {
-			prev: command,
-			filesToMutate,
-			instrumentResult,
-			instrumentedProject,
-			sandbox: yield* makeSandbox({
-				options: command.options,
-				project: instrumentedProject,
-				workingDirectory,
-				backupDirectory,
-				basePath
-			}).pipe(Effect$1.mapError((cause) => StageError.make({
-				stage: "instrument",
-				reason: "Sandbox initialization failed",
-				cause
-			}))),
-			concurrency: yield* makeConcurrency(command.options).pipe(Effect$1.mapError((cause) => StageError.make({
-				stage: "instrument",
-				reason: "Failed to compute concurrency",
-				cause
-			})))
-		};
-	}),
-	decode: (raw) => Result.succeed(InstrumentCommand.make({
-		fileCount: raw.filesToMutate.length,
-		inPlace: raw.prev.options.inPlace,
-		pluginCount: raw.prev.loadedPlugins.pluginModulePaths.length
-	})),
-	decide: planInstrumentation,
-	encode: (outcome) => outcome,
-	write: (output, raw) => withPhaseSpan("instrument", { fileCount: raw.filesToMutate.length }, () => Effect$1.gen(function* () {
-		const env = yield* RunEnvironment;
-		const now = yield* Clock.currentTimeMillis;
-		const queue = yield* RunEvents;
-		yield* Queue.offer(queue, PhaseEntered.make({
-			phase: "instrument",
-			elapsedMs: now - env.runStartedAt
-		}));
-		const out = output;
-		if (Result.isFailure(out)) {
-			const err = out.failure;
-			return yield* StageError.make({
-				stage: err.stage,
-				reason: err.reason,
-				cause: err
-			});
+		})))
+	};
+})).decode(Sandwich.pure((raw) => Result.succeed(InstrumentCommand.make({
+	fileCount: raw.filesToMutate.length,
+	inPlace: raw.prev.options.inPlace,
+	pluginCount: raw.prev.loadedPlugins.pluginModulePaths.length
+})))).decide(planInstrumentation).encode(Sandwich.pure((outcome) => Result.succeed(outcome))).write((output, raw) => withPhaseSpan("instrument", { fileCount: raw.filesToMutate.length }, () => Effect$1.gen(function* () {
+	const env = yield* RunEnvironment;
+	const now = yield* Clock.currentTimeMillis;
+	const queue = yield* RunEvents;
+	yield* Queue.offer(queue, PhaseEntered.make({
+		phase: "instrument",
+		elapsedMs: now - env.runStartedAt
+	}));
+	const out = output;
+	if (Result.isFailure(out)) {
+		const err = out.failure;
+		return yield* StageError.make({
+			stage: err.stage,
+			reason: err.reason,
+			cause: err
+		});
+	}
+	return {
+		...raw.prev,
+		project: raw.instrumentedProject,
+		mutants: raw.instrumentResult.mutants,
+		sandbox: raw.sandbox,
+		concurrency: {
+			testRunners: raw.concurrency.testRunners,
+			checkers: raw.concurrency.checkers
 		}
-		return {
-			...raw.prev,
-			project: raw.instrumentedProject,
-			mutants: raw.instrumentResult.mutants,
-			sandbox: raw.sandbox,
-			concurrency: {
-				testRunners: raw.concurrency.testRunners,
-				checkers: raw.concurrency.checkers
-			}
-		};
-	}))
-});
+	};
+})));
 //#endregion
 //#region src/MutationTest.schema.ts
 var MutationTestCommand = class extends S.TaggedClass()("MutationTestCommand", {
@@ -4168,7 +4044,7 @@ const admitMutationTest = Workflow.make(MutationTestCommand, (command) => Match.
 }, () => Result.succeed(MutationTestNoTests.make({}))), Match.orElse(() => Result.succeed(MutationTestProceed.make({})))));
 //#endregion
 //#region src/checker-mutant-wire.ts
-const CheckerMutantFromMutant = Mutant.pipe(S.decodeTo(CheckerMutantWire, SchemaTransformation.transform({
+const CheckerMutantFromMutant = Mutant.pipe(S.decodeTo(CheckerMutantWire, SchemaTransformation$1.transform({
 	decode: (m) => ({
 		id: m.id,
 		fileName: m.fileName,
@@ -4184,7 +4060,7 @@ const CheckerMutantFromMutant = Mutant.pipe(S.decodeTo(CheckerMutantWire, Schema
 		location: w.location
 	})
 })));
-const wireRecordOf = (mutant) => Result.mapError(S.decodeUnknownResult(CheckerMutantFromMutant)(mutant), (error) => ({
+const wireRecordOf = (mutant) => Result.mapError(S.decodeResult(CheckerMutantFromMutant)(mutant), (error) => ({
 	id: mutant.id,
 	fileName: mutant.fileName,
 	reason: error.message
@@ -4501,35 +4377,29 @@ const logSkippedMutants = (checkerName, undescribable) => Match.value(undescriba
 * that joins them back. The join is where the work is, and it is pure.
 */
 const checkPlans = (checker, checkerName, plans, lookup) => {
-	return Cell.layer({
-		read: (command) => Effect$1.gen(function* () {
-			const partitioned = Option.match(Option.fromUndefinedOr(command.lookup), {
-				onSome: (known) => selectedFromLookup(command.plans, known),
-				onNone: () => partitionMutantsForWire(command.plans)
-			});
-			yield* logSkippedMutants(command.checkerName, partitioned.undescribable);
-			if (partitioned.undescribable.length > 0) yield* Metric.update(checkerMutantsSkipped, partitioned.undescribable.length);
-			yield* Effect$1.annotateCurrentSpan({ "stryker.checker.skipped_mutants_count": partitioned.undescribable.length });
-			const answers = yield* command.checker.check(command.checkerName, partitioned.wire);
-			return {
-				checkerName: command.checkerName,
-				requestedIds: command.plans.map((plan) => plan.mutant.id),
-				answers: {
-					...compileErrorAnswersOf(partitioned.undescribable),
-					...answers
-				}
-			};
-		}),
-		decode: (raw) => Result.succeed(CheckerCommand.make({
-			checkerName: raw.checkerName,
-			requestedIds: [...raw.requestedIds],
-			phase: "check",
-			answers: { ...raw.answers }
-		})),
-		decide: admitCheckerAnswer,
-		encode: (outcome) => outcome,
-		write: (outcome, raw) => writeCheckerOutcome(plans, raw.checkerName, outcome)
-	}).run({
+	return Sandwich.read((command) => Effect$1.gen(function* () {
+		const partitioned = Option.match(Option.fromUndefinedOr(command.lookup), {
+			onSome: (known) => selectedFromLookup(command.plans, known),
+			onNone: () => partitionMutantsForWire(command.plans)
+		});
+		yield* logSkippedMutants(command.checkerName, partitioned.undescribable);
+		if (partitioned.undescribable.length > 0) yield* Metric.update(checkerMutantsSkipped, partitioned.undescribable.length);
+		yield* Effect$1.annotateCurrentSpan({ "stryker.checker.skipped_mutants_count": partitioned.undescribable.length });
+		const answers = yield* command.checker.check(command.checkerName, partitioned.wire);
+		return {
+			checkerName: command.checkerName,
+			requestedIds: command.plans.map((plan) => plan.mutant.id),
+			answers: {
+				...compileErrorAnswersOf(partitioned.undescribable),
+				...answers
+			}
+		};
+	})).decode(Sandwich.pure((raw) => Result.succeed(CheckerCommand.make({
+		checkerName: raw.checkerName,
+		requestedIds: [...raw.requestedIds],
+		phase: "check",
+		answers: { ...raw.answers }
+	})))).decide(admitCheckerAnswer).encode(Sandwich.pure((outcome) => Result.succeed(outcome))).write((outcome, raw) => writeCheckerOutcome(plans, raw.checkerName, outcome)).run({
 		checker,
 		checkerName,
 		plans,
@@ -4540,31 +4410,25 @@ const checkPlans = (checker, checkerName, plans, lookup) => {
 * Ask a checker how to group run plans, and get groups of run plans back.
 */
 const groupPlans = (checker, checkerName, plans, lookup) => {
-	return Cell.layer({
-		read: (command) => Effect$1.gen(function* () {
-			const partitioned = Option.match(Option.fromUndefinedOr(command.lookup), {
-				onSome: (known) => selectedFromLookup(command.plans, known),
-				onNone: () => partitionMutantsForWire(command.plans)
-			});
-			yield* Effect$1.annotateCurrentSpan({ "stryker.checker.skipped_mutants_count": partitioned.undescribable.length });
-			const undescribableIds = undescribableIdsOf(partitioned.undescribable);
-			const withoutSkipped = (yield* command.checker.group(command.checkerName, partitioned.wire)).map((group) => group.filter((id) => !undescribableIds.has(id))).filter((group) => group.length > 0);
-			return {
-				checkerName: command.checkerName,
-				requestedIds: command.plans.map((plan) => plan.mutant.id),
-				idGroups: [...singletonGroupsOf(partitioned.undescribable), ...withoutSkipped]
-			};
-		}),
-		decode: (raw) => Result.succeed(CheckerCommand.make({
-			checkerName: raw.checkerName,
-			requestedIds: [...raw.requestedIds],
-			phase: "group",
-			idGroups: raw.idGroups.map((group) => [...group])
-		})),
-		decide: admitCheckerAnswer,
-		encode: (outcome) => outcome,
-		write: (outcome, raw) => writeGroupOutcome(plans, raw.checkerName, outcome)
-	}).run({
+	return Sandwich.read((command) => Effect$1.gen(function* () {
+		const partitioned = Option.match(Option.fromUndefinedOr(command.lookup), {
+			onSome: (known) => selectedFromLookup(command.plans, known),
+			onNone: () => partitionMutantsForWire(command.plans)
+		});
+		yield* Effect$1.annotateCurrentSpan({ "stryker.checker.skipped_mutants_count": partitioned.undescribable.length });
+		const undescribableIds = undescribableIdsOf(partitioned.undescribable);
+		const withoutSkipped = (yield* command.checker.group(command.checkerName, partitioned.wire)).map((group) => group.filter((id) => !undescribableIds.has(id))).filter((group) => group.length > 0);
+		return {
+			checkerName: command.checkerName,
+			requestedIds: command.plans.map((plan) => plan.mutant.id),
+			idGroups: [...singletonGroupsOf(partitioned.undescribable), ...withoutSkipped]
+		};
+	})).decode(Sandwich.pure((raw) => Result.succeed(CheckerCommand.make({
+		checkerName: raw.checkerName,
+		requestedIds: [...raw.requestedIds],
+		phase: "group",
+		idGroups: raw.idGroups.map((group) => [...group])
+	})))).decide(admitCheckerAnswer).encode(Sandwich.pure((outcome) => Result.succeed(outcome))).write((outcome, raw) => writeGroupOutcome(plans, raw.checkerName, outcome)).run({
 		checker,
 		checkerName,
 		plans,
@@ -4800,7 +4664,7 @@ function embeddedConfig(report) {
 }
 function breakThreshold(thresholds) {
 	const ThresholdsBreakSchema = S.StructWithRest(S.Struct({ break: S.optional(S.Union([S.Finite, S.Null])) }), [S.Record(S.String, S.Unknown)]);
-	const decoded = S.decodeUnknownOption(ThresholdsBreakSchema)(thresholds);
+	const decoded = S.decodeOption(ThresholdsBreakSchema)(thresholds);
 	return Option.getOrNull(Option.flatMap(decoded, (value) => Option.fromNullishOr(value.break)));
 }
 const actionableMutants = (files) => Object.entries(files).flatMap(([file, fileResult]) => fileResult.mutants.filter((mutant) => isActionableStatus(mutant.status)).map((mutant) => ({
@@ -4965,7 +4829,7 @@ const makeMutationReportingService = (input) => {
 		const resolved = yield* Effect$1.try(() => new URL(import.meta.resolve(`${specifier}/package.json`)));
 		const manifestPath = yield* pathService.fromFileUrl(resolved);
 		const text = yield* fs.readFileString(manifestPath);
-		return Result.match(S.decodeUnknownResult(S.fromJsonString(ManifestSchema))(text), {
+		return Result.match(S.decodeResult(S.fromJsonString(ManifestSchema))(text), {
 			onFailure: () => Option.none(),
 			onSuccess: (manifest) => Option.some(manifest.version ?? "")
 		});
@@ -5215,160 +5079,168 @@ const reportDroppedMutants = (dropped) => Match.value(dropped.length).pipe(Match
 	yield* Metric.update(checkerMutantsSkipped, dropped.length);
 	yield* Effect$1.logWarning(`${dropped.length} mutant(s) cannot be described to a checker and were left out of the run (${droppedIdsOf(dropped)})`);
 })));
-const mutationTestCell$1 = Cell.layer({
-	read: (command) => Effect$1.gen(function* () {
-		yield* Scope.Scope;
-		return { prev: command };
-	}),
-	decode: (raw) => Result.succeed(MutationTestCommand.make({
-		dryRunOnly: raw.prev.options.dryRunOnly,
-		allowEmpty: raw.prev.options.allowEmpty,
-		testCount: raw.prev.dryRunResult.tests.length,
-		isZero: raw.prev.dryRunResult.tests.length === 0
-	})),
-	decide: admitMutationTest,
-	encode: (outcome) => outcome,
-	write: (outcome, raw) => {
-		const { dropped, plannable: plannableMutants } = partitionPlannable(raw.prev.mutants);
-		return withPhaseSpan("mutationTest", {
-			mutantCount: raw.prev.mutants.length,
-			skippedMutantCount: dropped.length,
-			testCount: raw.prev.dryRunResult.tests.length
-		}, () => Effect$1.gen(function* () {
-			yield* reportDroppedMutants(dropped);
-			const decision = yield* Result.match(outcome, {
-				onFailure: (err) => Effect$1.fail(StageError.make({
-					stage: err.stage,
-					reason: err.reason,
-					cause: err
-				})),
-				onSuccess: (d) => Effect$1.succeed(d)
-			});
-			return yield* Match.value(decision).pipe(Match.tag("MutationTestDryRunOnly", () => Effect$1.gen(function* () {
-				const env = yield* RunEnvironment;
-				const queue = yield* RunEvents;
+const mutationTestCell$1 = Sandwich.read((command) => Effect$1.gen(function* () {
+	yield* Scope.Scope;
+	return { prev: command };
+})).decode(Sandwich.pure((raw) => Result.succeed(MutationTestCommand.make({
+	dryRunOnly: raw.prev.options.dryRunOnly,
+	allowEmpty: raw.prev.options.allowEmpty,
+	testCount: raw.prev.dryRunResult.tests.length,
+	isZero: raw.prev.dryRunResult.tests.length === 0
+})))).decide(admitMutationTest).encode(Sandwich.pure((outcome) => Result.succeed(outcome))).write((outcome, raw) => {
+	const { dropped, plannable: plannableMutants } = partitionPlannable(raw.prev.mutants);
+	return withPhaseSpan("mutationTest", {
+		mutantCount: raw.prev.mutants.length,
+		skippedMutantCount: dropped.length,
+		testCount: raw.prev.dryRunResult.tests.length
+	}, () => Effect$1.gen(function* () {
+		yield* reportDroppedMutants(dropped);
+		const decision = yield* Result.match(outcome, {
+			onFailure: (err) => Effect$1.fail(StageError.make({
+				stage: err.stage,
+				reason: err.reason,
+				cause: err
+			})),
+			onSuccess: (d) => Effect$1.succeed(d)
+		});
+		return yield* Match.value(decision).pipe(Match.tag("MutationTestDryRunOnly", () => Effect$1.gen(function* () {
+			const env = yield* RunEnvironment;
+			const queue = yield* RunEvents;
+			const nowEmit = yield* Clock.currentTimeMillis;
+			yield* Queue.offer(queue, PhaseEntered.make({
+				phase: "mutation-test",
+				elapsedMs: nowEmit - env.runStartedAt
+			}));
+			yield* Effect$1.logInfo("The dry-run has been completed successfully. No mutations have been executed.");
+			return {
+				results: [],
+				verdict: null
+			};
+		})), Match.tag("MutationTestNoTests", () => Effect$1.gen(function* () {
+			const env = yield* RunEnvironment;
+			const queue = yield* RunEvents;
+			const now = yield* Clock.currentTimeMillis;
+			const elapsed = Duration.millis(now - env.runStartedAt);
+			yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
+			const nowEmit = yield* Clock.currentTimeMillis;
+			yield* Queue.offer(queue, PhaseEntered.make({
+				phase: "mutation-test",
+				elapsedMs: nowEmit - env.runStartedAt
+			}));
+			return {
+				results: [],
+				verdict: null
+			};
+		})), Match.tag("MutationTestProceed", () => Effect$1.gen(function* () {
+			const prev = raw.prev;
+			const env = yield* RunEnvironment;
+			yield* Effect$1.gen(function* () {
 				const nowEmit = yield* Clock.currentTimeMillis;
-				yield* Queue.offer(queue, PhaseEntered.make({
-					phase: "mutation-test",
-					elapsedMs: nowEmit - env.runStartedAt
-				}));
-				yield* Effect$1.logInfo("The dry-run has been completed successfully. No mutations have been executed.");
-				return {
-					results: [],
-					verdict: null
-				};
-			})), Match.tag("MutationTestNoTests", () => Effect$1.gen(function* () {
-				const env = yield* RunEnvironment;
 				const queue = yield* RunEvents;
-				const now = yield* Clock.currentTimeMillis;
-				const elapsed = Duration.millis(now - env.runStartedAt);
-				yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
-				const nowEmit = yield* Clock.currentTimeMillis;
 				yield* Queue.offer(queue, PhaseEntered.make({
 					phase: "mutation-test",
 					elapsedMs: nowEmit - env.runStartedAt
 				}));
+			});
+			const idGenerator = yield* IdGenerator;
+			const checkerPool = yield* makeCheckerPool(prev, idGenerator, env.basePath);
+			const testRunnerContext = {
+				options: prev.options,
+				fileDescriptions: prev.project.fileDescriptions,
+				sandboxWorkingDirectory: prev.sandbox.workingDirectory,
+				idGenerator,
+				retire: Effect$1.void,
+				testFiles: prev.project.testFiles.map((file) => prev.sandbox.sandboxFileFor(file))
+			};
+			const testRunnerPool = yield* Pool.make({
+				acquire: buildTestRunner(testRunnerContext, Effect$1.suspend(() => {
+					const runnerConfigured = prev.options.testRunner;
+					const runnerLabel = Match.value(runnerConfigured).pipe(Match.when(isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
+					return resolveConfiguredWorkerSpawn({
+						loaded: prev.loadedPlugins,
+						kind: "TestRunner",
+						configured: runnerConfigured
+					}).pipe(Effect$1.mapError(missingWorkerEntry("mutationTest", "test runner", runnerLabel)), Effect$1.flatMap(({ spawn }) => makeChildProcessTestRunner({
+						options: prev.options,
+						fileDescriptions: prev.project.fileDescriptions,
+						sandboxWorkingDirectory: prev.sandbox.workingDirectory,
+						workerEntrypoint: spawn.entrypoint,
+						idGenerator
+					})));
+				})),
+				size: prev.concurrency.testRunners
+			});
+			const reporting = makeMutationReportingService({
+				reporterStage: prev.reporterStage,
+				options: prev.options,
+				project: prev.project,
+				testCoverage: prev.testCoverage,
+				runId: env.runId,
+				resolvedMode: env.resolvedMode,
+				sandboxDirectory: prev.sandbox.workingDirectory,
+				basePath: env.basePath
+			});
+			const sandboxFileByName = Object.fromEntries([...MutableHashMap.keys(prev.project.filesToMutate)].map((name) => [name, prev.sandbox.sandboxFileFor(name)]));
+			const currentRelativeFiles = yield* readCurrentRelativeFiles(prev.project, env.basePath);
+			const incremental = incrementalDiff({
+				currentMutants: plannableMutants,
+				testCoverage: prev.testCoverage,
+				incrementalReport: prev.project.incrementalReport,
+				currentRelativeFiles,
+				basePath: env.basePath,
+				force: prev.options.force
+			});
+			const rememberedResults = rememberedResultsOf(plannableMutants, incremental.remembered);
+			yield* Effect$1.when(Effect$1.logInfo(`Incremental mode: reusing ${rememberedResults.length} mutant result(s), running ${incremental.mutants.length} mutant(s).`), Effect$1.succeed(rememberedResults.length > 0));
+			const { runPlans, earlyResults: noCoverageResults } = partitionRunPlans(yield* decidePlans(incremental.mutants, prev.testCoverage, {
+				disableBail: prev.options.disableBail,
+				timeoutMS: prev.options.timeoutMS,
+				timeoutFactor: prev.options.timeoutFactor,
+				ignoreStatic: prev.options.ignoreStatic
+			}, Duration.toMillis(prev.timeOverhead), void 0, sandboxFileByName));
+			const sortedPlans = sortRunPlans(runPlans);
+			const allPlansForReporter = [...sortedPlans];
+			yield* offerReporterEvent(prev.reporterStage, MutationTestingPlanReady.make({
+				total: allPlansForReporter.length + noCoverageResults.length + rememberedResults.length,
+				plans: allPlansForReporter.map((plan) => ({
+					mutantId: plan.mutant.id,
+					plan: plan.plan,
+					netTime: plan.netTime,
+					reloadEnvironment: plan.runOptions.reloadEnvironment
+				}))
+			})).pipe(Effect$1.ignoreCause);
+			{
+				const queue2 = yield* RunEvents;
+				yield* Queue.offer(queue2, PlanKnown.make({ total: allPlansForReporter.length + noCoverageResults.length }));
+			}
+			const { passedPlans, checkerResults } = yield* checkPlansWithConfiguredCheckers(checkerPool, sortedPlans, reporting);
+			const testRunnerStream = Stream.fromIterable(passedPlans);
+			const plannedTotal = allPlansForReporter.length + noCoverageResults.length + rememberedResults.length;
+			const pathService = yield* Path.Path;
+			const progressQueue = yield* RunEvents;
+			const completedRef = yield* Ref.make(0);
+			const preparedStreamableOf = (result) => {
+				if (!isMutantStatus(result.status)) return;
 				return {
-					results: [],
-					verdict: null
-				};
-			})), Match.tag("MutationTestProceed", () => Effect$1.gen(function* () {
-				const prev = raw.prev;
-				const env = yield* RunEnvironment;
-				yield* Effect$1.gen(function* () {
-					const nowEmit = yield* Clock.currentTimeMillis;
-					const queue = yield* RunEvents;
-					yield* Queue.offer(queue, PhaseEntered.make({
-						phase: "mutation-test",
-						elapsedMs: nowEmit - env.runStartedAt
-					}));
-				});
-				const idGenerator = yield* IdGenerator;
-				const checkerPool = yield* makeCheckerPool(prev, idGenerator, env.basePath);
-				const testRunnerContext = {
-					options: prev.options,
-					fileDescriptions: prev.project.fileDescriptions,
-					sandboxWorkingDirectory: prev.sandbox.workingDirectory,
-					idGenerator,
-					retire: Effect$1.void,
-					testFiles: prev.project.testFiles.map((file) => prev.sandbox.sandboxFileFor(file))
+					status: result.status,
+					file: reportFileName(pathService.relative(env.basePath, result.fileName)),
+					location: toSchemaLocation(result.location)
 				};
-				const testRunnerPool = yield* Pool.make({
-					acquire: buildTestRunner(testRunnerContext, Effect$1.suspend(() => {
-						const runnerConfigured = prev.options.testRunner;
-						const runnerLabel = Match.value(runnerConfigured).pipe(Match.when(isCustomTestRunner, (runner) => runner.plugin), Match.orElse((name) => name));
-						return resolveConfiguredWorkerSpawn({
-							loaded: prev.loadedPlugins,
-							kind: "TestRunner",
-							configured: runnerConfigured
-						}).pipe(Effect$1.mapError(missingWorkerEntry("mutationTest", "test runner", runnerLabel)), Effect$1.flatMap(({ spawn }) => makeChildProcessTestRunner({
-							options: prev.options,
-							fileDescriptions: prev.project.fileDescriptions,
-							sandboxWorkingDirectory: prev.sandbox.workingDirectory,
-							workerEntrypoint: spawn.entrypoint,
-							idGenerator
-						})));
-					})),
-					size: prev.concurrency.testRunners
-				});
-				const reporting = makeMutationReportingService({
-					reporterStage: prev.reporterStage,
-					options: prev.options,
-					project: prev.project,
-					testCoverage: prev.testCoverage,
-					runId: env.runId,
-					resolvedMode: env.resolvedMode,
-					sandboxDirectory: prev.sandbox.workingDirectory,
-					basePath: env.basePath
-				});
-				const sandboxFileByName = Object.fromEntries([...MutableHashMap.keys(prev.project.filesToMutate)].map((name) => [name, prev.sandbox.sandboxFileFor(name)]));
-				const currentRelativeFiles = yield* readCurrentRelativeFiles(prev.project, env.basePath);
-				const incremental = incrementalDiff({
-					currentMutants: plannableMutants,
-					testCoverage: prev.testCoverage,
-					incrementalReport: prev.project.incrementalReport,
-					currentRelativeFiles,
-					basePath: env.basePath,
-					force: prev.options.force
-				});
-				const rememberedResults = rememberedResultsOf(plannableMutants, incremental.remembered);
-				yield* Effect$1.when(Effect$1.logInfo(`Incremental mode: reusing ${rememberedResults.length} mutant result(s), running ${incremental.mutants.length} mutant(s).`), Effect$1.succeed(rememberedResults.length > 0));
-				const { runPlans, earlyResults: noCoverageResults } = partitionRunPlans(yield* decidePlans(incremental.mutants, prev.testCoverage, {
-					disableBail: prev.options.disableBail,
-					timeoutMS: prev.options.timeoutMS,
-					timeoutFactor: prev.options.timeoutFactor,
-					ignoreStatic: prev.options.ignoreStatic
-				}, Duration.toMillis(prev.timeOverhead), void 0, sandboxFileByName));
-				const sortedPlans = sortRunPlans(runPlans);
-				const allPlansForReporter = [...sortedPlans];
-				yield* offerReporterEvent(prev.reporterStage, MutationTestingPlanReady.make({
-					total: allPlansForReporter.length + noCoverageResults.length + rememberedResults.length,
-					plans: allPlansForReporter.map((plan) => ({
-						mutantId: plan.mutant.id,
-						plan: plan.plan,
-						netTime: plan.netTime,
-						reloadEnvironment: plan.runOptions.reloadEnvironment
-					}))
-				})).pipe(Effect$1.ignoreCause);
-				{
-					const queue2 = yield* RunEvents;
-					yield* Queue.offer(queue2, PlanKnown.make({ total: allPlansForReporter.length + noCoverageResults.length }));
-				}
-				const { passedPlans, checkerResults } = yield* checkPlansWithConfiguredCheckers(checkerPool, sortedPlans, reporting);
-				const testRunnerStream = Stream.fromIterable(passedPlans);
-				const plannedTotal = allPlansForReporter.length + noCoverageResults.length + rememberedResults.length;
-				const pathService = yield* Path.Path;
-				const progressQueue = yield* RunEvents;
-				const completedRef = yield* Ref.make(0);
-				const preparedStreamableOf = (result) => {
-					if (!isMutantStatus(result.status)) return;
-					return {
-						status: result.status,
-						file: reportFileName(pathService.relative(env.basePath, result.fileName)),
-						location: toSchemaLocation(result.location)
-					};
-				};
-				const toStreamEvent = (result, completed, prepared) => MutantTested.make({
+			};
+			const toStreamEvent = (result, completed, prepared) => MutantTested.make({
+				id: result.id,
+				status: prepared.status,
+				file: prepared.file,
+				location: prepared.location,
+				mutator: result.mutatorName,
+				replacement: result.replacement,
+				completed,
+				total: plannedTotal
+			});
+			const offerFinished = (result, prepared) => Effect$1.gen(function* () {
+				if (prepared === void 0) return;
+				const completed = yield* Ref.updateAndGet(completedRef, (n) => n + 1);
+				yield* Queue.offer(progressQueue, RunMutantTested.make({
 					id: result.id,
 					status: prepared.status,
 					file: prepared.file,
@@ -5377,90 +5249,76 @@ const mutationTestCell$1 = Cell.layer({
 					replacement: result.replacement,
 					completed,
 					total: plannedTotal
-				});
-				const offerFinished = (result, prepared) => Effect$1.gen(function* () {
-					if (prepared === void 0) return;
-					const completed = yield* Ref.updateAndGet(completedRef, (n) => n + 1);
-					yield* Queue.offer(progressQueue, RunMutantTested.make({
-						id: result.id,
-						status: prepared.status,
-						file: prepared.file,
-						location: prepared.location,
-						mutator: result.mutatorName,
-						replacement: result.replacement,
-						completed,
-						total: plannedTotal
-					}));
-					return completed;
-				});
-				const reportStreamTested = (result, completed, prepared) => offerReporterEvent(prev.reporterStage, toStreamEvent(result, completed, prepared)).pipe(Effect$1.catchCause((cause) => Effect$1.logWarning("Reporter stream failed handling mutantTested", cause)));
-				const offerStreamTested = (result, completed, prepared) => Option.match(Option.all([Option.fromNullishOr(completed), Option.fromNullishOr(prepared)]), {
-					onNone: () => Effect$1.void,
-					onSome: ([done, streamable]) => reportStreamTested(result, done, streamable)
-				});
-				const announceSettledMutant = (result) => Effect$1.gen(function* () {
-					const prepared = preparedStreamableOf(result);
-					const completed = yield* offerFinished(result, prepared);
-					yield* offerStreamTested(result, completed, prepared);
-				});
-				yield* Effect$1.forEach([
-					...rememberedResults,
-					...noCoverageResults,
-					...checkerResults
-				], announceSettledMutant, {
-					concurrency: 1,
-					discard: true
-				});
-				const completedMutants = yield* Ref.make([
-					...rememberedResults,
-					...noCoverageResults,
-					...checkerResults
-				]);
-				const checkpointGate = yield* Semaphore.make(1);
-				yield* reporting.checkpoint(yield* Ref.get(completedMutants)).pipe(Effect$1.catchCause((cause) => Effect$1.logWarning("Failed to persist the mutation checkpoint", cause)));
-				const persist = (result) => checkpointGate.withPermits(1)(Effect$1.gen(function* () {
-					const next = yield* Ref.updateAndGet(completedMutants, (prev) => [...prev, result]);
-					yield* reporting.checkpoint(next).pipe(Effect$1.catchCause((cause) => Effect$1.logWarning("Failed to persist the mutation checkpoint", cause)));
 				}));
-				const runResults = yield* withPhaseSpan("mutationTest.batch", {
-					total: plannedTotal,
-					testRunners: prev.concurrency.testRunners
-				}, () => Stream.mapEffect(testRunnerStream, (plan) => Effect$1.scoped(Effect$1.gen(function* () {
-					const pool = testRunnerPool;
-					const runner = yield* Pool.get(pool);
-					const result = yield* runner.mutantRun(plan.runOptions).pipe(Effect$1.withSpan("stryker.testRunner.mutantRun", { attributes: {
-						"stryker.mutant.id": plan.mutant.id,
-						"stryker.mutant.mutator": plan.mutant.mutatorName,
-						"stryker.mutant.file": plan.mutant.fileName
-					} }), Effect$1.tap((runResult) => Effect$1.annotateCurrentSpan({ "stryker.mutant.status": runResult.status })), Effect$1.catchTags({
-						OutOfMemoryError: (error) => invalidateSlot(pool, runner, error),
-						ChildProcessCrashedError: (error) => invalidateSlot(pool, runner, error)
-					}));
-					const reported = yield* reporting.reportMutantRunResult(toReportedMutant(plan.mutant), result);
-					const prepared = preparedStreamableOf(reported);
-					const finished = yield* offerFinished(reported, prepared);
-					yield* offerStreamTested(reported, finished, prepared);
-					yield* persist(reported);
-					return reported;
-				})), { concurrency: Math.max(1, prev.concurrency.testRunners) }).pipe(Stream.runCollect, Effect$1.map((chunk) => [...chunk])));
-				const allResults = [
-					...rememberedResults,
-					...noCoverageResults,
-					...checkerResults,
-					...runResults
-				];
-				const outcomeResult = yield* reporting.reportAll(allResults);
-				const doneNow = yield* Clock.currentTimeMillis;
-				const elapsed = Duration.millis(doneNow - env.runStartedAt);
-				yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
-				return outcomeResult;
-			})), Match.exhaustive);
-		})).pipe(Effect$1.mapError((cause) => Match.value(cause).pipe(Match.tag("StageError", (stage) => stage), Match.tag("ChildProcessCrashedError", "OutOfMemoryError", "PlatformError", "TestRunnerFailed", () => StageError.make({
-			stage: "mutationTest",
-			reason: "Mutation testing failed",
-			cause
-		})), Match.exhaustive)));
-	}
+				return completed;
+			});
+			const reportStreamTested = (result, completed, prepared) => offerReporterEvent(prev.reporterStage, toStreamEvent(result, completed, prepared)).pipe(Effect$1.tapCause((cause) => Effect$1.logWarning("Reporter stream failed handling mutantTested", cause)), Effect$1.ignoreCause);
+			const offerStreamTested = (result, completed, prepared) => Option.match(Option.all([Option.fromNullishOr(completed), Option.fromNullishOr(prepared)]), {
+				onNone: () => Effect$1.void,
+				onSome: ([done, streamable]) => reportStreamTested(result, done, streamable)
+			});
+			const announceSettledMutant = (result) => Effect$1.gen(function* () {
+				const prepared = preparedStreamableOf(result);
+				const completed = yield* offerFinished(result, prepared);
+				yield* offerStreamTested(result, completed, prepared);
+			});
+			yield* Effect$1.forEach([
+				...rememberedResults,
+				...noCoverageResults,
+				...checkerResults
+			], announceSettledMutant, {
+				concurrency: 1,
+				discard: true
+			});
+			const completedMutants = yield* Ref.make([
+				...rememberedResults,
+				...noCoverageResults,
+				...checkerResults
+			]);
+			const checkpointGate = yield* Semaphore.make(1);
+			yield* reporting.checkpoint(yield* Ref.get(completedMutants)).pipe(Effect$1.tapCause((cause) => Effect$1.logWarning("Failed to persist the mutation checkpoint", cause)), Effect$1.ignoreCause);
+			const persist = (result) => checkpointGate.withPermits(1)(Effect$1.gen(function* () {
+				const next = yield* Ref.updateAndGet(completedMutants, (prev) => [...prev, result]);
+				yield* reporting.checkpoint(next).pipe(Effect$1.tapCause((cause) => Effect$1.logWarning("Failed to persist the mutation checkpoint", cause)), Effect$1.ignoreCause);
+			}));
+			const runResults = yield* withPhaseSpan("mutationTest.batch", {
+				total: plannedTotal,
+				testRunners: prev.concurrency.testRunners
+			}, () => Stream.mapEffect(testRunnerStream, (plan) => Effect$1.scoped(Effect$1.gen(function* () {
+				const pool = testRunnerPool;
+				const runner = yield* Pool.get(pool);
+				const result = yield* runner.mutantRun(plan.runOptions).pipe(Effect$1.withSpan("stryker.testRunner.mutantRun", { attributes: {
+					"stryker.mutant.id": plan.mutant.id,
+					"stryker.mutant.mutator": plan.mutant.mutatorName,
+					"stryker.mutant.file": plan.mutant.fileName
+				} }), Effect$1.tap((runResult) => Effect$1.annotateCurrentSpan({ "stryker.mutant.status": runResult.status })), Effect$1.catchTags({
+					OutOfMemoryError: (error) => invalidateSlot(pool, runner, error),
+					ChildProcessCrashedError: (error) => invalidateSlot(pool, runner, error)
+				}));
+				const reported = yield* reporting.reportMutantRunResult(toReportedMutant(plan.mutant), result);
+				const prepared = preparedStreamableOf(reported);
+				const finished = yield* offerFinished(reported, prepared);
+				yield* offerStreamTested(reported, finished, prepared);
+				yield* persist(reported);
+				return reported;
+			})), { concurrency: Math.max(1, prev.concurrency.testRunners) }).pipe(Stream.runCollect, Effect$1.map((chunk) => [...chunk])));
+			const allResults = [
+				...rememberedResults,
+				...noCoverageResults,
+				...checkerResults,
+				...runResults
+			];
+			const outcomeResult = yield* reporting.reportAll(allResults);
+			const doneNow = yield* Clock.currentTimeMillis;
+			const elapsed = Duration.millis(doneNow - env.runStartedAt);
+			yield* Effect$1.logInfo(`Done in ${Duration.format(elapsed)}.`);
+			return outcomeResult;
+		})), Match.exhaustive);
+	})).pipe(Effect$1.mapError((cause) => Match.value(cause).pipe(Match.tag("StageError", (stage) => stage), Match.tag("ChildProcessCrashedError", "OutOfMemoryError", "PlatformError", "TestRunnerFailed", () => StageError.make({
+		stage: "mutationTest",
+		reason: "Mutation testing failed",
+		cause
+	})), Match.exhaustive)));
 });
 //#endregion
 //#region src/reporter-output.ts
@@ -5475,7 +5333,7 @@ const write = (stdio, channel, chunks) => Stream.run(Stream.fromIterable(chunks)
 * that cannot compose Effects — its writes fire inside a synchronous for-await).
 * Write errors are ignored like a broken pipe on a stream handle.
 *
-* Note: effect 4.0.0-rc.112 exports the runner as `Effect.runPromise`; there is no
+* Note: effect 4.0.0-rc.116 exports the runner as `Effect.runPromise`; there is no
 * `Runtime.runPromise` in this version (verified against the installed source) —
 * do not invent that import.
 */
@@ -5887,7 +5745,7 @@ const rememberTerminalReport = (seen, event) => {
 		};
 	}), Match.orElse(() => void 0));
 };
-const decodeClearTextReport = (terminal) => S.decodeUnknownEffect(ClearTextReportCommand)({
+const decodeClearTextReport = (terminal) => S.decodeEffect(ClearTextReportCommand)({
 	_tag: "ClearTextReportCommand",
 	report: terminal.report,
 	metrics: terminal.metrics
@@ -6329,13 +6187,7 @@ const writePrepare = (outcome, raw) => withPhaseSpan("prepare", {}, (span) => Ef
 		reporterStage
 	};
 }));
-const prepareCell = Cell.layer({
-	read: readPrepare,
-	decode: decodePrepare,
-	decide: planPrepare,
-	encode: encodePrepareDecision,
-	write: writePrepare
-});
+const prepareCell = Sandwich.read(readPrepare).decode(Sandwich.pure(decodePrepare)).decide(planPrepare).encode(Sandwich.pure((outcome) => Result.succeed(encodePrepareDecision(outcome)))).write(writePrepare);
 //#endregion
 //#region src/Run.ts
 const RUN_EVENTS_QUEUE_BOUND = 256;
@@ -6385,7 +6237,7 @@ const framedEventOf = (decision) => Option.match(decision, {
 	onSome: (d) => Match.value(d).pipe(Match.tag("EventFramed", (framed) => Result.succeed(framed.event)), Match.tag("EventSuppressed", () => Result.fail(void 0)), Match.exhaustive)
 });
 var RunEventDrain = class extends Context.Service()("@systemfsoftware/stryker-js/run-event-stream/RunEventDrain") {};
-const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect$1.withSpan("stryker.output.drain"), Effect$1.catchCause((cause) => Effect$1.logError("stryker.output.drain_failed", cause)));
+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 RunEventDrainLive = Layer.effect(RunEventDrain, Effect$1.gen(function* () {
 	const stdio = yield* Stdio.Stdio;
 	return RunEventDrain.of({
@@ -6552,7 +6404,7 @@ const RunEventDrainFileLive = Layer.effect(RunEventDrain, Effect$1.gen(function*
 		drainFramed: (framed) => Effect$1.gen(function* () {
 			const fileName = yield* Ref.get(fileNameRef);
 			yield* drainStdoutAndFile(fs, path, stdio, fileName, framed);
-		}).pipe(Effect$1.catchCause((cause) => Effect$1.logError("stryker.output.drain_file_failed", cause))),
+		}).pipe(Effect$1.tapCause((cause) => Effect$1.logError("stryker.output.drain_file_failed", cause)), Effect$1.ignoreCause),
 		setProgressStreamFile: (fileName) => Ref.set(fileNameRef, fileName)
 	});
 }));