@systemfsoftware/stryker-js-cli 4.0.3 → 5.0.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @systemfsoftware/stryker-js-cli
 
+## 5.0.0
+
+### Major Changes
+
+- The Node host package `@systemfsoftware/stryker-js-platform-node` is gone: the engine (`@systemfsoftware/stryker-js-engine`) is the host-neutral mutation run, and the `stryker` CLI owns the Node composition roots and worker entries. Depend on the engine for the run and the CLI for process entries; install the new names.
+
+- RunOutcome now places the genuine verdicts (RunParseFailed, RunSurvivorsRejected, RunConfigFailed, RunFailed) on the decision channel as a branded tagged union; RunInterrupted remains a failure. Output.workflow resolves a branded HumanOutput|MachineOutput union instead of a plain record
+
+- Disposing a worker now terminates the whole process group and escalates. The
+  runner signals the group so a worker's own child processes go with it, waits for
+  the exit, and sends `SIGKILL` if the worker is still alive two seconds later.
+  Previously a single `SIGTERM` went to one process id and the runner moved on
+  after a fixed wait, so a worker that installed a `SIGTERM` handler — or that had
+  spawned children of its own — outlived the run.
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@6.0.0
+  - @systemfsoftware/stryker-js@1.0.0
+  - @systemfsoftware/stryker-js-html-reporter@1.0.0
+
 ## 4.0.3
 
 ### Patch Changes

package/README.md

@@ -84,7 +84,7 @@ The highest pending class wins; a terminating signal outranks all of them.
 
 ## Related
 
-The mutation engine is [`@systemfsoftware/stryker-js-platform-node`][engine].
+The mutation engine is [`@systemfsoftware/stryker-js-engine`][engine].
 This package is the terminal-facing half and reaches it through an injected
 run-event sink;
 it ships a command and exposes no importable API.
@@ -100,5 +100,5 @@ Licensed under [Apache 2.0][license-url].
 [license-badge]: https://img.shields.io/badge/license-Apache_2.0-blue?style=flat-square
 [license-url]: https://github.com/systemfsoftware/systemfsoftware/blob/main/LICENSE
 [repo]: https://github.com/systemfsoftware/systemfsoftware
-[engine]: https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/testing/mutation/stryker-js/platform-node
+[engine]: https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/testing/mutation/stryker-js/engine
 [docs]: https://stryker-mutator.io/docs/stryker-js/configuration/

