@systemfsoftware/stryker-js-cli 4.0.2 → 5.0.0

package/dist/main.mjs

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
+import { n as nodePlatformLayer } from "./node-D-ynY_kk.mjs";
 import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
 import * as NodePath from "@effect/platform-node-shared/NodePath";
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import * as NodeStdio from "@effect/platform-node/NodeStdio";
-import { ConfigFileUnreadableError, buildVerdictEnvelope, defaultOptions, generateRunId, makeRunLayer, readConfig, runMutationTest, strykerEngines, strykerVersion, toRelativeNormalizedFileName } from "@systemfsoftware/stryker-js-platform-node";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import { ConfigFileUnreadableError, buildVerdictEnvelope, defaultOptions, generateRunId, makeRunLayer, readConfig, runMutationTest, strykerVersion, toRelativeNormalizedFileName } from "@systemfsoftware/stryker-js-engine";
+import { Mutant, causeText } from "@systemfsoftware/stryker-js/Mutant";
 import { Heartbeat, HelpRendered, ManifestRendered, RunEvents, RunFailed, RunStarted, VerdictReached } from "@systemfsoftware/stryker-js/Run";
 import { RENDERED_OPTION_DEFAULTS } from "@systemfsoftware/stryker-js/Schema";
 import * as Cause from "effect/Cause";
@@ -30,94 +31,21 @@ import * as CliError from "effect/unstable/cli/CliError";
 import * as Command from "effect/unstable/cli/Command";
 import * as Flag from "effect/unstable/cli/Flag";
 import * as GlobalFlag from "effect/unstable/cli/GlobalFlag";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
 import { ExitClass, highestExitClass } from "@systemfsoftware/stryker-js/ExitClass";
-import { Mutant, causeText } from "@systemfsoftware/stryker-js/Mutant";
 import * as Clock from "effect/Clock";
 import * as Formatter from "effect/Formatter";
 import * as Predicate from "effect/Predicate";
-import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Context from "effect/Context";
-import { pipe } from "effect/Function";
 import * as Stdio from "effect/Stdio";
 import * as Stream from "effect/Stream";
+import "@systemfsoftware/stryker-js/Module";
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
-//#region src/RunOutcome.workflow.ts
-var RunOutcomeCommand = class extends S.TaggedClass()("RunOutcomeCommand", {
-	succeeded: S.Boolean,
-	signal: S.optional(S.Finite),
-	interrupted: S.Boolean,
-	helpErrorCount: S.optional(S.Finite),
-	cliError: S.Boolean,
-	unrecognized: S.optional(S.String),
-	survivorsReason: S.optional(S.Literals(["no-report", "mismatch"])),
-	survivorsDiagnostic: S.optional(S.String),
-	schemaError: S.Boolean,
-	successExitClass: S.optional(ExitClass),
-	highestExitClass: S.optional(ExitClass),
-	configDetail: S.optional(S.String),
-	diagnostic: S.optional(S.String)
-}) {};
-const CONFIG_CODE$1 = 2;
-const classCode = (exitClass) => Match.value(exitClass).pipe(Match.when("VerdictFail", () => 1), Match.when("ConfigError", () => CONFIG_CODE$1), Match.when("RuntimeError", () => 3), Match.when("InternalError", () => 4), Match.exhaustive);
-var RunOk = class extends S.TaggedClass()("RunOk", { help: S.Boolean }) {};
-var RunInterrupted = class extends S.TaggedError()("RunInterrupted", { code: S.Finite }) {};
-var RunParseFailed = class extends S.TaggedError()("RunParseFailed", { unrecognized: S.optional(S.String) }) {};
-var RunSurvivorsRejected = class extends S.TaggedError()("RunSurvivorsRejected", {
-	reason: S.Literals(["no-report", "mismatch"]),
-	diagnostic: S.optional(S.String)
-}) {};
-var RunConfigFailed = class extends S.TaggedError()("RunConfigFailed", { detail: S.optional(S.String) }) {};
-var RunFailed$1 = class extends S.TaggedError()("RunFailed", {
-	code: S.Finite,
-	diagnostic: S.optional(S.String)
-}) {};
-function classify(command) {
-	if (command.signal !== void 0) return RunInterrupted.make({ code: 128 + command.signal });
-	if (command.succeeded) {
-		if (command.successExitClass !== void 0) return RunFailed$1.make({
-			code: classCode(command.successExitClass),
-			diagnostic: command.diagnostic
-		});
-		return RunOk.make({ help: false });
-	}
-	if (command.interrupted) return RunInterrupted.make({ code: 1 });
-	if (command.helpErrorCount !== void 0) {
-		if (command.helpErrorCount > 0) return RunParseFailed.make({ unrecognized: command.unrecognized });
-		return RunOk.make({ help: true });
-	}
-	if (command.cliError) return RunParseFailed.make({ unrecognized: command.unrecognized });
-	if (command.survivorsReason !== void 0) return RunSurvivorsRejected.make({
-		reason: command.survivorsReason,
-		diagnostic: command.survivorsDiagnostic
-	});
-	if (command.schemaError) return RunConfigFailed.make({ detail: command.configDetail });
-	if (command.highestExitClass !== void 0) {
-		if (command.highestExitClass === "ConfigError") return RunConfigFailed.make({ detail: command.configDetail });
-		return RunFailed$1.make({
-			code: classCode(command.highestExitClass),
-			diagnostic: command.diagnostic
-		});
-	}
-	return RunFailed$1.make({
-		code: 1,
-		diagnostic: command.diagnostic
-	});
-}
-function succeedRun(ok) {
-	return Result.succeed(ok);
-}
-function failRun(error) {
-	return Result.fail(error);
-}
-function runOutcomeDecision(command) {
-	return Match.value(classify(command)).pipe(Match.tag("RunOk", succeedRun), Match.tag("RunInterrupted", failRun), Match.tag("RunParseFailed", failRun), Match.tag("RunSurvivorsRejected", failRun), Match.tag("RunConfigFailed", failRun), Match.tag("RunFailed", failRun), Match.exhaustive);
-}
-const runOutcomeWorkflow = Workflow.make(RunOutcomeCommand, runOutcomeDecision);
+//#region package.json
+var engines = { "node": ">=20.0.0" };
 //#endregion
