@systemfsoftware/stryker-js-cli 1.2.5

package/dist/main.mjs

@@ -0,0 +1,1495 @@
+#!/usr/bin/env node
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeStdio from "@effect/platform-node/NodeStdio";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import semver from "semver";
+import { strykerEngines, strykerVersion } from "@systemfsoftware/stryker-js-mutation-run/stryker-package";
+import * as Context from "effect/Context";
+import * as Result from "effect/Result";
+import * as CliError from "effect/unstable/cli/CliError";
+import * as Cause from "effect/Cause";
+import * as Clock from "effect/Clock";
+import * as Deferred from "effect/Deferred";
+import * as Fiber from "effect/Fiber";
+import * as Queue from "effect/Queue";
+import * as Stdio from "effect/Stdio";
+import * as Stream from "effect/Stream";
+import { buildVerdictEnvelope, generateRunId } from "@systemfsoftware/stryker-js-mutation-run/verdict-envelope";
+import * as Console from "effect/Console";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Ref from "effect/Ref";
+import * as Terminal from "effect/Terminal";
+import * as Argument from "effect/unstable/cli/Argument";
+import * as CliConfig from "effect/unstable/cli/CliConfig";
+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 * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import { ConfigReader, OptionsValidator, defaultOptions } from "@systemfsoftware/stryker-js-mutation-run/config/config-resolution";
+import { PluginKind } from "@systemfsoftware/stryker-js-plugin-api/plugin";
+import { strykerPlugins } from "@systemfsoftware/stryker-js-mutation-report/stryker-plugins";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { noopLogger } from "@stryker-mutator/util";
+import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
+import "@systemfsoftware/stryker-js-plugin-api/core";
+import * as Exit from "effect/Exit";
+import { pipe } from "effect/Function";
+import * as Match from "effect/Match";
+import * as S from "effect/Schema";
+import { Stryker } from "@systemfsoftware/stryker-js-mutation-run";
+import { forkCoreSchema } from "@systemfsoftware/stryker-js-mutation-run/config/fork-schema";
+import { ConfigError, retrieveCause } from "@systemfsoftware/stryker-js-mutation-run/errors";
+import { ExitClass, getPendingExitClasses, resolveExitCode } from "@systemfsoftware/stryker-js-mutation-run/exit-classification";
+import { performance } from "node:perf_hooks";
+import { format, inspect } from "node:util";
+import { toRelativeNormalizedFileName } from "@systemfsoftware/stryker-js-mutation-run/mutants/incremental-differ";
+//#region src/OutputMode.ts
+/**
+* The known tool variables. Narrow per the plan — exactly
+* `['CLAUDECODE', 'CODEX_SANDBOX']` — and load-bearing rather than a
+* fallback: they cover the PTY-allocating harnesses a stdin condition would
+* have rescued.
+*/
+const TOOL_VARIABLES = ["CLAUDECODE", "CODEX_SANDBOX"];
+/**
+* Resolves the output mode by R4 precedence. Pure — reads nothing, so it is
+* fully testable; the caller supplies every input once at startup. The
+* mutually-exclusive-flags case is a caller error, returned as a `failure` so
+* the function stays total.
+*/
+function resolveMode(input) {
+	if (input.text === true && input.json === true) return Result.fail(CliError.InvalidValue.make({
+		option: "json",
+		value: "text",
+		expected: "the \"--format text\" and \"--json\" flags are mutually exclusive — use one or the other",
+		kind: "flag"
+	}));
+	if (input.text === true) return Result.succeed({
+		mode: "human",
+		signal: "flag",
+		stdoutIsTTY: input.stdoutIsTTY
+	});
+	if (input.json === true) return Result.succeed({
+		mode: "machine",
+		signal: "flag",
+		stdoutIsTTY: input.stdoutIsTTY
+	});
+	if (input.envMode !== void 0 && input.envMode.length > 0) return Result.succeed({
+		mode: input.envMode === "machine" ? "machine" : "human",
+		signal: "env",
+		stdoutIsTTY: input.stdoutIsTTY
+	});
+	if (!input.stdoutIsTTY) return Result.succeed({
+		mode: "machine",
+		signal: "tty",
+		stdoutIsTTY: false
+	});
+	if (input.agent !== void 0 && input.agent.length > 0) return Result.succeed({
+		mode: "machine",
+		signal: "agent",
+		stdoutIsTTY: true
+	});
+	for (const variable of TOOL_VARIABLES) {
+		const value = input.toolVars?.[variable];
+		if (value !== void 0 && value.length > 0) return Result.succeed({
+			mode: "machine",
+			signal: "tool",
+			stdoutIsTTY: true
+		});
+	}
+	return Result.succeed({
+		mode: "human",
+		signal: "tty",
+		stdoutIsTTY: true
+	});
+}
+/**
+* The progress bar's gate. Human mode on a non-TTY stdout (AE1) must not leak
+* its control sequences into a pipe, and machine mode keeps stdout clean for
+* the verdict envelope (R5). Decided from the resolved mode's own detection
+* data — never a second `isTTY` probe.
+*/
+function isProgressEnabled(resolved) {
+	return resolved.mode === "human" && resolved.stdoutIsTTY;
+}
+/**
+* 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.
+*/
+function isColorEnabled(resolved, noColor) {
+	return resolved.mode === "human" && (noColor === void 0 || noColor.length === 0);
+}
+//#endregion
+//#region src/OutputModeAdapter.ts
+var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/OutputModeAdapter/OutputModeProbeTag") {};
+const OutputModeProbe = OutputModeProbeTag;
+const OutputModeProbeLive = Layer.succeed(OutputModeProbe, OutputModeProbe.of({ detectMode: () => {
+	const envMode = process.env["STRYKER_MODE"];
+	const agent = process.env["AGENT"];
+	return Result.getOrThrow(resolveMode({
+		stdoutIsTTY: process.stdout.isTTY === true,
+		...envMode !== void 0 ? { envMode } : {},
+		...agent !== void 0 ? { agent } : {},
+		toolVars: Object.fromEntries(TOOL_VARIABLES.map((variable) => [variable, process.env[variable]]))
+	}));
+} }));
+//#endregion
+//#region src/StreamProtocol.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;
+//#endregion
+//#region src/RunEventStreamAdapter.ts
+var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/RunEventStreamAdapter/RunEventStreamPortTag") {};
+const RunEventStreamPort = RunEventStreamPortTag;
+const isTerminalEvent = (event) => event.kind === "verdict" || event.kind === "error" || event.kind === "help" || event.kind === "manifest";
+/**
+* The push adapter from the run's synchronous sink to the callback mailbox.
+* `Queue.offer`/`Queue.end` on an unbounded queue never block or fail, so the
+* sync sink can drive them with `Effect.runSync`. Defined at module scope,
+* outside any Effect expression.
+*/
+function queueEmit(queue) {
+	return {
+		single: (event) => {
+			Effect.runSync(Queue.offer(queue, event));
+		},
+		end: () => {
+			Effect.runSync(Queue.end(queue));
+		}
+	};
+}
+/**
+* The drain writes the framed lines through the platform's `Stdio` stdout
+* sink — `NodeStdio.layer` at the composition root supplies the service, and
+* the sink owns the writable's backpressure, the scoped `'error'` listener a
+* closed consumer raises, and the final `'finish'` wait (`endOnDone`). A
+* write failure surfaces as a `PlatformError` which this catch swallows — a
+* consumer closing the pipe must not replace the run's classed exit code
+* (R31) — and the drain still completes only after every byte was handed to
+* the OS (R30).
+*/
+const drainOf = (stdio, framed) => Stream.run(framed, stdio.stdout({ endOnDone: true })).pipe(Effect.ignore);
+/**
+* Creates a run's stream. The drain is an Effect the composition root forks
+* before the run; until then the sink is unbound and every push is dropped,
+* which is what makes human mode — or an absent drain — inert without
+* per-call probing (R2). The run's clock zero is read from the runtime so
+* the adapter never touches the wall clock directly.
+*/
+const makeRunEventStream = (stdio, resolved) => Effect.gen(function* () {
+	const runId = generateRunId();
+	const startedAt = yield* Clock.currentTimeMillis;
+	const state = {
+		mode: resolved.mode,
+		signal: resolved.signal,
+		emit: null,
+		headerWritten: false,
+		terminalWritten: false,
+		progress: {
+			completed: 0,
+			total: null
+		}
+	};
+	const registered = yield* Deferred.make();
+	const eventStream = Stream.callback((queue) => Effect.sync(() => {
+		state.emit = queueEmit(queue);
+	}).pipe(Effect.andThen(Deferred.succeed(registered, void 0))));
+	const tickStream = Stream.tick(TICK_INTERVAL_MS).pipe(Stream.filter(() => state.mode === "machine" && state.headerWritten && !state.terminalWritten), Stream.mapEffect(() => Effect.gen(function* () {
+		return {
+			kind: "tick",
+			elapsedMs: (yield* Clock.currentTimeMillis) - startedAt,
+			completed: state.progress.completed,
+			total: state.progress.total
+		};
+	})));
+	let terminalSeen = false;
+	const framed = Stream.merge(eventStream, tickStream, { haltStrategy: "either" }).pipe(Stream.filter((event) => {
+		if (terminalSeen) return false;
+		if (isTerminalEvent(event)) terminalSeen = true;
+		return true;
+	}), Stream.map((event) => `${JSON.stringify(event)}\n`));
+	const drain = drainOf(stdio, framed);
+	let drainFiber = null;
+	const sink = (event) => {
+		const emit = state.emit;
+		if (emit === null || state.terminalWritten || state.mode !== "machine") return;
+		if (!state.headerWritten) {
+			state.headerWritten = true;
+			emit.single({
+				kind: "stream",
+				schemaVersion: "1.0",
+				runId,
+				mode: state.mode,
+				signal: state.signal
+			});
+		}
+		switch (event.kind) {
+			case "stream":
+			case "tick": return;
+			case "phase": break;
+			case "plan":
+				state.progress = {
+					...state.progress,
+					total: event.total
+				};
+				break;
+			case "mutant":
+				state.progress = {
+					completed: event.completed,
+					total: event.total
+				};
+				break;
+			case "verdict":
+			case "error":
+			case "help":
+			case "manifest":
+				emit.single(event);
+				state.terminalWritten = true;
+				emit.end();
+				return;
+		}
+		emit.single(event);
+	};
+	return {
+		sink,
+		runId,
+		startedAt,
+		isOpen: () => state.emit !== null && state.mode === "machine" && !state.terminalWritten,
+		ensureOpen: (openResolved) => {
+			if (state.headerWritten) return;
+			state.mode = openResolved.mode;
+			state.signal = openResolved.signal;
+		},
+		open: Effect.gen(function* () {
+			if (drainFiber === null) {
+				drainFiber = yield* Effect.forkDetach(drain);
+				yield* Effect.race(Deferred.await(registered), Fiber.await(drainFiber));
+			}
+		}),
+		closeAndDrain: Effect.gen(function* () {
+			state.terminalWritten = true;
+			state.emit?.end();
+			if (drainFiber !== null) yield* Fiber.join(drainFiber);
+		})
+	};
+});
+const RunEventStreamLive = Layer.effect(RunEventStreamPort, Effect.map(Stdio.Stdio, (stdio) => RunEventStreamPort.of({ createRunEventStream: (resolved) => makeRunEventStream(stdio, resolved) })));
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(node, key) {
+	const value = node[key];
+	return typeof value === "string" ? value : void 0;
+}
+function stringArrayField(node, key) {
+	const value = node[key];
+	if (!Array.isArray(value)) return [];
+	const strings = [];
+	for (const item of value) if (typeof item === "string") strings.push(item);
+	return strings;
+}
+/** The compiled shapes discriminate on `_tag`; read it once, off the record. */
+function tagOf(node) {
+	return node["_tag"];
+}
+function walkParam(param, isOptional, out) {
+	if (!isObject(param)) return;
+	switch (tagOf(param)) {
+		case "Single":
+			describeSingle(param, isOptional, out);
+			return;
+		case "Map":
+		case "Transform":
+			walkParam(param["param"], isOptional, out);
+			return;
+		case "Optional":
+			walkParam(param["param"], true, out);
+			return;
+		case "Variadic":
+			walkParam(param["param"], isOptional, out);
+			return;
+		default: return;
+	}
+}
+const PRIMITIVE_KIND = {
+	Boolean: "boolean",
+	Choice: "choice",
+	Date: "date",
+	FileParse: "file",
+	FileSchema: "file",
+	FileText: "file",
+	Float: "float",
+	Integer: "integer",
+	KeyValuePair: "key=value",
+	None: "none",
+	Path: "path",
+	Redacted: "redacted",
+	String: "text"
+};
+function kindOf(primitive) {
+	const tag = stringField(primitive, "_tag");
+	return tag === void 0 ? "unknown" : PRIMITIVE_KIND[tag] ?? tag;
+}
+function choiceValues(primitive) {
+	const keys = primitive["choiceKeys"];
+	if (!Array.isArray(keys)) return;
+	const values = [];
+	for (const key of keys) if (typeof key === "string") values.push(key);
+	return values;
+}
+/** The allowed reporter names, read from the U9 registry — the same list the plugin loader accepts. */
+const REPORTER_NAMES = strykerPlugins.filter((plugin) => plugin.kind === PluginKind.Reporter).map((plugin) => plugin.name);
+/**
+* v4 option descriptions are stored as `Option.some(string)` on the compiled
+* `Single`; the walker unwraps the option.
+*/
+function descriptionOf(single) {
+	const description = single["description"];
+	if (!isObject(description)) return "";
+	switch (tagOf(description)) {
+		case "Some": {
+			const value = description["value"];
+			return typeof value === "string" ? value : "";
+		}
+		default: return "";
+	}
+}
+function describeSingle(single, isOptional, out) {
+	const name = stringField(single, "name") ?? "";
+	const primitive = isObject(single["primitiveType"]) ? single["primitiveType"] : {};
+	const kind = kindOf(primitive);
+	const choices = name === "reporters" ? REPORTER_NAMES : kind === "choice" ? choiceValues(primitive) : void 0;
+	const description = descriptionOf(single);
+	const required = kind !== "boolean" && !isOptional;
+	const described = {
+		name,
+		aliases: stringArrayField(single, "aliases"),
+		kind,
+		required,
+		...choices !== void 0 ? { choices } : {},
+		description
+	};
+	if (single["kind"] === "argument") {
+		out.args.push({
+			name,
+			kind,
+			required,
+			description
+		});
+		return;
+	}
+	out.flags.push(described);
+}
+function walkConfigNode(node, orderedParams, out) {
+	if (!isObject(node)) return;
+	switch (tagOf(node)) {
+		case "Param": {
+			const index = node["index"];
+			const param = typeof index === "number" ? orderedParams[index] : void 0;
+			if (param !== void 0) walkParam(param, false, out);
+			return;
+		}
+		case "Array":
+			if (Array.isArray(node["children"])) for (const child of node["children"]) walkConfigNode(child, orderedParams, out);
+			return;
+		case "Nested":
+			if (isObject(node["tree"])) walkConfigTree(node["tree"], orderedParams, out);
+			return;
+		default: return;
+	}
+}
+function walkConfigTree(tree, orderedParams, out) {
+	for (const key of Object.keys(tree)) walkConfigNode(tree[key], orderedParams, out);
+}
+function describeCommandNode(node) {
+	if (!isObject(node)) return;
+	const out = {
+		flags: [],
+		args: []
+	};
+	const config = node["config"];
+	if (isObject(config) && isObject(config["tree"])) {
+		const orderedParams = Array.isArray(config["orderedParams"]) ? config["orderedParams"] : [];
+		walkConfigTree(config["tree"], orderedParams, out);
+	}
+	const subcommands = [];
+	const grouped = node["subcommands"];
+	if (Array.isArray(grouped)) for (const group of grouped) {
+		if (!isObject(group) || !Array.isArray(group["commands"])) continue;
+		for (const child of group["commands"]) {
+			const described = describeCommandNode(child);
+			if (described !== void 0) subcommands.push(described);
+		}
+	}
+	return {
+		name: stringField(node, "name") ?? "",
+		description: typeof node["description"] === "string" ? node["description"] : "",
+		options: out.flags,
+		args: out.args,
+		subcommands
+	};
+}
+/**
+* Builds the manifest document for a command, walking its compiled form (the
+* same structure the parser matches against). `version` is the tool version,
+* passed in so this module stays free of package state.
+*/
+function buildLLMSManifest(command, version) {
+	const root = describeCommandNode(command) ?? {
+		name: "",
+		description: "",
+		options: [],
+		args: [],
+		subcommands: []
+	};
+	return {
+		schemaVersion: "1.0",
+		tool: root.name,
+		version,
+		commands: [root]
+	};
+}
+/** The manifest as one JSON document, ready for stdout — the U4 convention. */
+function emitLLMSManifest(command, version) {
+	return JSON.stringify(buildLLMSManifest(command, version));
+}
+//#endregion
+//#region src/OutputModeConsoleState.ts
+/**
+* U6 — the machine-mode `Console` layer (KTD3, R7).
+*
+* The v4 CLI renders help and errors through an ANSI renderer and prints them
+* with the `Console` reference — and there is no seam to intercept: the
+* document is written *before* the failure propagates. Machine mode therefore
+* replaces the `Console` reference itself with a capturing implementation:
+* every write lands in an in-memory buffer instead of the real stdout/stderr,
+* and the terminating bootstrap (StrykerCliHandler.ts) emits the buffer as
+* one JSON envelope at teardown. Human mode keeps the default console so the
+* framework's prose rendering is untouched.
+*
+* The v4 `Console.Console` interface is the sync `globalThis.console` shape
+* (the v3 service's effect-returning surface became the module-level
+* wrapper functions), so the capture implementation needs no `unsafe`
+* mirror — every method stores into the buffer directly.
+*/
+const capturedConsoleChunks = [];
+const countByLabel = /* @__PURE__ */ new Map();
+const timeByLabel = /* @__PURE__ */ new Map();
+function formatArgs(args) {
+	return format(...args);
+}
+function captureSync(args) {
+	capturedConsoleChunks.push(formatArgs(args));
+}
+function captureAssert(condition, args) {
+	if (!condition) capturedConsoleChunks.push(`Assertion failed: ${formatArgs(args)}`);
+}
+function captureCount(label) {
+	const key = label ?? "default";
+	const next = (countByLabel.get(key) ?? 0) + 1;
+	countByLabel.set(key, next);
+	capturedConsoleChunks.push(`${key}: ${next}`);
+}
+function captureTimeEnd(label, now) {
+	const key = label ?? "default";
+	const started = timeByLabel.get(key);
+	if (started !== void 0) {
+		timeByLabel.delete(key);
+		capturedConsoleChunks.push(`${key}: ${now - started}ms`);
+	}
+}
+function captureTrace(args) {
+	capturedConsoleChunks.push(`Trace: ${formatArgs(args)}\n${(/* @__PURE__ */ new Error()).stack ?? ""}`);
+}
+const capturingConsole = {
+	assert: (condition, ...args) => captureAssert(condition, args),
+	clear: () => {},
+	count: (label) => captureCount(label),
+	countReset: (label) => countByLabel.delete(label ?? "default"),
+	debug: (...args) => captureSync(args),
+	dir: (item, options) => capturedConsoleChunks.push(inspect(item, options)),
+	dirxml: (item) => capturedConsoleChunks.push(inspect(item)),
+	error: (...args) => captureSync(args),
+	group: () => {},
+	groupCollapsed: () => {},
+	groupEnd: () => {},
+	info: (...args) => captureSync(args),
+	log: (...args) => captureSync(args),
+	table: (tabularData) => capturedConsoleChunks.push(inspect(tabularData, {
+		colors: false,
+		depth: null
+	})),
+	time: (label) => timeByLabel.set(label ?? "default", performance.now()),
+	timeEnd: (label) => captureTimeEnd(label, performance.now()),
+	timeLog: (label, ...args) => {
+		const key = label ?? "default";
+		const started = timeByLabel.get(key);
+		if (started !== void 0) capturedConsoleChunks.push(`${key}: ${performance.now() - started}ms ${formatArgs(args)}`);
+	},
+	trace: (...args) => captureTrace(args),
+	warn: (...args) => captureSync(args)
+};
+/**
+* The machine-mode `Console` layer. Building it clears the capture buffer so
+* every run starts empty; the terminating bootstrap reads the buffer back
+* through `readCapturedConsole` at teardown. A `Layer` is already lazy, so
+* the layer is a value: the reset effect runs when the layer is built.
+*
+* The layer must replace the `Console` reference the module-level
+* `Console.log`/`Console.error` wrappers read through their fiber context;
+* v4 reads the override the same way it reads any provided service, so a
+* plain provide is sufficient — no special `setConsole`-style primitive
+* exists any more. The reference's identifier is `never` (it carries no
+* requirement), so the layer's type is too.
+*
+* Human mode provides no Console binding at all: effect's own default
+* console delegates every method to the global console, which is exactly the
+* prose rendering a human-mode run uses. Mirroring it here would reimplement
+* the library default (V.7).
+*/
+const machineConsoleLayer = Layer.effect(Console.Console, Effect.sync(() => {
+	resetCapturedConsole();
+	return capturingConsole;
+}));
+/**
+* The text captured so far by the machine console layer, joined into one
+* document the way a terminal would have rendered it (one console call per
+* line). Empty in human mode.
+*/
+function readCapturedConsole() {
+	return capturedConsoleChunks.join("\n");
+}
+/**
+* Clears the capture buffer and the count/time tables. Called when the
+* machine layer is constructed so every run starts empty.
+*/
+function resetCapturedConsole() {
+	capturedConsoleChunks.length = 0;
+	countByLabel.clear();
+	timeByLabel.clear();
+}
+//#endregion
+//#region src/Survivors.workflow.ts
+/**
+* The decision's helper closure reaches three language built-ins the purity
+* gate cannot resolve as globals, so each is bound at module scope and the
+* helpers reference the bindings: `isArray` keeps `Array.isArray`'s narrow,
+* `objectEntries`/`objectFromEntries`/`objectKeys` keep `Object`'s trio, and
+* `stringify` keeps `JSON.stringify`'s exact text.
+*/
+const isArray = Array.isArray;
+const { entries: objectEntries, fromEntries: objectFromEntries, keys: objectKeys } = Object;
+const stringify = JSON.stringify;
+/**
+* U8 — survivor re-run admission (R10, R11, KTD6, KTD7).
+*
+* The `--survivors` run re-tests exactly the mutants that survived a previous
+* run. Its input is the previous run's mutation report, and the run is
+* admitted only when a single structural hash of the resolved options, the
+* recorded framework version, and the per-file source content all match the
+* current run (KTD6). Because thresholds live inside the resolved options, a
+* threshold-only change is caught for free. Every rejection exits 2 with a
+* remediation naming the full run to do first; zero survivors exits 0 with a
+* null score and writes no new report (AE3); and a report written by a
+* survivors run is never admitted as the input of another survivors run
+* (KTD7), so chaining two survivors runs fails loudly instead of re-testing a
+* shrunken or stale set.
+*
+* All functions here are pure over their inputs — no file I/O — so the
+* admission logic is fixture-testable in seconds.
+*/
+/** The path a `--survivors` run reads when no `survivorsPriorReport` is configured. */
+const DEFAULT_SURVIVORS_PRIOR_REPORT = "reports/mutation-report.json";
+/**
+* The remediation every rejection carries (R10): name the full run to do
+* first, never the survivors run itself.
+*/
+const SURVIVORS_RUN_FIRST_REMEDIATION = "run a full `stryker run` first, then re-run with --survivors";
+/**
+* The survivors-run bookkeeping keys carried in the resolved options. They
+* are run mechanics, not configuration: a survivors run adds them, so without
+* stripping them the current run's hash would differ from the prior full
+* run's hash for the very same configuration. Their presence in a report's
+* embedded config is also the marker that the report was produced by a
+* survivors run (KTD7).
+*/
+const SURVIVORS_BOOKKEEPING_KEYS = ["survivorsPriorReport"];
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !isArray(value);
+}
+/**
+* The resolved options without the survivors-run bookkeeping keys, so both
+* sides of the admission hash describe the same configuration.
+*/
+function stripSurvivorsKeys(config) {
+	if (!isRecord(config)) return {};
+	const rest = { ...config };
+	for (const key of SURVIVORS_BOOKKEEPING_KEYS) delete rest[key];
+	return rest;
+}
+/**
+* A report written by a survivors run embeds the bookkeeping key in its
+* `config` (the report helper writes the resolved options). Such a report is
+* never a valid input for another survivors run (KTD7): without this check
+* the second run would either re-read a shrunken set or re-test a stale one.
+*/
+function wasProducedBySurvivorsRun(priorReport) {
+	const config = priorReport.config;
+	return isRecord(config) && "survivorsPriorReport" in config;
+}
+/**
+* The sha256 content hash both sides of the admission comparison use: the
+* current run's source files and the sources the prior report embeds. The
+* digest capability is supplied by the caller.
+*/
+function sourceContentHash(content, hash) {
+	return hash(content);
+}
+/**
+* Serializes the hash input with keys sorted at every level, so the hash is a
+* pure function of the data and not of object key insertion order. The shape
+* is pinned by a golden snapshot test: a serialization change here fails
+* loudly instead of silently invalidating every prior report in the wild.
+*/
+function serializeSurvivorsHashInput(input) {
+	return stringify(sortKeys(input));
+}
+function sortKeys(value) {
+	if (isArray(value)) return value.map(sortKeys);
+	if (isRecord(value)) return objectFromEntries(objectKeys(value).sort().map((key) => [key, sortKeys(value[key])]));
+	return value;
+}
+/** The single structural hash the admission compares (KTD6). */
+function structuralHash(input, hash) {
+	return hash(serializeSurvivorsHashInput(input));
+}
+/**
+* Converts a report mutant (1-based schema location) into the internal mutant
+* shape a run consumes (0-based positions, absolute file name) — the exact
+* inverse of `objectUtils.toSchemaLocation` and the same shift the
+* incremental report reader applies (`project-reader.ts`). Mutants without a
+* replacement fall back to their mutator name, the same convention the
+* incremental differ uses.
+*/
+function reportMutantToMutant(file, mutant, resolveAbsolutePath) {
+	return {
+		id: mutant.id,
+		fileName: resolveAbsolutePath(file),
+		mutatorName: mutant.mutatorName,
+		replacement: mutant.replacement ?? mutant.mutatorName,
+		location: {
+			start: {
+				line: mutant.location.start.line - 1,
+				column: mutant.location.start.column - 1
+			},
+			end: {
+				line: mutant.location.end.line - 1,
+				column: mutant.location.end.column - 1
+			}
+		}
+	};
+}
+/**
+* The survivors of the prior report: exactly the mutants whose status is
+* `Survived`, converted to the internal mutant shape so a run can re-test
+* them.
+*/
+function extractSurvivors(priorReport, resolveAbsolutePath) {
+	const survivors = [];
+	for (const [file, fileResult] of objectEntries(priorReport.files)) for (const mutant of fileResult.mutants) if (mutant.status === "Survived") survivors.push(reportMutantToMutant(file, mutant, resolveAbsolutePath));
+	return survivors;
+}
+/**
+* The survivor spans as `file:startLine:startCol-endLine:endCol` mutate
+* ranges: the report's 1-based lines with the internal 0-based columns,
+* relative file names, deduplicated in first-seen order.
+*/
+function survivorMutateSpans(survivors) {
+	const spans = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const survivor of survivors) {
+		const file = toRelativeNormalizedFileName(survivor.fileName);
+		const { start, end } = survivor.location;
+		const span = `${file}:${start.line + 1}:${start.column}-${end.line + 1}:${end.column}`;
+		if (!seen.has(span)) {
+			seen.add(span);
+			spans.push(span);
+		}
+	}
+	return spans;
+}
+const NO_REPORT_DETAIL = "No prior mutation report found — a --survivors run needs the report of a previous run.";
+const SURVIVORS_RUN_SOURCE_DETAIL = "The prior mutation report was itself produced by a --survivors run, so it is not a valid input for another one.";
+const MISMATCH_DETAIL = "The prior mutation report does not match the current run (resolved options, framework version, or source content differ).";
+/** The per-file source hashes of the sources the prior report embeds. */
+function priorSourceHashes(priorReport, hashContent) {
+	return objectFromEntries(objectEntries(priorReport.files).map(([file, fileResult]) => [file, sourceContentHash(fileResult.source, hashContent)]));
+}
+/**
+* Whether the admission hashes agree: the prior report's embedded resolved
+* options, framework version and source content against the current run's.
+*/
+function hashesMatch(priorReport, input) {
+	return structuralHash({
+		resolvedOptions: stripSurvivorsKeys(priorReport.config),
+		frameworkVersion: priorReport.framework?.version,
+		sourceContentHashes: priorSourceHashes(priorReport, input.hashContent)
+	}, input.hashContent) === structuralHash({
+		resolvedOptions: stripSurvivorsKeys(input.currentConfig),
+		frameworkVersion: input.frameworkVersion,
+		sourceContentHashes: input.sourceContentHashes
+	}, input.hashContent);
+}
+const rejection = (reason, detail) => ({
+	kind: "reject",
+	reason,
+	remediation: `${detail} ${SURVIVORS_RUN_FIRST_REMEDIATION}`
+});
+function admissionVerdict(input) {
+	const priorReport = input.priorReport;
+	if (priorReport === void 0) return rejection("no-report", NO_REPORT_DETAIL);
+	if (wasProducedBySurvivorsRun(priorReport)) return rejection("mismatch", SURVIVORS_RUN_SOURCE_DETAIL);
+	const survivors = extractSurvivors(priorReport, input.resolveAbsolutePath);
+	if (survivors.length === 0) return { kind: "no-survivors" };
+	if (!hashesMatch(priorReport, input)) return rejection("mismatch", MISMATCH_DETAIL);
+	return {
+		kind: "admit",
+		survivors
+	};
+}
+const SurvivorsAdmissionTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/SurvivorsAdmission");
+var Admitted = class extends S.TaggedClass()("Admitted", { survivors: S.Array(S.Struct({
+	id: S.String,
+	fileName: S.String,
+	mutatorName: S.String,
+	replacement: S.String,
+	location: S.Struct({
+		start: S.Struct({
+			line: S.Finite,
+			column: S.Finite
+		}),
+		end: S.Struct({
+			line: S.Finite,
+			column: S.Finite
+		})
+	})
+})) }) {
+	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
+};
+var NoSurvivors = class extends S.TaggedClass()("NoSurvivors", {}) {
+	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
+};
+S.Union([Admitted, NoSurvivors]);
+var SurvivorsRejection = class extends S.TaggedError()("SurvivorsRejection", {
+	reason: S.Literals(["no-report", "mismatch"]),
+	remediation: S.String
+}) {
+	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
+};
+/**
+* The survivors admission decision: the classification `admissionVerdict`
+* produces, assigned to the workflow channels — one arm per kind, no guard
+* chain. A missing report, a survivors-sourced report and a hash mismatch are
+* the same reject outcome with different reasons; only the rejection's
+* remediation names the full run to do first (R10).
+*/
+const admitSurvivorsRun = Workflow.make((command) => Match.value(admissionVerdict(command)).pipe(Match.discriminator("kind")("reject", (verdict) => Result.fail(SurvivorsRejection.make({
+	reason: verdict.reason,
+	remediation: verdict.remediation
+}))), Match.discriminator("kind")("no-survivors", () => Result.succeed(NoSurvivors.make())), Match.discriminator("kind")("admit", (verdict) => Result.succeed(Admitted.make({ survivors: verdict.survivors }))), Match.exhaustive));
+//#endregion
+//#region src/SurvivorsExit.ts
+/** The exit class a rejected survivors run exits with (R6: exit 2). */
+const SURVIVORS_REJECT_EXIT_CLASS = ExitClass.ConfigError;
+S.Union([S.TaggedStruct("run", {
+	options: S.Any,
+	survivors: S.Boolean
+}), S.TaggedStruct("llms", { document: S.Any })]);
+//#endregion
+//#region src/StrykerCliExecutor.ts
+/**
+* The default run: binds the host-resolved run options (the sink, the mode,
+* the timing) to a fresh `Stryker` and runs mutation testing.
+*/
+const defaultRunMutationTest = (hostOptions) => (options) => new Stryker(options, hostOptions).runMutationTest();
+/**
+* The machine-mode `Console` layer, bundled so the transport (which resolves
+* the mode) can provide it without importing the state cell. Human mode
+* provides no layer — effect's own default console is the prose rendering
+* (OutputModeConsoleState.ts).
+*/
+const strykerCliConsoleLayers = { machine: machineConsoleLayer };
+const SIGNAL_NUMBERS = Object.freeze({
+	SIGINT: 2,
+	SIGTERM: 15
+});
+const hashContent = (content) => createHash("sha256").update(content, "utf-8").digest("hex");
+const resolveAbsolutePath = (file) => resolve(file);
+/**
+* The host options a run is bound to: the sink, the mode, the timing and the
+* log descriptor chosen by the mode — machine mode keeps stdout exclusively
+* for the NDJSON stream, so the logging backend is pointed at stderr; human
+* mode keeps the stdout sink. The fix is the descriptor, never the log level.
+*/
+function hostOptionsOf(mode, stream) {
+	return {
+		loggerConsoleOut: mode.mode === "machine" ? process.stderr : process.stdout,
+		showColors: isColorEnabled(mode, process.env["NO_COLOR"]),
+		runEventSink: stream.sink,
+		runId: stream.runId,
+		resolvedMode: mode,
+		progressEnabled: isProgressEnabled(mode),
+		clearTextEnabled: mode.mode === "human",
+		runStartedAt: stream.startedAt,
+		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-mutation-report/stryker-plugins")]
+	};
+}
+/**
+* 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) => pipe(Cell.read((cliOptions) => Effect.promise(() => resolveSurvivorsRunOptions(cliOptions)).pipe(Effect.flatMap((resolvedOptions) => {
+	const priorReportPath = priorReportPathOf(resolvedOptions);
+	const priorReport = readPriorReport(priorReportPath);
+	return Ref.set(runContext, {
+		resolvedOptions,
+		priorReportPath
+	}).pipe(Effect.as({
+		resolvedOptions,
+		priorReport,
+		priorReportPath,
+		sourceContentHashes: sourceContentHashesOf(priorReport)
+	}));
+}))), Cell.decode(({ resolvedOptions, priorReport, sourceContentHashes }) => Result.succeed({
+	priorReport,
+	currentConfig: resolvedOptions,
+	frameworkVersion: strykerVersion,
+	sourceContentHashes,
+	hashContent,
+	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 } = context;
+	return Result.match(outcome, {
+		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("NoSurvivors", () => Effect.sync(() => emitEmptySurvivorsVerdict(stream, mode, resolvedOptions))), Match.tag("Admitted", (admitted) => {
+			const restricted = {
+				...resolvedOptions,
+				survivors: admitted.survivors,
+				mutate: survivorMutateSpans(admitted.survivors),
+				survivorsPriorReport: priorReportPath,
+				incremental: false
+			};
+			return Effect.promise(() => runMutationTest(restricted));
+		}), 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.
+*/
+function runSurvivorsAdmission(runMutationTest, stream, mode, cliOptions) {
+	return Effect.gen(function* () {
+		const admissionContext = yield* Ref.make(void 0);
+		return yield* Cell.apply(survivorsAdmissionDescription(runMutationTest, stream, mode, admissionContext), cliOptions);
+	});
+}
+/**
+* Resolves the current options the same way the pipeline does — defaults +
+* config file + CLI, validated against the fork schema (which carries the
+* survivors-run properties). The admission hash compares these resolved
+* options against the prior report's embedded config.
+*/
+function resolveSurvivorsRunOptions(cliOptions) {
+	return new ConfigReader(noopLogger, new OptionsValidator(forkCoreSchema, noopLogger)).readConfig(cliOptions);
+}
+/**
+* The prior report a `--survivors` run reads: the `survivorsPriorReport`
+* config option when set, else the default path. The report path is run
+* bookkeeping, never a CLI flag.
+*/
+function priorReportPathOf(resolved) {
+	const configured = resolved["survivorsPriorReport"];
+	return typeof configured === "string" ? configured : DEFAULT_SURVIVORS_PRIOR_REPORT;
+}
+/**
+* A report is usable only when it parses and carries a `files` dictionary; a
+* missing, unreadable or misshapen report is the `no-report` rejection.
+*/
+function isMutationTestResultShape(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	return "files" in value && typeof value.files === "object" && value.files !== null && !Array.isArray(value.files);
+}
+function readPriorReport(priorReportPath) {
+	try {
+		const raw = readFileSync(priorReportPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		return isMutationTestResultShape(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function readSourceFile(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return "";
+	}
+}
+/**
+* The per-file content hashes of the current sources, keyed by the relative
+* file names the prior report uses — the current side of the admission
+* comparison (`admitSurvivorsRun` hashes the prior side from the sources the
+* report embeds).
+*/
+function sourceContentHashesOf(priorReport) {
+	const hashes = {};
+	if (priorReport === void 0) return hashes;
+	for (const file of Object.keys(priorReport.files)) hashes[file] = sourceContentHash(readSourceFile(file), hashContent);
+	return hashes;
+}
+/**
+* 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) {
+	const report = {
+		schemaVersion: "1.0",
+		files: {},
+		thresholds,
+		projectRoot: process.cwd(),
+		config,
+		framework: {
+			name: "StrykerJS",
+			version: strykerVersion
+		}
+	};
+	const envelope = buildVerdictEnvelope(report, mode.mode, mode.signal, stream.runId);
+	stream.sink({
+		kind: "verdict",
+		...envelope
+	});
+}
+/**
+* The `--survivors` zero-survivor path: the prior report held no survivors,
+* so the run emits the null-score verdict without starting the pipeline. The
+* full resolved options ride along as the report's embedded config (KTD7).
+*/
+function emitEmptySurvivorsVerdict(stream, mode, resolved) {
+	emitNullScoreVerdict(stream, mode, resolved.thresholds, resolved);
+}
+/**
+* The contextual remediation for a failure, picked from the cause's shape:
+* signal terminations (POSIX `128 + n`) are called out as interruptions,
+* usage/parse errors point at `--help`, config errors name the offending file
+* (ConfigError messages carry it), and rejected survivors runs name the full
+* run to do first. Everything else points at the report file and the verdict
+* envelope, which is where a runtime failure's detail already is.
+*/
+function remediationFor(exit, code) {
+	if (code > 128) return "the run was interrupted by a signal; re-run it to continue";
+	const value = failureValue(exit);
+	if (value !== void 0) {
+		if (CliError.isCliError(value)) return "re-run with --help to see the full usage";
+		if (value instanceof ConfigError) return `check the config file: ${value.message}`;
+		if (S.is(SurvivorsRejection)(value)) return value.remediation;
+	}
+	return "see --reportFile or the verdict envelope on stdout";
+}
+/**
+* The failure's own text, used when the capture buffer is empty — a failure
+* stryker reported through its own logger rather than the framework's
+* `Console`. Falls back to a rendered cause.
+*/
+function describeFailure(exit) {
+	if (Exit.isFailure(exit)) {
+		const value = failureValue(exit);
+		if (value !== void 0) {
+			if (S.is(SurvivorsRejection)(value)) return value.remediation;
+			if (value instanceof Error) return value.message;
+			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") return String(value);
+			return Object.prototype.toString.call(value);
+		}
+		return Cause.pretty(exit.cause);
+	}
+	return "";
+}
+/**
+* The argument the framework reports it does not know, named the way the wire
+* contract spells it. The v4 parser fails wrapped in a ShowHelp whose errors
+* carry the offending flag or operand; when the unrecognized flag was given a
+* separate value (`--format text`), the value is the token the old parser
+* reported, so the token after the flag is named when one was given.
+*/
+function unrecognizedArgumentOf(exit, argv) {
+	if (!Exit.isFailure(exit)) return;
+	const value = failureValue(exit);
+	if (value === void 0 || !CliError.isCliError(value)) return;
+	const errors = S.is(CliError.ShowHelp)(value) ? value.errors : [value];
+	for (const error of errors) {
+		if (S.is(CliError.UnrecognizedOption)(error)) {
+			const at = argv.indexOf(error.option);
+			const next = at >= 0 ? argv[at + 1] : void 0;
+			return next !== void 0 && !next.startsWith("-") ? next : error.option;
+		}
+		if (S.is(CliError.UnexpectedArgument)(error)) return error.arguments[0];
+		if (S.is(CliError.UnknownSubcommand)(error)) return error.subcommand;
+	}
+}
+/**
+* The first typed error in the exit's cause. The framework fails with
+* `Cause.fail` (usage errors); the run handler is `Effect.promise`, whose
+* rejected promises surface as *defects* (`Die` reasons) rather than
+* failures — so stryker's own ConfigError/StrykerError values arrive there
+* and must be read from the cause's `Die` reasons.
+*/
+function failureValue(exit) {
+	if (!Exit.isFailure(exit)) return;
+	const failure = Cause.findErrorOption(exit.cause);
+	if (Option.isSome(failure)) return failure.value;
+	const dieReason = exit.cause.reasons.find(Cause.isDieReason);
+	return dieReason === void 0 ? void 0 : dieReason.defect;
+}
+function buildErrorEnvelope(exit, code, captured, argv) {
+	const unrecognized = unrecognizedArgumentOf(exit, argv);
+	return {
+		schemaVersion: "1.0",
+		code,
+		error: unrecognized !== void 0 ? `Received unknown argument: '${unrecognized}'` : captured.length > 0 ? captured : describeFailure(exit),
+		remediation: remediationFor(exit, code)
+	};
+}
+/**
+* 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 emitMachineModeOutput(stream, mode, exit, code, argv) {
+	const captured = readCapturedConsole();
+	const value = failureValue(exit);
+	if (Exit.isFailure(exit) && S.is(CliError.ShowHelp)(value) && value.errors.length === 0) {
+		const document = {
+			kind: "help",
+			schemaVersion: "1.0",
+			code: 0,
+			help: captured
+		};
+		stream.sink(document);
+		return;
+	}
+	if (Exit.isFailure(exit)) {
+		stream.sink({
+			kind: "error",
+			...buildErrorEnvelope(exit, code, captured, argv)
+		});
+		return;
+	}
+	if (captured.length > 0) {
+		const document = {
+			kind: "help",
+			schemaVersion: "1.0",
+			code: 0,
+			help: captured
+		};
+		stream.sink(document);
+		return;
+	}
+	if (stream.isOpen()) emitNullScoreVerdict(stream, mode, defaultOptions.thresholds, {});
+}
+/**
+* A rejected config reaches the finalizer as a typed failure or as a defect
+* depending on where the validator threw, and typed-inject may have wrapped
+* it, so both channels are searched and each candidate is unwrapped.
+*/
+function carriesConfigError(cause) {
+	for (const reason of cause.reasons) {
+		const candidate = Cause.isFailReason(reason) ? reason.error : Cause.isDieReason(reason) ? reason.defect : void 0;
+		if (candidate !== void 0 && (candidate instanceof ConfigError || retrieveCause(candidate) instanceof ConfigError)) return true;
+	}
+	return false;
+}
+/**
+* Classifies a failed run for the finalizer: usage/parse failures
+* (`CliError` — except a bare help request, which exits 0), rejected
+* survivors runs (`SurvivorsRejection`) and a rejected config (`ConfigError`)
+* all exit 2, all other failures exit 1 (the framework's default). A
+* successful run exits 0; the verdict gates (U5) then resolve the final
+* classed code.
+*/
+function resolveCliExitCode(exit) {
+	if (Exit.isSuccess(exit)) return 0;
+	if (Cause.hasInterruptsOnly(exit.cause)) return 1;
+	const failure = Cause.findErrorOption(exit.cause);
+	if (Option.isSome(failure)) {
+		const value = failure.value;
+		if (S.is(CliError.ShowHelp)(value)) return value.errors.length > 0 ? 2 : 0;
+		if (CliError.isCliError(value)) return 2;
+		if (S.is(SurvivorsRejection)(value)) return SURVIVORS_REJECT_EXIT_CLASS;
+	}
+	if (carriesConfigError(exit.cause)) return ExitClass.ConfigError;
+	return 1;
+}
+/**
+* The single operation of the CLI's executor cell: the impure shell that
+* wraps the transport's command effect with the run bootstrap. It creates the
+* run's stream from the resolved mode, binds the host options a run is
+* executed with, opens the stream, runs the command effect, dispatches the
+* request the handlers left, and on every outcome — success, failure and
+* interruption alike — emits the machine-mode terminal event (error/help/
+* null verdict) and drains the stream, returning the classed exit code as its
+* value. SIGINT/SIGTERM interrupt the current fiber so the finalizer runs
+* before the process exits; the code is resolved exactly once (R6), in the
+* finalizer, where the terminal event's `code` is chosen from the same inputs
+* the teardown used before.
+*/
+const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
+	const stream = yield* createRunEventStream(input.mode);
+	const runMutationTest = input.runMutationTest ?? defaultRunMutationTest(hostOptionsOf(input.mode, stream));
+	let currentFiber = null;
+	let lastSignal = null;
+	const resolveClassedExitCode = (exit) => {
+		const signal = lastSignal;
+		if (signal !== null) return 128 + signal;
+		if (Exit.isFailure(exit)) return resolveCliExitCode(exit);
+		return resolveExitCode(getPendingExitClasses(), null);
+	};
+	const onSignal = (signal) => {
+		lastSignal = SIGNAL_NUMBERS[signal] ?? null;
+		process.removeListener("SIGINT", onSignal);
+		process.removeListener("SIGTERM", onSignal);
+		if (currentFiber !== null) currentFiber.interruptUnsafe(currentFiber.id);
+	};
+	const dispatch = (request) => Match.value(request).pipe(Match.tag("run", (runRequest) => runRequest.survivors ? runSurvivorsAdmission(runMutationTest, stream, input.mode, runRequest.options) : Effect.promise(() => runMutationTest(runRequest.options))), Match.tag("llms", (llmsRequest) => Effect.sync(() => {
+		stream.ensureOpen({
+			mode: "machine",
+			signal: "flag",
+			stdoutIsTTY: process.stdout.isTTY === true
+		});
+		stream.sink(llmsRequest.document);
+	})), Match.orElse(() => Effect.die("unreachable cli request variant")));
+	const program = Effect.acquireUseRelease(Effect.sync(() => {
+		currentFiber = Fiber.getCurrent() ?? null;
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+	}), () => Effect.gen(function* () {
+		yield* stream.open;
+		yield* input.program;
+		const request = yield* Ref.get(input.requestRef);
+		yield* Option.match(request, {
+			onNone: () => Effect.void,
+			onSome: (cliRequest) => dispatch(cliRequest)
+		});
+	}), () => Effect.sync(() => {
+		process.removeListener("SIGINT", onSignal);
+		process.removeListener("SIGTERM", onSignal);
+	}));
+	return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const exit = yield* Effect.exit(restore(program));
+		const code = resolveClassedExitCode(exit);
+		input.recordExitCode(code);
+		if (input.mode.mode === "machine") emitMachineModeOutput(stream, input.mode, exit, code, input.argv);
+		yield* stream.closeAndDrain;
+		return code;
+	}));
+});
+//#endregion
+//#region src/StrykerCliHandler.ts
+function createSplitter(separator) {
+	return (value) => value.split(separator).filter(Boolean);
+}
+const splitOnComma = createSplitter(",");
+const splitOnSpace = createSplitter(" ");
+/**
+* Commander characterization: `always` stays a string, everything else is a
+* boolean where `false`/`0` (case-insensitively) mean `false` — a tri-state a
+* plain boolean or choice would flatten.
+*/
+function parseCleanDirOption(value) {
+	const v = value.toLocaleLowerCase();
+	return v === "always" ? v : v !== "false" && v !== "0";
+}
+/**
+* Commander characterization: a pure integer is parsed as a number, anything
+* else (e.g. `"50%"`) stays a string.
+*/
+function parseConcurrency(value) {
+	if (/^\d+$/.test(value)) return parseInt(value, 10);
+	return value;
+}
+const optional = (option) => Flag.optional(option);
+/**
+* Commander left an omitted flag out of the parsed options; `deepMerge` treats
+* `undefined` as absent but an explicit `false` would override a config-file
+* `true`. The framework's boolean defaults to `false` when absent, so map that
+* back to `undefined` (KTD4).
+*/
+const absentWhenFalse = (value) => value ? true : void 0;
+const LOG_LEVELS = [
+	"fatal",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace",
+	"off"
+];
+const LOG_LEVEL_LOOKUP = {
+	fatal: true,
+	error: true,
+	warn: true,
+	info: true,
+	debug: true,
+	trace: true,
+	off: true
+};
+function isLogLevel(value) {
+	return LOG_LEVEL_LOOKUP[value] === true;
+}
+function setLogLevel(target, key, value) {
+	const unwrapped = unwrap(value);
+	if (unwrapped !== void 0 && isLogLevel(unwrapped)) target[key] = unwrapped;
+}
+const runOptions = {
+	ignorePatterns: Flag.string("ignorePatterns").pipe(Flag.withDescription("A comma separated list of patterns used for specifying which files need to be ignored. This should only be used in cases where you experience a slow Stryker startup, because too many (or too large) files are copied to the sandbox that are not needed to run the tests. For example, image or movie directories. Note: This option will have NO effect when using the `--inPlace` option. The directories `node_modules`, `.git` and some others are always ignored. Example: `--ignorePatterns dist`. These patterns are ALWAYS ignored: [`node_modules`, `.git`, `/reports`, `*.tsbuildinfo`, `/stryker.log`, `.stryker-tmp`]. Because Stryker always ignores these, you should rarely have to adjust the `ignorePatterns` setting at all. This is useful to speed up Stryker by reducing the size of the sandbox directory which has a positive effect on performance."), Flag.map(splitOnComma), optional),
+	ignoreStatic: Flag.map(Flag.boolean("ignoreStatic"), absentWhenFalse).pipe(Flag.withDescription("Ignore static mutants. Static mutants are mutants which are only executed during the loading of a file.")),
+	incremental: Flag.map(Flag.boolean("incremental"), absentWhenFalse).pipe(Flag.withDescription("Enable 'incremental mode'. Stryker will store results in a file and use that file to speed up the next --incremental run")),
+	allowEmpty: Flag.map(Flag.boolean("allowEmpty"), absentWhenFalse).pipe(Flag.withDescription("Allows stryker to exit without any errors in cases where no tests are found")),
+	incrementalFile: Flag.string("incrementalFile").pipe(Flag.withDescription("Specify the file to use for incremental mode."), optional),
+	force: Flag.map(Flag.boolean("force"), absentWhenFalse).pipe(Flag.withDescription("Run all mutants, even if --incremental is provided and an incremental file exists. Can be used to force a rebuild of the incremental file.")),
+	mutate: Flag.string("mutate").pipe(Flag.withAlias("m"), Flag.withDescription("With `mutate` you configure the subset of files or just one specific file to be mutated. These should be your _production code files_, and definitely not your test files. (Whereas with `ignorePatterns` you prevent non-relevant files from being copied to the sandbox directory in the first place)\nThe default will try to guess your production code files based on sane defaults. It reads like this:\n- Include all js-like files inside the `src` or `lib` dir\n- Except files inside `__tests__` directories and file names ending with `test` or `spec`.\nIf the defaults are not sufficient for you, for example in a angular project you might want to **exclude** not only the `*.spec.ts` files but other files too, just like the default already does.\nIt is possible to override the defaults by: - supplying one or more [glob patterns](https://github.com/isaacs/minimatch) to include (e.g. `src/**/*.js`) - or one or more comma separated glob patterns preceded with `!` to exclude (e.g. `!src/**/*.spec.js`) - or both (e.g. `src/**/*.js,!src/**/*.spec.js`).\nNote: Stryker will use [minimatch](https://github.com/isaacs/minimatch) for parsing these patterns, see minimatch for the exact syntax."), Flag.map(splitOnComma), optional),
+	testFiles: Flag.string("testFiles").pipe(Flag.withAlias("t"), Flag.withDescription("With `testFiles` you can limit which test files are executed during mutation testing. When specified, only tests from these files will be run. This allows you to verify that a module's dedicated unit tests can kill all its mutants independently."), Flag.map(splitOnComma), optional),
+	buildCommand: Flag.string("buildCommand").pipe(Flag.withAlias("b"), Flag.withDescription("Configure a build command to run after mutating the code, but before mutants are tested. This is generally used to transpile your code before testing. Only configure this if your test runner doesn't take care of this already and you're not using just-in-time transpiler like `babel/register` or `ts-node`."), optional),
+	dryRunOnly: Flag.map(Flag.boolean("dryRunOnly"), absentWhenFalse).pipe(Flag.withDescription("Execute the initial test run only, without doing actual mutation testing. Doing a dry run only can be used to test that StrykerJS can run your test setup, for example, in CI pipelines.")),
+	checkers: Flag.string("checkers").pipe(Flag.withDescription("A comma separated list of checkers to use, for example --checkers typescript"), Flag.map(splitOnComma), optional),
+	checkerNodeArgs: Flag.string("checkerNodeArgs").pipe(Flag.withDescription("A list of node args to be passed to checker child processes. Split on spaces (commander characterization): `--checkerNodeArgs \"--inspect-brk --trace-warnings\"`."), Flag.map(splitOnSpace), optional),
+	coverageAnalysis: Flag.choice("coverageAnalysis", [
+		"perTest",
+		"all",
+		"off"
+	]).pipe(Flag.withDescription(`The coverage analysis strategy you want to use. Default value: "${defaultOptions.coverageAnalysis}"`), optional),
+	testRunner: Flag.string("testRunner").pipe(Flag.withDescription("The name of the test runner you want to use"), optional),
+	testRunnerNodeArgs: Flag.string("testRunnerNodeArgs").pipe(Flag.withDescription("A list of node args to be passed to test runner child processes. Split on spaces (commander characterization): `--testRunnerNodeArgs \"--inspect-brk --trace-warnings\"`."), Flag.map(splitOnSpace), optional),
+	reporters: Flag.string("reporters").pipe(Flag.withDescription("A comma separated list of the names of the reporter(s) you want to use"), Flag.map(splitOnComma), optional),
+	plugins: Flag.string("plugins").pipe(Flag.withDescription("A list of plugins you want stryker to load (`require`)."), Flag.map(splitOnComma), optional),
+	appendPlugins: Flag.string("appendPlugins").pipe(Flag.withDescription("A list of additional plugins you want Stryker to load (`require`) without overwriting the (default) `plugins`."), Flag.map(splitOnComma), optional),
+	timeoutMS: Flag.integer("timeoutMS").pipe(Flag.withDescription("Tweak the absolute timeout used to wait for a test runner to complete"), optional),
+	timeoutFactor: Flag.float("timeoutFactor").pipe(Flag.withDescription("Tweak the standard deviation relative to the normal test run of a mutated test"), optional),
+	dryRunTimeoutMinutes: Flag.float("dryRunTimeoutMinutes").pipe(Flag.withDescription("Configure an absolute timeout for the initial test run. (It can take a while.)"), optional),
+	maxConcurrentTestRunners: Flag.integer("maxConcurrentTestRunners").pipe(Flag.withDescription("Set the number of max concurrent test runner to spawn (default: cpuCount)"), optional),
+	concurrency: Flag.string("concurrency").pipe(Flag.withAlias("c"), Flag.withDescription("Set the concurrency of workers. Stryker will always run checkers and test runners in parallel by creating worker processes (default: cpuCount - 1)"), Flag.map(parseConcurrency), optional),
+	disableBail: Flag.map(Flag.boolean("disableBail"), absentWhenFalse).pipe(Flag.withDescription("Force the test runner to keep running tests, even when a mutant is already killed.")),
+	maxTestRunnerReuse: Flag.integer("maxTestRunnerReuse").pipe(Flag.withDescription("Restart each test runner worker process after `n` runs. Not recommended unless you are experiencing memory leaks that you are unable to resolve. Configuring `0` here means infinite reuse."), optional),
+	logLevel: Flag.choice("logLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the console. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${defaultOptions.logLevel}"`), optional),
+	fileLogLevel: Flag.choice("fileLogLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the "stryker.log" file. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${defaultOptions.fileLogLevel}"`), optional),
+	inPlace: Flag.map(Flag.boolean("inPlace"), absentWhenFalse).pipe(Flag.withDescription("Determines whether or not Stryker should mutate your files in place. Note: mutating your files in place is generally not needed for mutation testing, unless you have a dependency in your project that is really dependent on the file locations (like \"app-root-path\" for example).\nWhen `true`, Stryker will override your files, but it will keep a copy of the originals in the temp directory (using `tempDirName`) and it will place the originals back after it is done. Also with `true` the `ignorePatterns` has no effect any more.\nWhen `false` (default) Stryker will work in the copy of your code inside the temp directory.")),
+	tempDirName: Flag.string("tempDirName").pipe(Flag.withDescription("Set the name of the directory that is used by Stryker as a working directory. This directory will be cleaned after a successful run"), optional),
+	cleanTempDir: Flag.string("cleanTempDir").pipe(Flag.withDescription(`Choose whether or not to clean the temp dir (which is "${defaultOptions.tempDirName}" inside the current working directory by default) after a run.\n- false: Never delete the temp dir;\n- true: Delete the tmp dir after a successful run;\n- always: Always delete the temp dir, regardless of whether the run was successful.`), Flag.map(parseCleanDirOption), optional),
+	survivors: Flag.map(Flag.boolean("survivors"), absentWhenFalse).pipe(Flag.withDescription("Re-run only the mutants that survived a previous run. Admits against the previous run's mutation report (the `survivorsPriorReport` config option, default `reports/mutation-report.json`) and re-tests exactly the survivor set. Exits 2 with a remediation naming a full run when the report is missing, drifted, or the configuration changed; exits 0 with a null score when the report has no survivors."))
+};
+const runArgs = { configFile: Argument.optional(Argument.string("configFile")) };
+const runConfig = {
+	...runOptions,
+	...runArgs
+};
+const rootConfig = { llms: Flag.map(Flag.boolean("llms"), absentWhenFalse).pipe(Flag.withDescription("Print the agent-facing command manifest as one JSON object on stdout: every option, alias, kind, default, allowed value set and description, plus the subcommands and positional arguments, walked from the command descriptors.")) };
+function unwrap(value) {
+	if (Option.isOption(value)) return Option.match(value, {
+		onNone: () => void 0,
+		onSome: (v) => v
+	});
+	return value;
+}
+function setIfPresent(target, key, value) {
+	const unwrapped = unwrap(value);
+	if (unwrapped !== void 0) target[key] = unwrapped;
+}
+/**
+* Builds the full command tree — root plus the `run` subcommand — from the
+* same option/arg records the parser matches against. Each handler leaves the
+* request the executor runs: the run handler writes the parsed options (and
+* the survivors flag, which the admission consumes and the pipeline must not
+* see), the `--llms` handler writes the pre-rendered manifest document, and
+* the bare root writes nothing — `helpRequested` makes the framework render
+* help, which the executor's finalizer turns into the `help` terminal event.
+*/
+function makeStrykerCommand(requestRef) {
+	const runCommand = Command.make("run", runConfig, (config) => {
+		const configFile = Option.getOrUndefined(config.configFile);
+		if (configFile !== void 0 && configFile.startsWith("-")) return Console.error(`Received unknown argument: '${configFile}'`).pipe(Effect.andThen(Effect.failSync(() => CliError.UnexpectedArgument.make({ arguments: [configFile] }))));
+		return Ref.set(requestRef, Option.some({
+			_tag: "run",
+			options: readStrykerOptions(config),
+			survivors: config.survivors === true
+		}));
+	}).pipe(Command.withDescription("Run mutation testing"));
+	/**
+	* Rebuilds the `PartialStrykerOptions` object commander produced: only options
+	* actually given on the command line become keys (KTD4). `survivors` is
+	* deliberately not forwarded — the survivor re-run logic (U8) consumes it.
+	*/
+	function readStrykerOptions(config) {
+		const options = {};
+		setIfPresent(options, "ignorePatterns", config.ignorePatterns);
+		setIfPresent(options, "ignoreStatic", config.ignoreStatic);
+		setIfPresent(options, "incremental", config.incremental);
+		setIfPresent(options, "allowEmpty", config.allowEmpty);
+		setIfPresent(options, "incrementalFile", config.incrementalFile);
+		setIfPresent(options, "force", config.force);
+		setIfPresent(options, "mutate", config.mutate);
+		setIfPresent(options, "testFiles", config.testFiles);
+		setIfPresent(options, "buildCommand", config.buildCommand);
+		setIfPresent(options, "dryRunOnly", config.dryRunOnly);
+		setIfPresent(options, "checkers", config.checkers);
+		setIfPresent(options, "checkerNodeArgs", config.checkerNodeArgs);
+		setIfPresent(options, "coverageAnalysis", config.coverageAnalysis);
+		setIfPresent(options, "testRunner", config.testRunner);
+		setIfPresent(options, "testRunnerNodeArgs", config.testRunnerNodeArgs);
+		setIfPresent(options, "reporters", config.reporters);
+		setIfPresent(options, "plugins", config.plugins);
+		setIfPresent(options, "appendPlugins", config.appendPlugins);
+		setIfPresent(options, "timeoutMS", config.timeoutMS);
+		setIfPresent(options, "timeoutFactor", config.timeoutFactor);
+		setIfPresent(options, "dryRunTimeoutMinutes", config.dryRunTimeoutMinutes);
+		setIfPresent(options, "maxConcurrentTestRunners", config.maxConcurrentTestRunners);
+		setIfPresent(options, "concurrency", config.concurrency);
+		setIfPresent(options, "disableBail", config.disableBail);
+		setIfPresent(options, "maxTestRunnerReuse", config.maxTestRunnerReuse);
+		setLogLevel(options, "logLevel", config.logLevel);
+		setLogLevel(options, "fileLogLevel", config.fileLogLevel);
+		setIfPresent(options, "inPlace", config.inPlace);
+		setIfPresent(options, "tempDirName", config.tempDirName);
+		setIfPresent(options, "cleanTempDir", config.cleanTempDir);
+		if (Option.isSome(config["configFile"])) options["configFile"] = config["configFile"].value;
+		return options;
+	}
+	const strykerCommand = Command.make("stryker", rootConfig, (config) => {
+		if (config.llms === true) {
+			const document = {
+				kind: "manifest",
+				schemaVersion: "1.0",
+				code: 0,
+				manifest: emitLLMSManifest(strykerCommand, strykerVersion)
+			};
+			return Ref.set(requestRef, Option.some({
+				_tag: "llms",
+				document
+			}));
+		}
+		return Effect.failSync(() => CliError.ShowHelp.make({
+			commandPath: ["stryker"],
+			errors: []
+		}));
+	}).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),
+	readInput: Effect.die(/* @__PURE__ */ new Error("stryker has no interactive prompts: Terminal.readInput is not supported")),
+	readLine: Effect.die(/* @__PURE__ */ new Error("stryker has no interactive prompts: Terminal.readLine is not supported")),
+	display: (text) => Effect.sync(() => {
+		process.stdout.write(text);
+	})
+}));
+const cliLayer = Layer.mergeAll(CliConfig.layer({ builtIns: [
+	GlobalFlag.Help,
+	GlobalFlag.action({
+		flag: Flag.boolean("version").pipe(Flag.withAlias("v"), Flag.withDescription("Show version information")),
+		run: () => Console.log(strykerVersion)
+	}),
+	GlobalFlag.Wizard,
+	GlobalFlag.Completions,
+	GlobalFlag.LogLevel
+] }), Path.layer, FileSystem.layerNoop({}), terminalLayer, NodeStdio.layer, Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, ChildProcessSpawner.make(() => Effect.die("no child processes"))));
+/**
+* The transport entry: builds the command tree, resolves the mode once at
+* the edge (never a second probe), provides the CLI and Console layers the
+* framework renders through, delegates the whole run to the executor cell and
+* returns the classed exit code it computes. The executor is the I/O
+* sandwich; this function only frames it.
+*/
+function strykerCliEffect(argv, runMutationTest, recordExitCode, detectMode, createRunEventStream) {
+	return Effect.gen(function* () {
+		const mode = detectMode();
+		const requestRef = yield* Ref.make(Option.none());
+		const command = makeStrykerCommand(requestRef);
+		const cliEffect = Command.runWith(command, { version: strykerVersion })(argv).pipe(Effect.provide(Layer.mergeAll(mode.mode === "machine" ? strykerCliConsoleLayers.machine : Layer.empty, cliLayer)));
+		const outcome = yield* Effect.result(runStrykerCli({
+			program: cliEffect,
+			requestRef,
+			mode,
+			runMutationTest,
+			recordExitCode,
+			argv
+		}, createRunEventStream));
+		return Result.isFailure(outcome) ? outcome.failure : outcome.success;
+	});
+}
+//#endregion
+//#region src/main.ts
+const EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER = 1;
+process.title = "stryker";
+if (!semver.satisfies(process.version, strykerEngines.node)) 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`);
+const resolvedExitCode = { current: EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER };
+const program = Effect.gen(function* () {
+	const outputMode = yield* OutputModeProbe;
+	const runEvents = yield* RunEventStreamPort;
+	return yield* strykerCliEffect(process.argv.slice(2), void 0, (code) => {
+		resolvedExitCode.current = code;
+	}, outputMode.detectMode, runEvents.createRunEventStream);
+}).pipe(Effect.provide(Layer.merge(OutputModeProbeLive, RunEventStreamLive).pipe(Layer.provide(NodeStdio.layer))));
+NodeRuntime.runMain(program, {
+	disableErrorReporting: true,
+	teardown: (_exit, onExit) => {
+		onExit(resolvedExitCode.current);
+	}
+});
+//#endregion
+export {};