package/dist/main.mjs

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
-import * as NodeFileSystem$1 from "@effect/platform-node-shared/NodeFileSystem";
-import * as NodePath$1 from "@effect/platform-node-shared/NodePath";
+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, nodeModuleLayer, 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";
@@ -29,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 { 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 { NodeFileSystem, NodePath } from "@effect/platform-node";
+import "@systemfsoftware/stryker-js/Module";
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
-import "@systemfsoftware/stryker-js/Module";
-//#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.
@@ -316,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);
@@ -576,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();
@@ -683,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),
@@ -697,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({
@@ -715,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;
@@ -891,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;
@@ -905,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",
@@ -1006,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
@@ -1087,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";
 /**
@@ -1183,87 +1167,57 @@ function survivorMutateSpans(survivors, basePath) {
 	return spans;
 }
 const hashContent = (content) => bytesToHex(sha256(utf8ToBytes(content)));
-/**
-* 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) => pipe(Cell.read((cliOptions) => Effect.flatMap(Path.Path, (pathService) => resolveSurvivorsRunOptions(cliOptions, basePath).pipe(Effect.flatMap((resolvedOptions) => {
-	const priorReportPath = priorReportPathOf(resolvedOptions);
-	const resolveAbsolutePath = (file) => pathService.resolve(file);
-	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,
-		resolveAbsolutePath
-	}))));
-}))).pipe(Effect.provide(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer, nodeModuleLayer)))), Cell.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
+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 admissionContext = yield* Ref.make(void 0);
-		return yield* Cell.apply(survivorsAdmissionDescription(runMutationTest, stream, mode, admissionContext, basePath), cliOptions);
-	});
+		onFailure: Effect.fail
+	})
+});
+function runSurvivorsAdmission(cliOptions, basePath) {
+	return Cell.run(survivorsAdmissionCell(basePath), cliOptions);
 }
 function resolveSurvivorsRunOptions(cliOptions, basePath) {
 	return readConfig(cliOptions, basePath);
@@ -1515,7 +1469,7 @@ function readCoreEntries() {
 	return Effect.gen(function* () {
 		const path = yield* Path.Path;
 		const fs = yield* FileSystem.FileSystem;
-		const resolved = import.meta.resolve("@systemfsoftware/stryker-js-platform-node/package.json");
+		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;
@@ -1530,8 +1484,6 @@ function readCoreEntries() {
 		return [];
 	}).pipe(Effect.catchCause(() => {
 		return Effect.succeed([]);
-	}), Effect.catchDefect(() => {
-		return Effect.succeed([]);
 	}));
 }
 function buildLLMSManifest(command, version) {
@@ -1765,7 +1717,7 @@ const cliLayer = Layer.mergeAll(CliConfig.layer({ builtIns: [
 	GlobalFlag.Wizard,
 	GlobalFlag.Completions,
 	GlobalFlag.LogLevel
-] }), Path.layer, NodeFileSystem$1.layer, terminalLayer, NodeStdio.layer, NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem$1.layer, NodePath$1.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;
@@ -1788,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, makeRunLayer(hostOptions, queue))).pipe(Effect.provideService(RunEvents, queue));
+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: process.cwd(),
-		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-html-reporter"), import.meta.resolve("@systemfsoftware/stryker-js-platform-node/builtin-reporters")],
+		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"])
 	};
 }
@@ -1804,7 +1757,7 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 	const hostOptions = hostOptionsOf(input.mode, stream);
 	const runMutationTestImpl = input.runMutationTest ?? defaultRunMutationTest(hostOptions, stream.queue);
 	const basePath = hostOptions.basePath;
-	const pathService = yield* Path.Path.pipe(Effect.provide(NodePath$1.layer));
+	const pathService = yield* Path.Path.pipe(Effect.provide(NodePath.layer));
 	let currentFiber = null;
 	const onSignal = () => {
 		process.removeListener("SIGINT", onSignal);
@@ -1812,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({
@@ -1866,29 +1832,18 @@ 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;
 	return yield* strykerCliEffect(process.argv.slice(2), void 0, outputMode.detectMode, runEvents.createRunEventStream, lastSignal);
-}).pipe(Effect.provideService(Logger.LogToStderr, true), Effect.provide(Layer.merge(OutputModeProbeLive, RunEventStreamFileLive).pipe(Layer.provide(Layer.mergeAll(NodeStdio.layer, NodeFileSystem$1.layer, NodePath$1.layer)))));
+}).pipe(Effect.provideService(Logger.LogToStderr, true), Effect.provide(Layer.merge(OutputModeProbeLive, RunEventStreamFileLive).pipe(Layer.provide(Layer.mergeAll(NodeStdio.layer, NodeFileSystem.layer, NodePath.layer)))));
 NodeRuntime.runMain(program, {
 	disableErrorReporting: true,
 	teardown: (exit, onExit) => {

package/dist/node-D-ynY_kk.mjs

@@ -0,0 +1,105 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import { ChildProcessCrashedError, WorkerEntries, WorkerLauncher } from "@systemfsoftware/stryker-js-engine";
+import * as FileSystem from "effect/FileSystem";
+import * as Match from "effect/Match";
+import * as Path from "effect/Path";
+import { NodeFileSystem, NodePath, NodeSocket } from "@effect/platform-node";
+import { Module } from "@systemfsoftware/stryker-js/Module";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+//#region src/platform/node.ts
+const makeModuleRequire = (nodeModule, filename) => {
+	const requireFrom = nodeModule.createRequire(filename);
+	const requireFn = (request) => requireFrom(request);
+	requireFn.resolve = (request, options) => {
+		if (options === void 0) return requireFrom.resolve(request);
+		return requireFrom.resolve(request, { paths: [...options.paths ?? []] });
+	};
+	return requireFn;
+};
+/**
+* The Node implementation of the {@link Module} port: every call routes
+* through the runtime's own `node:module` via `process.getBuiltinModule`, so
+* this package imports no host builtins and the import ban holds here too.
+*/
+const nodeModuleLayer = Layer.effect(Module, Effect.sync(() => {
+	const nodeModule = process.getBuiltinModule("node:module");
+	return {
+		createRequire: (filename) => makeModuleRequire(nodeModule, filename),
+		isBuiltin: (moduleName) => nodeModule.isBuiltin(moduleName)
+	};
+}));
+/**
+* The worker entries this package's own build emits. The engine spawns by
+* address; this process package knows its dist layout and hands the
+* addresses in.
+*/
+const workerEntriesLayer = Layer.succeed(WorkerEntries, {
+	checkerWorkerUrl: new URL("./workers/checker-worker.mjs", import.meta.url),
+	testRunnerWorkerUrl: new URL("./workers/child-process-test-runner-worker.mjs", import.meta.url)
+});
+/**
+* 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
+* socket file in the worker directory on POSIX, a same-user named pipe on
+* Windows), and connect the NDJSON protocol client over `NodeSocket`.
+*/
+const nodeWorkerLauncherLayer = Layer.effect(WorkerLauncher, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	return { spawn: (params) => Effect.gen(function* () {
+		const workerDir = yield* fs.makeTempDirectoryScoped({ prefix: params.tempDirPrefix });
+		const socketPath = Match.value(process.platform).pipe(Match.when("win32", () => `\\\\.\\pipe\\stryker-worker-${globalThis.crypto.randomUUID()}`), Match.orElse(() => path.join(workerDir, "worker.sock")));
+		yield* fs.writeFileString(path.join(workerDir, "options.json"), params.optionsJson);
+		const entryPath = yield* path.fromFileUrl(params.entryUrl);
+		const handle = yield* ChildProcess.make(process.execPath, [...params.execArgv, entryPath], {
+			cwd: params.workingDirectory,
+			extendEnv: true,
+			env: {
+				STRYKER_WORKER_DIR: workerDir,
+				STRYKER_SOCKET: socketPath
+			},
+			stderr: "inherit"
+		}).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+		const clientLayer = RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(Layer.provide(NodeSocket.layerNet({ path: socketPath })), Layer.provide(RpcSerialization.layerNdjson));
+		const exited = handle.exitCode.pipe(Effect.orDie, Effect.flatMap((exitCode) => Effect.fail(new ChildProcessCrashedError({
+			pid: Number(handle.pid),
+			exit: {
+				_tag: "Code",
+				code: exitCode
+			},
+			cause: "worker exited before it accepted the RPC connection"
+		}))));
+		return {
+			pid: Number(handle.pid),
+			clientLayer,
+			exited
+		};
+	}).pipe(Effect.catch((error) => {
+		if (error instanceof ChildProcessCrashedError) return Effect.fail(error);
+		return Effect.fail(new ChildProcessCrashedError({
+			pid: 0,
+			exit: {
+				_tag: "Code",
+				code: 1
+			},
+			cause: "worker spawn failed"
+		}));
+	})) };
+}));
+const nodeFsPathLayer = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer);
+const nodeSpawnerLayer = NodeChildProcessSpawner.layer.pipe(Layer.provide(nodeFsPathLayer));
+const nodeBase = Layer.merge(nodeFsPathLayer, nodeSpawnerLayer);
+/**
+* Every port the engine requires, provided from this runtime: the file
+* system, the path service, the module loader, the child-process spawner,
+* the worker launcher, and this build's worker entry addresses.
+*/
+const nodePlatformLayer = Layer.mergeAll(nodeModuleLayer, workerEntriesLayer, nodeWorkerLauncherLayer.pipe(Layer.provide(nodeBase)), nodeBase);
+//#endregion
+export { nodePlatformLayer as n, nodeModuleLayer as t };