-//#region src/Survivors.workflow.ts
+//#region src/admit-survivors-run.workflow.ts
 /**
 * The mutant shape the admission carries, named once because both the decision's
 * `Admitted` payload and the command's precomputed survivor list are the same shape.
@@ -317,20 +245,91 @@ function admissionDecision(command) {
 }
 const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, admissionDecision);
 //#endregion
+//#region src/classify-run-outcome.workflow.ts
+var RunOutcomeCommand = class extends S.TaggedClass()("RunOutcomeCommand", {
+	succeeded: S.Boolean,
+	signal: S.optional(S.Finite),
+	interrupted: S.Boolean,
+	helpErrorCount: S.optional(S.Finite),
+	cliError: S.Boolean,
+	unrecognized: S.optional(S.String),
+	survivorsReason: S.optional(S.Literals(["no-report", "mismatch"])),
+	survivorsDiagnostic: S.optional(S.String),
+	schemaError: S.Boolean,
+	successExitClass: S.optional(ExitClass),
+	highestExitClass: S.optional(ExitClass),
+	configDetail: S.optional(S.String),
+	diagnostic: S.optional(S.String)
+}) {};
+const CONFIG_CODE$1 = 2;
+const classCode = (exitClass) => Match.value(exitClass).pipe(Match.when("VerdictFail", () => 1), Match.when("ConfigError", () => CONFIG_CODE$1), Match.when("RuntimeError", () => 3), Match.when("InternalError", () => 4), Match.exhaustive);
+const RunOutcomeTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/RunOutcome");
+var RunOk = class extends S.TaggedClass()("RunOk", { help: S.Boolean }) {
+	[RunOutcomeTypeId] = RunOutcomeTypeId;
+};
+var RunInterrupted = class extends S.TaggedError()("RunInterrupted", { code: S.Finite }) {
+	[RunOutcomeTypeId] = RunOutcomeTypeId;
+};
+var RunParseFailed = class extends S.TaggedClass()("RunParseFailed", { unrecognized: S.optional(S.String) }) {
+	[RunOutcomeTypeId] = RunOutcomeTypeId;
+};
+var RunSurvivorsRejected = class extends S.TaggedClass()("RunSurvivorsRejected", {
+	reason: S.Literals(["no-report", "mismatch"]),
+	diagnostic: S.optional(S.String)
+}) {
+	[RunOutcomeTypeId] = RunOutcomeTypeId;
+};
+var RunConfigFailed = class extends S.TaggedClass()("RunConfigFailed", { detail: S.optional(S.String) }) {
+	[RunOutcomeTypeId] = RunOutcomeTypeId;
+};
+var RunFailed$1 = class extends S.TaggedClass()("RunFailed", {
+	code: S.Finite,
+	diagnostic: S.optional(S.String)
+}) {
+	[RunOutcomeTypeId] = RunOutcomeTypeId;
+};
+function classify(command) {
+	if (command.signal !== void 0) return RunInterrupted.make({ code: 128 + command.signal });
+	if (command.succeeded) {
+		if (command.successExitClass !== void 0) return RunFailed$1.make({
+			code: classCode(command.successExitClass),
+			diagnostic: command.diagnostic
+		});
+		return RunOk.make({ help: false });
+	}
+	if (command.interrupted) return RunInterrupted.make({ code: 1 });
+	if (command.helpErrorCount !== void 0) {
+		if (command.helpErrorCount > 0) return RunParseFailed.make({ unrecognized: command.unrecognized });
+		return RunOk.make({ help: true });
+	}
+	if (command.cliError) return RunParseFailed.make({ unrecognized: command.unrecognized });
+	if (command.survivorsReason !== void 0) return RunSurvivorsRejected.make({
+		reason: command.survivorsReason,
+		diagnostic: command.survivorsDiagnostic
+	});
+	if (command.schemaError) return RunConfigFailed.make({ detail: command.configDetail });
+	if (command.highestExitClass !== void 0) {
+		if (command.highestExitClass === "ConfigError") return RunConfigFailed.make({ detail: command.configDetail });
+		return RunFailed$1.make({
+			code: classCode(command.highestExitClass),
+			diagnostic: command.diagnostic
+		});
+	}
+	return RunFailed$1.make({
+		code: 1,
+		diagnostic: command.diagnostic
+	});
+}
+const classifyRunOutcome$1 = Workflow.make(RunOutcomeCommand, (command) => Match.value(classify(command)).pipe(Match.tag("RunInterrupted", (error) => Result.fail(error)), Match.when((outcome) => !(outcome instanceof RunInterrupted), (decision) => Result.succeed(decision)), Match.exhaustive));
+//#endregion
 //#region src/Envelope.ts
-/**
-* Envelope — the failure envelope and console capture leaf.
-*
-* Extracted from Cli.ts to break the import cycle Cli <-> Output.
-* Both Cli and Output import from this leaf, so neither depends on the other
-* for these values. This file imports only from external packages and from
-* StreamVersion (leaf) and Survivors.workflow (leaf), never from Cli or Output
-* themselves.
-*/
 const CONFIG_CODE = 2;
 function runOutcomeCode(result) {
-	if (Result.isSuccess(result)) return 0;
-	return Match.value(result.failure).pipe(Match.tag("RunInterrupted", (error) => error.code), Match.tag("RunParseFailed", () => CONFIG_CODE), Match.tag("RunSurvivorsRejected", () => CONFIG_CODE), Match.tag("RunConfigFailed", () => CONFIG_CODE), Match.tag("RunFailed", (error) => error.code), Match.exhaustive);
+	const outcome = Result.match(result, {
+		onSuccess: (success) => success,
+		onFailure: (failure) => failure
+	});
+	return Match.value(outcome).pipe(Match.tag("RunOk", () => 0), Match.tag("RunInterrupted", (error) => error.code), Match.tag("RunParseFailed", () => CONFIG_CODE), Match.tag("RunSurvivorsRejected", () => CONFIG_CODE), Match.tag("RunConfigFailed", () => CONFIG_CODE), Match.tag("RunFailed", (failed) => failed.code), Match.exhaustive);
 }
 function isExitClass(value) {
 	return S.is(ExitClass)(value);
@@ -577,7 +576,7 @@ function shapeEnvelope(error, captured) {
 	};
 }
 function classifyRunOutcome(exit, signal, argv) {
-	return runOutcomeWorkflow(gatherRunOutcome(exit, signal, argv));
+	return classifyRunOutcome$1(gatherRunOutcome(exit, signal, argv));
 }
 const capturedConsoleChunks = [];
 const countByLabel = /* @__PURE__ */ new Map();