package/dist/worker-runtime-CT5LMMgY.mjs

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Cause from "effect/Cause";
+//#region src/workers/worker-runtime.ts
+const workerSocketPath = (label) => {
+	const socketPath = process.env["STRYKER_SOCKET"];
+	if (socketPath === void 0) {
+		process.stderr.write(`${label}: STRYKER_SOCKET is not set\n`);
+		process.exit(1);
+	}
+	return socketPath;
+};
+const launchWorker = (main, label) => {
+	Effect.runFork(Layer.launch(main).pipe(Effect.tapCause((cause) => Effect.sync(() => {
+		process.stderr.write(`${label}: ${Cause.pretty(cause)}\n`);
+		process.exitCode = 1;
+	}))));
+};
+//#endregion
+export { workerSocketPath as n, launchWorker as t };

package/dist/workers/checker-worker.mjs

@@ -0,0 +1,53 @@
+import { t as nodeModuleLayer } from "../node-D-ynY_kk.mjs";
+import { n as workerSocketPath, t as launchWorker } from "../worker-runtime-CT5LMMgY.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import { NodeFileSystem, NodePath, NodeSocketServer } from "@effect/platform-node";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { Checker, CheckerFailed } from "@systemfsoftware/stryker-js/Checker";
+import { RunConfiguration, SandboxDirectory } from "@systemfsoftware/stryker-js/Plugin";
+import * as HashMap from "effect/HashMap";
+import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import { CheckerRpcs, create, decodeWorkerOptions, loadPlugins } from "@systemfsoftware/stryker-js-engine/worker";
+//#region src/workers/Checker.worker.ts
+const buildChecker = (contribution, options) => Checker.pipe(Effect.provide(contribution.layer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(RunConfiguration, options), Layer.succeed(SandboxDirectory, process.cwd()), NodeFileSystem.layer, NodePath.layer, nodeModuleLayer)))));
+const mutantIdsOf = (mutants) => mutants.map((mutant) => mutant.id);
+const readWorkerOptions = Effect.gen(function* () {
+	const workerDir = process.env["STRYKER_WORKER_DIR"] ?? (yield* Effect.die(/* @__PURE__ */ new Error("STRYKER_WORKER_DIR is not set")));
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const raw = yield* fs.readFileString(path.join(workerDir, "options.json"));
+	return yield* decodeWorkerOptions(raw);
+});
+const CheckerHandlers = CheckerRpcs.toLayer(Effect.gen(function* () {
+	const options = yield* readWorkerOptions;
+	const loaded = yield* loadPlugins(options.plugins, process.cwd());
+	const checkers = HashMap.fromIterable(yield* Effect.forEach(options.checkers, (name) => Effect.gen(function* () {
+		const contribution = yield* create(loaded.pluginsByKind, "Checker", name);
+		const checker = yield* buildChecker(contribution, options);
+		yield* checker.init;
+		return [name, checker];
+	}), {
+		concurrency: "unbounded",
+		discard: false
+	}));
+	const resolve = (checkerName, mutants) => Option.match(HashMap.get(checkers, checkerName), {
+		onNone: () => Effect.fail(new CheckerFailed({
+			cause: `Checker ${checkerName} does not exist`,
+			checkerName,
+			mutantIds: mutantIdsOf(mutants)
+		})),
+		onSome: (checker) => Effect.succeed(checker)
+	});
+	return {
+		check: ({ checkerName, mutants }) => resolve(checkerName, mutants).pipe(Effect.flatMap((checker) => checker.check([...mutants])), Effect.map((resultMap) => Object.fromEntries(resultMap))),
+		group: ({ checkerName, mutants }) => resolve(checkerName, mutants).pipe(Effect.flatMap((checker) => checker.group([...mutants])))
+	};
+})).pipe(Layer.provide(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));
+const MainLayer = RpcServer.layer(CheckerRpcs).pipe(Layer.provide(CheckerHandlers), Layer.provide(RpcServer.layerProtocolSocketServer), Layer.provide(RpcSerialization.layerNdjson), Layer.provide(NodeSocketServer.layer({ path: workerSocketPath("checker worker") })), Layer.provide(nodeModuleLayer));
+launchWorker(MainLayer, "checker worker");
+//#endregion
+export {};

package/dist/workers/child-process-test-runner-worker.mjs

@@ -0,0 +1,67 @@
+import { t as nodeModuleLayer } from "../node-D-ynY_kk.mjs";
+import { n as workerSocketPath, t as launchWorker } from "../worker-runtime-CT5LMMgY.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { errorToString } from "@systemfsoftware/stryker-js/Mutant";
+import * as Cause from "effect/Cause";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { NodeFileSystem, NodePath, NodeSocketServer } from "@effect/platform-node";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { RunConfiguration, SandboxDirectory } from "@systemfsoftware/stryker-js/Plugin";
+import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import { MutantCoverageSchema, TestRunnerRpcs, create, decodeWorkerOptions, loadPlugins } from "@systemfsoftware/stryker-js-engine/worker";
+import { TestRunner, TestRunnerFailed } from "@systemfsoftware/stryker-js/TestRunner";
+import { Schema } from "effect";
+//#region src/workers/child-process-test-runner-worker.ts
+const withCoverage = (result, options) => Effect.gen(function* () {
+	if (result.status === "error") return {
+		...result,
+		errorMessage: errorToString(result.errorMessage)
+	};
+	if (result.status !== "complete") return result;
+	if (result.mutantCoverage !== void 0) return result;
+	if (options.coverageAnalysis === "off") return result;
+	const decoded = yield* Schema.decodeUnknownEffect(Schema.optional(MutantCoverageSchema))(globalThis.__mutantCoverage__).pipe(Effect.orElseSucceed(() => void 0));
+	if (decoded === void 0) return result;
+	return {
+		...result,
+		mutantCoverage: decoded
+	};
+});
+const normalizeMutantRun = (result) => {
+	if (result.status === "error") return {
+		...result,
+		errorMessage: errorToString(result.errorMessage)
+	};
+	return result;
+};
+const readWorkerOptions = Effect.gen(function* () {
+	const workerDir = process.env["STRYKER_WORKER_DIR"] ?? (yield* Effect.die(/* @__PURE__ */ new Error("STRYKER_WORKER_DIR is not set")));
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const raw = yield* fs.readFileString(path.join(workerDir, "options.json"));
+	return yield* decodeWorkerOptions(raw);
+});
+const TestRunnerHandlers = TestRunnerRpcs.toLayer(Effect.gen(function* () {
+	const options = yield* readWorkerOptions;
+	const runnerName = options.testRunner;
+	const failed = (phase) => (cause) => Effect.fail(new TestRunnerFailed({
+		cause: Cause.pretty(cause),
+		phase,
+		runnerName
+	}));
+	const loaded = yield* loadPlugins(options.plugins, process.cwd()).pipe(Effect.catchCause(failed("init")));
+	const underlying = yield* create(loaded.pluginsByKind, "TestRunner", runnerName).pipe(Effect.flatMap((contribution) => TestRunner.pipe(Effect.provide(contribution.layer))), Effect.provide(Layer.merge(Layer.succeed(RunConfiguration, options), Layer.succeed(SandboxDirectory, process.cwd()))), Effect.catchCause(failed("init")));
+	yield* underlying.init.pipe(Effect.catchCause(failed("init")));
+	yield* Effect.addFinalizer(() => underlying.dispose.pipe(Effect.ignore));
+	return {
+		capabilities: () => underlying.capabilities.pipe(Effect.catchCause(failed("capabilities"))),
+		dryRun: ({ options: runOptions }) => underlying.dryRun(runOptions).pipe(Effect.flatMap((result) => withCoverage(result, runOptions)), Effect.catchCause(failed("dryRun"))),
+		mutantRun: ({ options: runOptions }) => underlying.mutantRun(runOptions).pipe(Effect.map(normalizeMutantRun), Effect.catchCause(failed("mutantRun")))
+	};
+})).pipe(Layer.provide(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));
+const MainLayer = RpcServer.layer(TestRunnerRpcs).pipe(Layer.provide(TestRunnerHandlers), Layer.provide(RpcServer.layerProtocolSocketServer), Layer.provide(RpcSerialization.layerNdjson), Layer.provide(NodeSocketServer.layer({ path: workerSocketPath("test runner worker") })), Layer.provide(nodeModuleLayer));
+launchWorker(MainLayer, "test runner worker");
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-cli",
-  "version": "4.0.3",
+  "version": "5.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -18,32 +18,33 @@
     "@effect/platform-node-shared": "^4.0.0-rc.112",
     "@noble/hashes": "1.8.0",
     "effect": "^4.0.0-rc.112",