@@ -684,12 +683,8 @@ function resetCapturedConsole() {
 	timeByLabel.clear();
 }
 //#endregion
-//#region src/Output.workflow.ts
+//#region src/resolve-output-mode.workflow.ts
 const TOOL_VARIABLES$1 = ["CLAUDECODE", "CODEX_SANDBOX"];
-/**
-* The command of the output-mode workflow: a schema class, because `Workflow.make`
-* derives the command type from it and pins the error channel at the construction site.
-*/
 var ResolveModeCommand = class extends S.TaggedClass()("ResolveModeCommand", {
 	stdoutIsTTY: S.Boolean,
 	text: S.optional(S.Boolean),
@@ -698,17 +693,33 @@ var ResolveModeCommand = class extends S.TaggedClass()("ResolveModeCommand", {
 	agent: S.optional(S.String),
 	toolVars: S.optional(S.Record(S.String, S.String))
 }) {};
-/**
-* The conflict error for mutually exclusive format flags. Defined locally so the
-* workflow decision remains pure — the sealed effect surface does not include
-* `effect/unstable/cli/CliError`, so the decision returns this local error and
-* the shell maps it to `CliError.InvalidValue` at the boundary.
-*/
+const ResolveModeTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/ResolveMode");
 var ModeConflictError = class extends S.TaggedError()("ModeConflictError", {
 	option: S.String,
 	value: S.String,
 	expected: S.String
-}) {};
+}) {
+	[ResolveModeTypeId] = ResolveModeTypeId;
+};
+const ModeSignal = S.Literals([
+	"flag",
+	"env",
+	"tty",
+	"agent",
+	"tool"
+]);
+var HumanOutput = class extends S.TaggedClass()("HumanOutput", {
+	signal: ModeSignal,
+	stdoutIsTTY: S.Boolean
+}) {
+	[ResolveModeTypeId] = ResolveModeTypeId;
+};
+var MachineOutput = class extends S.TaggedClass()("MachineOutput", {
+	signal: ModeSignal,
+	stdoutIsTTY: S.Boolean
+}) {
+	[ResolveModeTypeId] = ResolveModeTypeId;
+};
 const CONFLICT_EXPECTED = "the \"--format text\" and \"--json\" flags are mutually exclusive — use one or the other";
 function r4(command) {
 	if (command.text === true && command.json === true) return Result.fail(ModeConflictError.make({
@@ -716,71 +727,51 @@ function r4(command) {
 		value: "text",
 		expected: CONFLICT_EXPECTED
 	}));
-	if (command.text === true) return Result.succeed({
-		mode: "human",
+	if (command.text === true) return Result.succeed(HumanOutput.make({
 		signal: "flag",
 		stdoutIsTTY: command.stdoutIsTTY
-	});
-	if (command.json === true) return Result.succeed({
-		mode: "machine",
+	}));
+	if (command.json === true) return Result.succeed(MachineOutput.make({
 		signal: "flag",
 		stdoutIsTTY: command.stdoutIsTTY
-	});
+	}));
 	if (command.envMode !== void 0 && command.envMode.length > 0) {
-		if (command.envMode === "machine") return Result.succeed({
-			mode: "machine",
+		if (command.envMode === "machine") return Result.succeed(MachineOutput.make({
 			signal: "env",
 			stdoutIsTTY: command.stdoutIsTTY
-		});
-		return Result.succeed({
-			mode: "human",
+		}));
+		return Result.succeed(HumanOutput.make({
 			signal: "env",
 			stdoutIsTTY: command.stdoutIsTTY
-		});
+		}));
 	}
-	if (!command.stdoutIsTTY) return Result.succeed({
-		mode: "machine",
+	if (!command.stdoutIsTTY) return Result.succeed(MachineOutput.make({
 		signal: "tty",
 		stdoutIsTTY: false
-	});
-	if (command.agent !== void 0 && command.agent.length > 0) return Result.succeed({
-		mode: "machine",
+	}));
+	if (command.agent !== void 0 && command.agent.length > 0) return Result.succeed(MachineOutput.make({
 		signal: "agent",
 		stdoutIsTTY: true
-	});
+	}));
 	const toolVars = command.toolVars ?? {};
 	for (const variable of TOOL_VARIABLES$1) {
 		const value = toolVars[variable];
-		if (typeof value === "string" && value.length > 0) return Result.succeed({
-			mode: "machine",
+		if (typeof value === "string" && value.length > 0) return Result.succeed(MachineOutput.make({
 			signal: "tool",
 			stdoutIsTTY: true
-		});
+		}));
 	}
-	return Result.succeed({
-		mode: "human",
+	return Result.succeed(HumanOutput.make({
 		signal: "tty",
 		stdoutIsTTY: true
-	});
+	}));
 }
 function modeDecision(command) {
 	return r4(command);
 }
-const resolveModeWorkflow = Workflow.make(ResolveModeCommand, modeDecision);
+const resolveOutputMode = Workflow.make(ResolveModeCommand, modeDecision);
 //#endregion
 //#region src/Output.ts
-/**
-* Output — the machine/human output capability.
-*
-* The NDJSON run-event stream, wire protocol constants, mode resolution probes,
-* and machine-mode terminal output. Pure mode resolution lives in
-* Output.workflow.ts.
-*/
-/**
-* The heartbeat interval (R19), matching Terraform's `apply_progress`
-* cadence: long enough that a slow phase is not noisy, short enough that a
-* consumer can tell "slow" from "hung" without waiting for a mutant event.
-*/
 const TICK_INTERVAL_MS = 1e4;
 var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/Output/RunEventStreamPortTag") {};
 const RunEventStreamPort = RunEventStreamPortTag;
@@ -892,12 +883,15 @@ const makeRunEventStream = (stdio, resolved, drainFramed = drainOf.bind(null, st
 });
 Layer.effect(RunEventStreamPort, Effect.map(Stdio.Stdio, (stdio) => RunEventStreamPort.of({ createRunEventStream: (resolved) => makeRunEventStream(stdio, resolved) })));
 const TOOL_VARIABLES = ["CLAUDECODE", "CODEX_SANDBOX"];
-/**
-* The log colouriser's gate (R8). Machine mode never emits colour, so a
-* harness merging `2>&1` is not handed escape sequences it must strip, and
-* `NO_COLOR` is honoured for the human path per the convention: any value
-* other than an unset or empty variable disables colour.
-*/
+const decisionToResolvedMode = (decision) => Match.value(decision).pipe(Match.tag("HumanOutput", (human) => ({
+	mode: "human",
+	signal: human.signal,
+	stdoutIsTTY: human.stdoutIsTTY
+})), Match.tag("MachineOutput", (machine) => ({
+	mode: "machine",
+	signal: machine.signal,
+	stdoutIsTTY: machine.stdoutIsTTY
+})), Match.exhaustive);
 function isColorEnabled(resolved, noColor) {
 	if (resolved.mode !== "human") return false;
 	if (noColor === void 0) return true;
@@ -906,83 +900,80 @@ function isColorEnabled(resolved, noColor) {
 }
 var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/Output/OutputModeProbeTag") {};
 const OutputModeProbe = OutputModeProbeTag;
-const outputModeProbeDescription = pipe(Cell.read((command) => Effect.succeed((() => {
-	const toolVarsRecord = {};
-	for (const variable of TOOL_VARIABLES) {
-		const value = process.env[variable];
-		if (value !== void 0) toolVarsRecord[variable] = value;
-	}
-	const envMode = process.env["STRYKER_MODE"];
-	const agent = process.env["AGENT"];
-	let result = { stdoutIsTTY: process.stdout.isTTY === true };
-	if (Object.keys(toolVarsRecord).length > 0) result = {
-		...result,
-		toolVars: toolVarsRecord
-	};
-	if (envMode !== void 0) result = {
-		...result,
-		envMode
-	};
-	if (agent !== void 0) result = {
-		...result,
-		agent
-	};
-	if (command.text !== void 0) result = {
-		...result,
-		text: command.text
-	};
-	if (command.json !== void 0) result = {
-		...result,
-		json: command.json
-	};
-	return result;
-})())), Cell.decode((raw) => Result.succeed((() => {
-	const filteredToolVars = {};
-	if (raw.toolVars !== void 0) {
-		for (const [key, value] of Object.entries(raw.toolVars)) if (value !== void 0) filteredToolVars[key] = value;
-	}
-	let commandInput = { stdoutIsTTY: raw.stdoutIsTTY };
-	if (raw.text !== void 0) commandInput = {
-		...commandInput,
-		text: raw.text
-	};
-	if (raw.json !== void 0) commandInput = {
-		...commandInput,
-		json: raw.json
-	};
-	if (raw.envMode !== void 0) commandInput = {
-		...commandInput,
-		envMode: raw.envMode
-	};
-	if (raw.agent !== void 0) commandInput = {
-		...commandInput,
-		agent: raw.agent
-	};
-	if (Object.keys(filteredToolVars).length > 0) commandInput = {
-		...commandInput,
-		toolVars: filteredToolVars
-	};
-	return ResolveModeCommand.make(commandInput);
-})())), Cell.decide(resolveModeWorkflow), Cell.encode((outcome) => outcome), Cell.write((outcome) => Result.match(outcome, {
-	onFailure: (error) => Effect.fail(error),
-	onSuccess: (mode) => Effect.succeed(mode)
-})));
-const detectModeWithProbe = (flags = {}) => Cell.apply(outputModeProbeDescription, flags).pipe(Effect.mapError((error) => CliError.InvalidValue.make({
+const outputModeProbeCell = Cell.layer({
+	read: (command) => Effect.succeed((() => {
+		const toolVarsRecord = {};
+		for (const variable of TOOL_VARIABLES) {
+			const value = process.env[variable];
+			if (value !== void 0) toolVarsRecord[variable] = value;
+		}
+		const envMode = process.env["STRYKER_MODE"];
+		const agent = process.env["AGENT"];
+		let result = { stdoutIsTTY: process.stdout.isTTY === true };
+		if (Object.keys(toolVarsRecord).length > 0) result = {
+			...result,
+			toolVars: toolVarsRecord
+		};
+		if (envMode !== void 0) result = {
+			...result,
+			envMode
+		};
+		if (agent !== void 0) result = {
+			...result,
+			agent
+		};
+		if (command.text !== void 0) result = {
+			...result,
+			text: command.text
+		};
+		if (command.json !== void 0) result = {
+			...result,
+			json: command.json
+		};
+		return result;
+	})()),
+	decode: (raw) => Result.succeed((() => {
+		const filteredToolVars = {};
+		if (raw.toolVars !== void 0) {
+			for (const [key, value] of Object.entries(raw.toolVars)) if (value !== void 0) filteredToolVars[key] = value;
+		}
+		let commandInput = { stdoutIsTTY: raw.stdoutIsTTY };
+		if (raw.text !== void 0) commandInput = {
+			...commandInput,
+			text: raw.text
+		};
+		if (raw.json !== void 0) commandInput = {
+			...commandInput,
+			json: raw.json
+		};
+		if (raw.envMode !== void 0) commandInput = {
+			...commandInput,
+			envMode: raw.envMode
+		};
+		if (raw.agent !== void 0) commandInput = {
+			...commandInput,
+			agent: raw.agent
+		};
+		if (Object.keys(filteredToolVars).length > 0) commandInput = {
+			...commandInput,
+			toolVars: filteredToolVars
+		};
+		return ResolveModeCommand.make(commandInput);
+	})()),
+	decide: resolveOutputMode,
+	encode: (outcome) => Result.map(outcome, decisionToResolvedMode),
+	write: (outcome) => Result.match(outcome, {
+		onFailure: (error) => Effect.fail(error),
+		onSuccess: (mode) => Effect.succeed(mode)
+	})
+});
+const detectModeWithProbe = (flags = {}) => Cell.run(outputModeProbeCell, flags).pipe(Effect.mapError((error) => CliError.InvalidValue.make({
 	option: error.option,
 	value: error.value,
 	expected: error.expected,
 	kind: "flag"
 })));
 const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({ detectMode: detectModeWithProbe({}) }));
-/**
-* Machine mode emits the U4 verdict envelope for a run that produced no
-* mutants and no report file: a `--survivors` run with zero survivors (AE3)
-* or a successful `--dryRunOnly` run that ended before the mutation
-* pipeline. The envelope carries a null score and an empty mutant list and is
-* written as the terminal `verdict` line of the stdout stream (U6), carrying
-* the run id the stream header already opened with (KTD11 — never a fresh
-* id). Human mode prints nothing (the sink drops in human mode).
-*/
 function emitNullScoreVerdict(stream, mode, thresholds, config, basePath, pathService) {
 	const envelope = buildVerdictEnvelope({
 		schemaVersion: "1.0",
@@ -1007,49 +998,41 @@ function emitNullScoreVerdict(stream, mode, thresholds, config, basePath, pathSe
 		mutants: envelope.mutants
 	}));
 }
-/**
-* Emits the machine-mode output from the run's finalizer — it runs on
-* success, failure and interruption alike (R30): a failed run writes the
-* `error` terminal event as the last line of the stdout stream; a successful
-* run whose only console output was the framework's help/version rendering
-* emits that captured document as the `help` terminal event, so `--help` in
-* machine mode never leaks an ANSI document. A successful run with an empty
-* buffer (the normal verdict path) emits nothing extra — the run already
-* wrote its terminal `verdict` line through the same module — unless the
-* stream is still open, which means the run never reached a verdict (the
-* `--dryRunOnly` early return): then a null-score `verdict` closes the
-* stream so the last stdout line is always a terminal event (R5).
-*/
+function offerFailureEnvelope(stream, failed, captured) {
+	const envelope = shapeEnvelope(failed, captured);
+	return Queue.offer(stream.queue, RunFailed.make({
+		schemaVersion: envelope.schemaVersion,
+		code: envelope.code,
+		error: envelope.error,
+		remediation: envelope.remediation
+	}));
+}
 function emitMachineModeOutput(stream, mode, outcome, basePath, pathService) {
 	return Effect.gen(function* () {
 		const captured = readCapturedConsole();
 		if (Result.isSuccess(outcome)) {
-			if (outcome.success.help) {
-				yield* Queue.offer(stream.queue, HelpRendered.make({
-					schemaVersion: "1.0",
-					code: 0,
-					help: captured
-				}));
-				return;
-			}
-			if (captured.length > 0) {
-				yield* Queue.offer(stream.queue, HelpRendered.make({
-					schemaVersion: "1.0",
-					code: 0,
-					help: captured
-				}));
-				return;
-			}
-			if (stream.isOpen()) yield* emitNullScoreVerdict(stream, mode, (yield* defaultOptions).thresholds, {}, basePath, pathService);
-			return;
+			const decision = outcome.success;
+			return yield* Match.value(decision).pipe(Match.tag("RunOk", (ok) => Effect.gen(function* () {
+				if (ok.help) {
+					yield* Queue.offer(stream.queue, HelpRendered.make({
+						schemaVersion: "1.0",
+						code: 0,
+						help: captured
+					}));
+					return;
+				}
+				if (captured.length > 0) {
+					yield* Queue.offer(stream.queue, HelpRendered.make({
+						schemaVersion: "1.0",
+						code: 0,
+						help: captured
+					}));
+					return;
+				}
+				if (stream.isOpen()) yield* emitNullScoreVerdict(stream, mode, (yield* defaultOptions).thresholds, {}, basePath, pathService);
+			})), Match.tag("RunParseFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.tag("RunSurvivorsRejected", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.tag("RunConfigFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.tag("RunFailed", (failed) => offerFailureEnvelope(stream, failed, captured)), Match.exhaustive);
 		}
-		const envelope = shapeEnvelope(outcome.failure, captured);
-		yield* Queue.offer(stream.queue, RunFailed.make({
-			schemaVersion: envelope.schemaVersion,
-			code: envelope.code,
-			error: envelope.error,
-			remediation: envelope.remediation
-		}));
+		return yield* offerFailureEnvelope(stream, outcome.failure, captured);
 	});
 }
 //#endregion
@@ -1088,7 +1071,7 @@ const RunEventStreamFileLive = Layer.effect(RunEventStreamPort, Effect.gen(funct
 *
 * The prior-report decoding, source hashing, mutant conversion, and admission
 * pipeline for --survivors runs. Pure admission decision lives in
-* Survivors.workflow.ts.
+* admit-survivors-run.workflow.ts.
 */
 const DEFAULT_SURVIVORS_PRIOR_REPORT = "reports/mutation-report.json";
 /**
@@ -1184,87 +1167,57 @@ function survivorMutateSpans(survivors, basePath) {
 	return spans;
 }
 const hashContent = (content) => bytesToHex(sha256(utf8ToBytes(content)));
-const resolveAbsolutePath = (file) => resolve(file);
-/**
-* The survivors admission, as a description whose phases chain by type and
-* read in the order they run. The read gathers the admission's whole input
-* product — resolved options, prior report and the current source hashes —
-* across its interior and stashes the shell context the write dispatches on
-* into the executor-owned `runContext` ref; `decode` packages exactly the
-* workflow input; `admitSurvivorsRun` is the decide phase; `encode` is the
-* identity because write receives the outcome as-is; the write reads the
-* stashed context back and dispatches the decision to the verdict/run,
-* failing the run with a rejection.
-*/
-const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext, basePath, services) => pipe(Cell.read((cliOptions) => Effect.provideContext(Effect.flatMap(Path.Path, (pathService) => resolveSurvivorsRunOptions(cliOptions, basePath).pipe(Effect.flatMap((resolvedOptions) => {
-	const priorReportPath = priorReportPathOf(resolvedOptions);
-	return Effect.flatMap(readPriorReport(priorReportPath), (read) => Effect.flatMap(currentSourceHashesFor(priorReportFileKeys(read.raw)), (sourceContentHashes) => Ref.set(runContext, {
-		resolvedOptions,
-		priorReportPath,
-		pathService
-	}).pipe(Effect.as({
-		resolvedOptions,
-		priorReportRaw: read.raw,
-		priorReportFound: read.found,
-		priorReportPath,
-		sourceContentHashes
-	}))));
-}))), services)), Cell.decode(({ resolvedOptions, priorReportRaw, priorReportFound, sourceContentHashes }) => {
-	if (!priorReportFound) return Result.succeed(AdmitSurvivorsRunCommand.make({
-		priorReport: void 0,
-		currentConfig: resolvedOptions,
-		frameworkVersion: strykerVersion,
-		sourceContentHashes,
-		priorSourceHashes: {},
-		priorSurvivors: []
-	}));
-	return Result.map(decodePriorReport(priorReportRaw), (document) => AdmitSurvivorsRunCommand.make({
-		priorReport: PriorReportFacts.make({
-			config: document.config ?? {},
-			frameworkVersion: document.framework?.version
+const survivorsAdmissionCell = (basePath) => Cell.layer({
+	read: (cliOptions) => Effect.gen(function* () {
+		const pathService = yield* Path.Path;
+		const resolvedOptions = yield* resolveSurvivorsRunOptions(cliOptions, basePath);
+		const priorReportPath = priorReportPathOf(resolvedOptions);
+		const resolveAbsolutePath = (file) => pathService.resolve(file);
+		const read = yield* readPriorReport(priorReportPath);
+		const sourceContentHashes = yield* currentSourceHashesFor(priorReportFileKeys(read.raw));
+		return {
+			resolvedOptions,
+			priorReportRaw: read.raw,
+			priorReportFound: read.found,
+			priorReportPath,
+			sourceContentHashes,
+			resolveAbsolutePath
+		};
+	}),
+	decode: ({ resolvedOptions, priorReportRaw, priorReportFound, sourceContentHashes, resolveAbsolutePath }) => {
+		if (!priorReportFound) return Result.succeed(AdmitSurvivorsRunCommand.make({
+			priorReport: void 0,
+			currentConfig: resolvedOptions,
+			frameworkVersion: strykerVersion,
+			sourceContentHashes,
+			priorSourceHashes: {},
+			priorSurvivors: []
+		}));
+		return Result.map(decodePriorReport(priorReportRaw), (document) => AdmitSurvivorsRunCommand.make({
+			priorReport: PriorReportFacts.make({
+				config: document.config ?? {},
+				frameworkVersion: document.framework?.version
+			}),
+			currentConfig: resolvedOptions,
+			frameworkVersion: strykerVersion,
+			sourceContentHashes,
+			priorSourceHashes: priorSourceHashes(document, hashContent),
+			priorSurvivors: extractSurvivors(document, resolveAbsolutePath)
+		}));
+	},
+	decide: admitSurvivorsRun,
+	encode: (outcome) => outcome,
+	write: (outcome, raw) => Result.match(outcome, {
+		onSuccess: (admission) => Effect.succeed({
+			admission,
+			resolvedOptions: raw.resolvedOptions,
+			priorReportPath: raw.priorReportPath
 		}),
-		currentConfig: resolvedOptions,
-		frameworkVersion: strykerVersion,
-		sourceContentHashes,
-		priorSourceHashes: priorSourceHashes(document, hashContent),
-		priorSurvivors: extractSurvivors(document, resolveAbsolutePath)
-	}));
-}), Cell.decide(admitSurvivorsRun), Cell.encode((outcome) => outcome), Cell.write((outcome) => Effect.flatMap(Ref.get(runContext), (context) => {
-	if (context === void 0) return Effect.die("the survivors admission read must run before its write");
-	const { resolvedOptions, priorReportPath, pathService } = context;
-	return Result.match(outcome, {
-		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("NoSurvivors", () => emitNullScoreVerdict(stream, mode, resolvedOptions.thresholds, resolvedOptions, basePath, pathService)), Match.tag("Admitted", (admitted) => {
-			const admittedMutants = admitted.survivors.map((s) => Mutant.make(s));
-			return runMutationTest({
-				...resolvedOptions,
-				survivors: admittedMutants,
-				mutate: survivorMutateSpans(admittedMutants, basePath),
-				survivorsPriorReport: priorReportPath,
-				incremental: false
-			}).pipe(Effect.orDie);
-		}), Match.orElse(() => Effect.die("unreachable admission decision variant"))),
-		onFailure: (rejection) => Effect.fail(rejection)
-	});
-})));
-/**
-* The `--survivors` request: re-test exactly the prior report's survivor set.
-* The survivors flag was parsed as a boolean; the admission decides between
-* running the survivors and the plain pipeline. The chain's order is carried by
-* the description's phase types; the run's resolved context cell is created
-* here, beside the description it feeds.
-*
-* Two failures reach the caller, and they are not the same thing. A rejection is the
-* decision's own outcome — the run was inspected and refused. A `SchemaError` is a prior
-* report that was present and did not decode, which stops the chain before any decision
-* is made; it is in this signature because the phase types put it there, not because the
-* admission chose it.
-*/
-function runSurvivorsAdmission(runMutationTest, stream, mode, cliOptions, basePath) {
-	return Effect.gen(function* () {
-		const services = yield* Effect.context();
-		const admissionContext = yield* Ref.make(void 0);
-		return yield* Cell.apply(survivorsAdmissionDescription(runMutationTest, stream, mode, admissionContext, basePath, services), cliOptions);
-	});
+		onFailure: Effect.fail
+	})
+});
+function runSurvivorsAdmission(cliOptions, basePath) {
+	return Cell.run(survivorsAdmissionCell(basePath), cliOptions);
 }
 function resolveSurvivorsRunOptions(cliOptions, basePath) {
 	return readConfig(cliOptions, basePath);
@@ -1513,37 +1466,47 @@ function describeCommandNode(node) {
 	};
 }
 function readCoreEntries() {
-	try {
-		const manifestPath = createRequire(import.meta.url).resolve("@systemfsoftware/stryker-js-platform-node/package.json");
-		const raw = readFileSync(manifestPath, "utf-8");
-		const parsed = JSON.parse(raw);
+	return Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const fs = yield* FileSystem.FileSystem;
+		const resolved = import.meta.resolve("@systemfsoftware/stryker-js-engine/package.json");
+		const manifestPath = yield* path.fromFileUrl(new URL(resolved));
+		const raw = yield* fs.readFileString(manifestPath);
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return [];
+		}
 		const ExportsSchema = S.Struct({ exports: S.Record(S.String, S.Unknown) });
 		const decoded = S.decodeUnknownResult(ExportsSchema)(parsed);
 		if (Result.isSuccess(decoded)) return Object.keys(decoded.success.exports).filter((key) => key !== "./package.json");
 		return [];
-	} catch {
-		return [];
-	}
+	}).pipe(Effect.catchCause(() => {
+		return Effect.succeed([]);
+	}));
 }
 function buildLLMSManifest(command, version) {
-	const root = describeCommandNode(command) ?? {
-		name: "",
-		description: "",
-		options: [],
-		args: [],
-		subcommands: []
-	};
-	return {
-		schemaVersion: "1.0",
-		tool: root.name,
-		version,
-		commands: [root],
-		entries: readCoreEntries()
-	};
+	return Effect.gen(function* () {
+		const root = describeCommandNode(command) ?? {
+			name: "",
+			description: "",
+			options: [],
+			args: [],
+			subcommands: []
+		};
+		const entries = yield* readCoreEntries();
+		return {
+			schemaVersion: "1.0",
+			tool: root.name,
+			version,
+			commands: [root],
+			entries
+		};
+	});
 }
-/** The manifest as one JSON document, ready for stdout — the U4 convention. */
 function emitLLMSManifest(command, version) {
-	return JSON.stringify(buildLLMSManifest(command, version));
+	return Effect.map(buildLLMSManifest(command, version), (manifest) => JSON.stringify(manifest));
 }
 function createSplitter(separator) {
 	return (value) => value.split(separator).filter(Boolean);
@@ -1716,39 +1679,26 @@ function makeStrykerCommand(requestRef) {
 		if (Option.isSome(config["configFile"])) options["configFile"] = config["configFile"].value;
 		return options;
 	}
-	const strykerCommand = Command.make("stryker", rootConfig, (config) => {
+	const strykerCommand = Command.make("stryker", rootConfig, (config) => Effect.gen(function* () {
 		if (config.llms === true) {
 			const document = {
 				_tag: "manifest",
 				schemaVersion: "1.0",
 				code: 0,
-				manifest: emitLLMSManifest(strykerCommand, strykerVersion)
+				manifest: yield* emitLLMSManifest(strykerCommand, strykerVersion)
 			};
-			return Ref.set(requestRef, Option.some({
+			return yield* Ref.set(requestRef, Option.some({
 				_tag: "llms",
 				document
 			}));
 		}
-		return Effect.failSync(() => CliError.ShowHelp.make({
+		return yield* Effect.failSync(() => CliError.ShowHelp.make({
 			commandPath: ["stryker"],
 			errors: []
 		}));
-	}).pipe(Command.withSubcommands([runCommand]));
+	})).pipe(Command.withSubcommands([runCommand]));
 	return strykerCommand;
 }
-/**
-* The CLI parses only text/number/choice options, so the framework's platform
-* services are never read at runtime; the v4 runner still demands them in its
-* environment. The bootstrap provides `Path.layer` (the universal
-* implementation in `effect/Path`), an *empty* file system (`layerNoop`:
-* every operation reports not-found), and a process-stdio `Terminal` whose
-* interactive input primitives fail loudly — the run-only surface (R14) has
-* no prompts. `@effect/platform-node` is a declared dependency of this
-* package (it provides the `NodeRuntime` the bin runs through), but no
-* platform-node service is wired into the command environment: the parser
-* never reads a real file system at run time, so the noop layers are
-* sufficient.
-*/
 const terminalLayer = Layer.succeed(Terminal.Terminal, Terminal.make({
 	columns: Effect.sync(() => process.stdout.columns),
 	rows: Effect.sync(() => process.stdout.rows),
@@ -1767,7 +1717,7 @@ const cliLayer = Layer.mergeAll(CliConfig.layer({ builtIns: [
 	GlobalFlag.Wizard,
 	GlobalFlag.Completions,
 	GlobalFlag.LogLevel
-] }), Path.layer, FileSystem.layerNoop({}), terminalLayer, NodeStdio.layer, NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer))));
+] }), Path.layer, NodeFileSystem.layer, terminalLayer, NodeStdio.layer, NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer))));
 function strykerCliEffect(argv, runMutationTest, detectMode, createRunEventStream, lastSignal) {
 	return Effect.gen(function* () {
 		const mode = yield* detectMode;
@@ -1790,14 +1740,15 @@ function strykerCliEffect(argv, runMutationTest, detectMode, createRunEventStrea
 		return result.success;
 	}).pipe(Effect.orElseSucceed(() => 2));
 }
-const defaultRunMutationTest = (hostOptions, queue) => (options) => Effect.scoped(runMutationTest(options)).pipe(Effect.provideService(RunEvents, queue), Effect.provide(makeRunLayer(hostOptions)));
+const hostRunLayer = (hostOptions, queue) => makeRunLayer(hostOptions, queue).pipe(Layer.provideMerge(nodePlatformLayer));
+const defaultRunMutationTest = (hostOptions, queue) => (...args) => Effect.scoped(runMutationTest(...args)).pipe(Effect.provide(hostRunLayer(hostOptions, queue)), Effect.provideService(RunEvents, queue));
 function hostOptionsOf(mode, stream) {
 	return {
 		runId: stream.runId,
 		resolvedMode: mode,
 		runStartedAt: stream.startedAt,
-		basePath: resolve(process.cwd()),
-		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-html-reporter"), import.meta.resolve("@systemfsoftware/stryker-js-platform-node/builtin-reporters")],
+		basePath: process.cwd(),
+		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-html-reporter"), import.meta.resolve("@systemfsoftware/stryker-js-engine/builtin-reporters")],
 		allowConsoleColors: isColorEnabled(mode, process.env["NO_COLOR"])
 	};
 }
@@ -1814,7 +1765,20 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 		if (currentFiber !== null) currentFiber.interruptUnsafe(currentFiber.id);
 	};
 	const dispatch = (request) => Match.value(request).pipe(Match.tag("run", (runRequest) => (() => {
-		if (runRequest.survivors) return runSurvivorsAdmission(runMutationTestImpl, stream, input.mode, runRequest.options, basePath).pipe(Effect.provide(makeRunLayer(hostOptions)));
+		if (runRequest.survivors) return Effect.gen(function* () {
+			const { admission, resolvedOptions, priorReportPath } = yield* runSurvivorsAdmission(runRequest.options, basePath).pipe(Effect.provide(hostRunLayer(hostOptions)));
+			return yield* Match.value(admission).pipe(Match.tag("NoSurvivors", () => emitNullScoreVerdict(stream, input.mode, resolvedOptions.thresholds, resolvedOptions, basePath, pathService)), Match.tag("Admitted", (admitted) => {
+				const admittedMutants = admitted.survivors.map((s) => Mutant.make(s));
+				const restricted = {
+					...resolvedOptions,
+					survivors: admittedMutants,
+					mutate: survivorMutateSpans(admittedMutants, basePath),
+					survivorsPriorReport: priorReportPath,
+					incremental: false
+				};
+				return runMutationTestImpl(restricted).pipe(Effect.orDie);
+			}), Match.exhaustive);
+		});
 		return runMutationTestImpl(runRequest.options).pipe(Effect.orDie);
 	})()), Match.tag("llms", (llmsRequest) => Effect.gen(function* () {
 		stream.ensureOpen({
@@ -1868,24 +1832,13 @@ const EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER = 1;
 process.title = "stryker";
 const lastSignal = observeTerminatingSignal();
 function isSupportedNodeVersion(version) {
-	let withoutV = version;
-	if (version.startsWith("v")) withoutV = version.slice(1);
-	const dashBaseRaw = withoutV.split("-")[0];
-	let dashBase = withoutV;
-	if (dashBaseRaw !== void 0) dashBase = dashBaseRaw;
-	const baseRaw = dashBase.split("+")[0];
-	let base = dashBase;
-	if (baseRaw !== void 0) base = baseRaw;
-	const parts = base.split(".").map((p) => Number.parseInt(p, 10));
-	const major = parts[0] ?? 0;
-	const minor = parts[1] ?? 0;
-	const patch = parts[2] ?? 0;
+	const [major = 0, minor = 0, patch = 0] = (version.replace(/^v/, "").split(/[-+]/)[0] ?? "").split(".").map((p) => Number.parseInt(p, 10));
 	if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) return false;
 	if (major !== 20) return major > 20;
 	if (minor !== 0) return minor > 0;
 	return patch >= 0;
 }
-if (!isSupportedNodeVersion(process.version)) throw new Error(`Node.js version ${process.version} detected. StrykerJS requires version to match ${strykerEngines.node}. Please update your Node.js version or visit https://nodejs.org/ for additional instructions`);
+if (!isSupportedNodeVersion(process.version)) throw new Error(`Node.js version ${process.version} detected. StrykerJS requires version to match ${engines.node}. Please update your Node.js version or visit https://nodejs.org/ for additional instructions`);
 const program = Effect.gen(function* () {
 	const outputMode = yield* OutputModeProbe;
 	const runEvents = yield* RunEventStreamPort;