-    "@systemfsoftware/effect-cell-types": "^5.0.2",
-    "@systemfsoftware/stryker-js-html-reporter": "^0.1.2",
-    "@systemfsoftware/stryker-js-platform-node": "^0.2.0",
-    "@systemfsoftware/stryker-js": "^0.2.0"
+    "@systemfsoftware/effect-cell-types": "^6.0.0",
+    "@systemfsoftware/stryker-js-engine": "^0.2.0",
+    "@systemfsoftware/stryker-js": "^1.0.0",
+    "@systemfsoftware/stryker-js-html-reporter": "^1.0.0"
   },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
     "@vitest/coverage-v8": "^4",
+    "mutation-testing-report-schema": "3.7.3",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "testcontainers": "^12.1.0",
     "tsdown": "^0.22.14",
     "vite-tsconfig-paths": "^6.1.1",
     "vitest": "^4",
+    "@systemfsoftware/all": "^1.1.2",
     "@systemfsoftware/effect-gherkin-spec": "^4.0.0",
     "@systemfsoftware/effect-schema-law": "^2.0.1",
     "@systemfsoftware/effect-schema-vite": "^2.0.2",
-    "@systemfsoftware/all": "^1.1.0",
-    "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/stryker-js-typescript-checker": "^3.0.3",
-    "@systemfsoftware/stryker-js-vitest-runner": "^2.1.0",
-    "@systemfsoftware/stryker-plugins": "^2.0.1",
-    "@systemfsoftware/tsconfig": "^1.3.3",
+    "@systemfsoftware/stryker-js-typescript-checker": "^4.0.0",
+    "@systemfsoftware/stryker-js-vitest-runner": "^3.0.0",
+    "@systemfsoftware/stryker-plugins": "^2.0.2",
+    "@systemfsoftware/stryker-test-contribution": "^1.1.3",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/stryker-test-contribution": "^1.1.2"
+    "@systemfsoftware/tsconfig": "^1.3.3",
+    "@systemfsoftware/oxlint-config": "^0.1.0"
   },
   "engines": {
     "node": ">=20.0.0"