@systemfsoftware/stryker-js-cli 6.0.0 → 7.0.1

package/dist/main.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as nodePlatformLayer } from "./node-D-ynY_kk.mjs";
+import { n as nodePlatformLayer } from "./node-B7U4hEuW.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";
@@ -8,22 +8,20 @@ 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 Option from "effect/Option";
 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 { Heartbeat, HelpRendered, RunEvents, RunFailed, RunStarted, VerdictReached } from "@systemfsoftware/stryker-js/Run";
+import { RENDERED_OPTION_DEFAULTS, StrykerOptionsSchema } from "@systemfsoftware/stryker-js/Schema";
 import * as Cause from "effect/Cause";
 import * as Console from "effect/Console";
 import * as Fiber from "effect/Fiber";
-import * as FileSystem from "effect/FileSystem";
 import * as Match from "effect/Match";
-import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Queue from "effect/Queue";
 import * as Ref from "effect/Ref";
 import * as Result from "effect/Result";
-import * as S from "effect/Schema";
 import * as Terminal from "effect/Terminal";
 import * as Argument from "effect/unstable/cli/Argument";
 import * as CliConfig from "effect/unstable/cli/CliConfig";
@@ -32,10 +30,17 @@ 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 * as Arr from "effect/Array";
+import * as S from "effect/Schema";
 import { ExitClass, highestExitClass } from "@systemfsoftware/stryker-js/ExitClass";
 import * as Clock from "effect/Clock";
 import * as Formatter from "effect/Formatter";
 import * as Predicate from "effect/Predicate";
+import { LocationSchema, MutantStatusSchema, MutationTestResultSchema } from "@systemfsoftware/stryker-js/Report";
+import { makeHtmlReporter } from "@systemfsoftware/stryker-js-html-reporter";
+import { calculateMetrics } from "@systemfsoftware/stryker-js/Metrics";
+import { MutationTestReportReady } from "@systemfsoftware/stryker-js/Reporter";
+import * as FileSystem from "effect/FileSystem";
 import * as Context from "effect/Context";
 import * as Stdio from "effect/Stdio";
 import * as Stream from "effect/Stream";
@@ -46,10 +51,6 @@ import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
 var engines = { "node": ">=20.0.0" };
 //#endregion
 //#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.
-*/
 const MutantShape = S.Struct({
 	id: S.String,
 	fileName: S.String,
@@ -89,118 +90,38 @@ const PriorReportDocument = S.Struct({
 		}))
 	}))
 });
-/**
-* 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).
-*/
-/**
-* The decision's helpers reach three language built-ins the purity gate cannot
-* resolve as globals, so each is bound at module scope.
-*
-* These live here, beside the decision, because `make-body-purity` follows the
-* decision's reachable set: a helper `admissionVerdict` calls is checked as part
-* of the body even though it is declared outside it. That is why the properties
-* covering them are in this file's in-source block rather than beside a pure helper -
-* testing a copy the decision does not run is worse than not testing it, because
-* the suite goes green either way.
-*/
 const isArray = Array.isArray;
-const { fromEntries: objectFromEntries$1, keys: objectKeys } = Object;
+const { entries: objectEntries$1, fromEntries: objectFromEntries$1, keys: objectKeys } = Object;
 const stringify = JSON.stringify;
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !isArray(value);
-}
 const SURVIVORS_RUN_FIRST_REMEDIATION = "run a full `stryker run` first, then re-run with --survivors";
 const SURVIVORS_BOOKKEEPING_KEYS = ["survivorsPriorReport"];
-/**
-* The resolved options without the survivors-run bookkeeping keys, so both
-* sides of the admission comparison 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;
+	return objectFromEntries$1(objectEntries$1(config).filter(([key]) => !SURVIVORS_BOOKKEEPING_KEYS.includes(key)));
 }
-/**
-* A report written by a survivors run embeds the bookkeeping key in its
-* `config`. 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;
+	return Option.exists(Option.liftPredicate(priorReport.config, Match.record), (config) => SURVIVORS_BOOKKEEPING_KEYS.some((bookkeeping) => bookkeeping in config));
 }
-/**
-* Serializes the comparison input with keys sorted at every level, so the result
-* is a function of the data and not of key insertion order.
-*/
 function serializeSurvivorsHashInput(input) {
 	return stringify(sortKeys(input));
 }
 function sortKeys(value) {
-	if (isArray(value)) return value.map(sortKeys);
-	if (isRecord(value)) return objectFromEntries$1(objectKeys(value).sort().map((key) => [key, sortKeys(value[key])]));
-	return value;
+	return Match.value(value).pipe(Match.when(isArray, (many) => many.map((member) => sortKeys(member))), Match.when(Match.record, (named) => objectFromEntries$1(objectKeys(named).sort().map((key) => [key, sortKeys(named[key])]))), Match.orElse((leaf) => leaf));
 }
-/**
-* The prior report's facts the decision reads: its embedded configuration, which carries
-* both the compared options and the survivors-run provenance marker, and the engine
-* version it recorded. The report's files are not here — the survivors and the per-file
-* source hashes derived from them need capabilities the command cannot hold, so they
-* arrive already computed.
-*/
 var PriorReportFacts = class extends S.Class("PriorReportFacts")({
 	config: S.Record(S.String, S.Unknown),
 	frameworkVersion: S.UndefinedOr(S.String)
 }) {};
-/**
-* The command of the admission workflow: a schema class, because `Workflow.make`
-* constrains its first argument on the class value and a declared interface produces no
-* value to pass. Every field is pure data — the two capabilities the previous shape
-* carried, a digest function and a path resolver, can never be schema fields, so their
-* results arrive precomputed from the decode phase instead.
-*/
 var AdmitSurvivorsRunCommand = class extends S.Class("AdmitSurvivorsRunCommand")({
-	/**
-	* The prior run's report facts, `undefined` when no report exists — the run cannot be
-	* admitted without one ('no-report'). Explicitly nullable rather than key-optional: a
-	* missing report is a state the edge determined and states, not a key it forgot.
-	*/
 	priorReport: S.UndefinedOr(PriorReportFacts),
-	/** The current run's resolved options (defaults + config file + CLI). */
 	currentConfig: S.Record(S.String, S.Unknown),
-	/** The current CLI/framework version (`strykerVersion`). */
 	frameworkVersion: S.String,
-	/**
-	* Per-file content hashes of the current source, keyed by the prior report's relative
-	* file keys. The prior side is hashed from the sources the report embeds, so an editor
-	* save that shifts line ranges — which would silently re-test a different mutant than
-	* the one that survived — is caught here.
-	*/
 	sourceContentHashes: S.Record(S.String, S.String),
-	/** The same hashes for the sources the prior report embeds, computed at the edge. */
 	priorSourceHashes: S.Record(S.String, S.String),
-	/** The prior report's survivors, already converted to the internal mutant shape. */
 	priorSurvivors: S.Array(MutantShape)
 }) {};
 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).";
-/**
-* Whether the admission inputs agree: the prior report's embedded resolved options,
-* framework version and source content against the current run's.
-*
-* The comparison is on the canonical serializations rather than digests of them. Equal
-* serializations are equal runs, so the digest was a lossy restatement of the check that
-* also demanded a capability no command can carry.
-*/
 function hashesMatch(priorReport, input) {
 	return serializeSurvivorsHashInput({
 		resolvedOptions: stripSurvivorsKeys(priorReport.config),
@@ -232,18 +153,46 @@ function reject(reason, detail) {
 		remediation: `${detail} ${SURVIVORS_RUN_FIRST_REMEDIATION}`
 	}));
 }
+/**
+* The closed set of admissions a command can name, before any of them is turned
+* into a decision. Deriving the variant first keeps the decision itself a total
+* dispatch over a type rather than a fallback over predicates.
+*/
+const PriorReportAbsentOutcome = S.TaggedStruct("PriorReportAbsent", {});
+const PriorReportIsSurvivorsRunOutcome = S.TaggedStruct("PriorReportIsSurvivorsRun", {});
+const NoSurvivorsFoundOutcome = S.TaggedStruct("NoSurvivorsFound", {});
+const PriorReportDriftedOutcome = S.TaggedStruct("PriorReportDrifted", {});
+const SurvivorsMatchOutcome = S.TaggedStruct("SurvivorsMatch", { survivors: S.Array(MutantShape) });
+S.Union([
+	PriorReportAbsentOutcome,
+	PriorReportIsSurvivorsRunOutcome,
+	NoSurvivorsFoundOutcome,
+	PriorReportDriftedOutcome,
+	SurvivorsMatchOutcome
+]);
+const ADMISSION_RULES = [
+	{
+		holds: (input) => input.priorReport === void 0,
+		outcome: PriorReportAbsentOutcome.make({})
+	},
+	{
+		holds: (input) => Option.exists(Option.fromUndefinedOr(input.priorReport), wasProducedBySurvivorsRun),
+		outcome: PriorReportIsSurvivorsRunOutcome.make({})
+	},
+	{
+		holds: (input) => input.priorSurvivors.length === 0,
+		outcome: NoSurvivorsFoundOutcome.make({})
+	},
+	{
+		holds: (input) => Option.exists(Option.fromUndefinedOr(input.priorReport), (facts) => !hashesMatch(facts, input)),
+		outcome: PriorReportDriftedOutcome.make({})
+	}
+];
+const admissionOutcomeOf = (input) => Option.getOrElse(Option.map(Arr.findFirst(ADMISSION_RULES, (rule) => rule.holds(input)), (rule) => rule.outcome), () => SurvivorsMatchOutcome.make({ survivors: input.priorSurvivors }));
 function decideAdmission(input) {
-	const priorReport = input.priorReport;
-	if (priorReport === void 0) return reject("no-report", NO_REPORT_DETAIL);
-	if (wasProducedBySurvivorsRun(priorReport)) return reject("mismatch", SURVIVORS_RUN_SOURCE_DETAIL);
-	if (input.priorSurvivors.length === 0) return Result.succeed(NoSurvivors.make());
-	if (!hashesMatch(priorReport, input)) return reject("mismatch", MISMATCH_DETAIL);
-	return Result.succeed(Admitted.make({ survivors: input.priorSurvivors }));
-}
-function admissionDecision(command) {
-	return decideAdmission(command);
+	return Match.value(admissionOutcomeOf(input)).pipe(Match.tag("PriorReportAbsent", () => reject("no-report", NO_REPORT_DETAIL)), Match.tag("PriorReportIsSurvivorsRun", () => reject("mismatch", SURVIVORS_RUN_SOURCE_DETAIL)), Match.tag("NoSurvivorsFound", () => Result.succeed(NoSurvivors.make())), Match.tag("PriorReportDrifted", () => reject("mismatch", MISMATCH_DETAIL)), Match.tag("SurvivorsMatch", (matched) => Result.succeed(Admitted.make({ survivors: matched.survivors }))), Match.exhaustive);
 }
-const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, admissionDecision);
+const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, decideAdmission);
 //#endregion
 //#region src/classify-run-outcome.workflow.ts
 var RunOutcomeCommand = class extends S.TaggedClass()("RunOutcomeCommand", {
@@ -288,42 +237,42 @@ var RunFailed$1 = class extends S.TaggedClass()("RunFailed", {
 }) {
 	[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,
+const isSignaled = (command) => command.signal !== void 0;
+const isSucceeded = (command) => command.succeeded;
+const isHelpRun = (command) => command.helpErrorCount !== void 0;
+const isSurvivorsRun = (command) => command.survivorsReason !== void 0;
+const isHighestClassed = (command) => command.highestExitClass !== void 0;
+const signaledOutcome = (command) => RunInterrupted.make({ code: 128 + command.signal });
+const succeededOutcome = (command) => Option.match(Option.fromUndefinedOr(command.successExitClass), {
+	onNone: () => RunOk.make({ help: false }),
+	onSome: (exitClass) => RunFailed$1.make({
+		code: classCode(exitClass),
 		diagnostic: command.diagnostic
-	});
+	})
+});
+const helpOutcome = (command) => Match.value(command.helpErrorCount > 0).pipe(Match.when(true, () => RunParseFailed.make({ unrecognized: command.unrecognized })), Match.orElse(() => RunOk.make({ help: true })));
+const parseFailedOutcome = (command) => RunParseFailed.make({ unrecognized: command.unrecognized });
+const survivorsRejectedOutcome = (command) => RunSurvivorsRejected.make({
+	reason: command.survivorsReason,
+	diagnostic: command.survivorsDiagnostic
+});
+const configFailedOutcome = (command) => RunConfigFailed.make({ detail: command.configDetail });
+const classedOutcome = (command) => Match.value(command.highestExitClass).pipe(Match.when("ConfigError", () => RunConfigFailed.make({ detail: command.configDetail })), Match.orElse((exitClass) => RunFailed$1.make({
+	code: classCode(exitClass),
+	diagnostic: command.diagnostic
+})));
+const genericFailureOutcome = (command) => RunFailed$1.make({
+	code: 1,
+	diagnostic: command.diagnostic
+});
+function classify(command) {
+	return Match.value(command).pipe(Match.when(isSignaled, signaledOutcome), Match.when(isSucceeded, succeededOutcome), Match.when((interrupted) => interrupted.interrupted, () => RunInterrupted.make({ code: 1 })), Match.when(isHelpRun, helpOutcome), Match.when((cliError) => cliError.cliError, parseFailedOutcome), Match.when(isSurvivorsRun, survivorsRejectedOutcome), Match.when((schemaError) => schemaError.schemaError, configFailedOutcome), Match.when(isHighestClassed, classedOutcome), Match.orElse(genericFailureOutcome));
 }
 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
 const CONFIG_CODE = 2;
+const UNKNOWN_FAILURE = "Unknown failure";
 function runOutcomeCode(result) {
 	const outcome = Result.match(result, {
 		onSuccess: (success) => success,
@@ -334,170 +283,138 @@ function runOutcomeCode(result) {
 function isExitClass(value) {
 	return S.is(ExitClass)(value);
 }
+const asExitClass = Option.liftPredicate(isExitClass);
 function exitClassOf(value) {
-	if (typeof value !== "object" || value === null) return;
-	if (!("exitClass" in value)) return;
-	const raw = Reflect.get(value, "exitClass");
-	if (!isExitClass(raw)) return;
-	return raw;
-}
-function collectExitClassesFromValue(value, out, seen, depth) {
-	if (depth > 10 || value === null || value === void 0) return;
-	if (typeof value !== "object") return;
-	if (seen.has(value)) return;
-	seen.add(value);
-	const ec = exitClassOf(value);
-	if (ec !== void 0) out.push(ec);
-	if ("cause" in value) {
-		const causeVal = Reflect.get(value, "cause");
-		if (Array.isArray(causeVal)) for (const entry of causeVal) collectExitClassesFromValue(entry, out, seen, depth + 1);
-		else collectExitClassesFromValue(causeVal, out, seen, depth + 1);
+	if (!Predicate.isObjectOrArray(value)) return;
+	return Option.getOrUndefined(asExitClass(Reflect.get(value, "exitClass")));
+}
+const MAX_TRAVERSAL_DEPTH = 10;
+function isUnseenObject(value, seen) {
+	return Predicate.isObjectOrArray(value) && !seen.has(value);
+}
+function isReachableValue(value, depth, seen) {
+	return depth <= MAX_TRAVERSAL_DEPTH && isUnseenObject(value, seen);
+}
+function isChildList(value) {
+	return Array.isArray(value);
+}
+function causeChildrenOf(value) {
+	const cause = Reflect.get(value, "cause");
+	return Match.value(cause).pipe(Match.when(isChildList, (children) => children), Match.orElse(() => [cause]));
+}
+function visitReachableValue(value, depth, seen, visit) {
+	if (isReachableValue(value, depth, seen)) {
+		seen.add(value);
+		visit(value);
+		causeChildrenOf(value).forEach((child) => visitReachableValue(child, depth + 1, seen, visit));
 	}
 }
+function findReachableValue(value, depth, seen, read) {
+	if (!isReachableValue(value, depth, seen)) return Option.none();
+	seen.add(value);
+	return Option.orElse(read(value), () => Arr.findFirst(causeChildrenOf(value), (child) => findReachableValue(child, depth + 1, seen, read)));
+}
+function causePayloadOf(reason) {
+	return Match.value(reason).pipe(Match.when(Cause.isFailReason, (failed) => failed.error), Match.when(Cause.isDieReason, (died) => died.defect), Match.orElse(() => void 0));
+}
+const failedExit = Option.liftPredicate(Exit.isFailure);
+function failurePayloads(exit) {
+	return Option.getOrElse(Option.map(failedExit(exit), (failure) => failure.cause.reasons.map(causePayloadOf)), () => []);
+}
+function appendExitClass(value, out) {
+	const declared = exitClassOf(value);
+	if (declared !== void 0) out.push(declared);
+}
 function collectExitClasses(exit) {
 	const out = [];
 	const seen = /* @__PURE__ */ new WeakSet();
-	if (Exit.isFailure(exit)) for (const reason of exit.cause.reasons) {
-		let candidate;
-		if (Cause.isFailReason(reason)) candidate = reason.error;
-		else if (Cause.isDieReason(reason)) candidate = reason.defect;
-		else candidate = void 0;
-		if (candidate !== void 0) collectExitClassesFromValue(candidate, out, seen, 0);
-	}
+	failurePayloads(exit).forEach((payload) => visitReachableValue(payload, 0, seen, (value) => appendExitClass(value, out)));
 	return out;
 }
+function isNonEmptyString$1(value) {
+	return typeof value === "string" && value.length > 0;
+}
+const nonEmptyText = Option.liftPredicate(isNonEmptyString$1);
 function reasonOf(value) {
-	if (!("reason" in value)) return;
-	const reason = Reflect.get(value, "reason");
-	if (typeof reason !== "string" || reason.length === 0) return;
-	const detail = causeTextOf(value);
-	if (detail === void 0) return reason;
-	return `${reason}: ${detail}`;
+	const declared = Reflect.get(value, "reason");
+	return Option.getOrUndefined(Option.map(nonEmptyText(declared), (reason) => Option.match(Option.fromNullishOr(causeTextOf(value)), {
+		onNone: () => reason,
+		onSome: (detail) => `${reason}: ${detail}`
+	})));
 }
-function causeTextOf(value, depth = 0) {
-	if (depth > 4 || !("cause" in value)) return;
+function causeTextOf(value) {
 	const cause = Reflect.get(value, "cause");
-	return causeText(cause, depth + 1);
+	return causeText(cause, 1);
 }
-function configDetailOf(value) {
-	if (!("reason" in value) && !("message" in value)) return;
+function firstConfiguredText(value) {
 	const reason = Reflect.get(value, "reason");
-	if (typeof reason === "string" && reason.length > 0) return reason;
 	const message = Reflect.get(value, "message");
-	if (typeof message === "string" && message.length > 0) return message;
-}
-function shouldVisitConfigValue(value, depth, seen) {
-	if (depth > 10) return false;
-	if (value === null || value === void 0) return false;
-	if (typeof value !== "object") return false;
-	if (seen.has(value)) return false;
-	return true;
-}
-function pushConfigCauses(value, depth, stack) {
-	if (!("cause" in value)) return;
-	const causeVal = Reflect.get(value, "cause");
-	if (Array.isArray(causeVal)) for (let index = causeVal.length - 1; index >= 0; index--) stack.push({
-		value: causeVal[index],
-		depth: depth + 1
-	});
-	else stack.push({
-		value: causeVal,
-		depth: depth + 1
-	});
+	return Option.orElse(nonEmptyText(reason), () => nonEmptyText(message));
+}
+function configDetailAt(value) {
+	if (exitClassOf(value) !== "ConfigError") return Option.none();
+	return firstConfiguredText(value);
 }
 function firstConfigErrorDetail(exit) {
-	if (!Exit.isFailure(exit)) return;
 	const seen = /* @__PURE__ */ new WeakSet();
-	const stack = [];
-	for (const reason of exit.cause.reasons) {
-		let candidate;
-		if (Cause.isFailReason(reason)) candidate = reason.error;
-		else if (Cause.isDieReason(reason)) candidate = reason.defect;
-		else candidate = void 0;
-		if (candidate !== void 0) stack.push({
-			value: candidate,
-			depth: 0
-		});
-	}
-	while (stack.length > 0) {
-		const entry = stack.pop();
-		if (entry === void 0) continue;
-		const { value, depth } = entry;
-		if (!shouldVisitConfigValue(value, depth, seen)) continue;
-		seen.add(value);
-		if (exitClassOf(value) === "ConfigError") {
-			const detail = configDetailOf(value);
-			if (detail !== void 0) return detail;
-		}
-		pushConfigCauses(value, depth, stack);
-	}
+	const roots = [...failurePayloads(exit)].reverse();
+	return Option.getOrUndefined(Arr.findFirst(roots, (root) => findReachableValue(root, 0, seen, configDetailAt)));
+}
+const PRIMITIVE_REFINEMENTS = [
+	Predicate.isString,
+	Predicate.isNumber,
+	Predicate.isBoolean,
+	Predicate.isBigInt,
+	Predicate.isSymbol
+];
+const isPrimitiveText = Predicate.some(PRIMITIVE_REFINEMENTS);
+function isMessageError(value) {
+	return value instanceof Error && value.message.length > 0;
+}
+function declaresReasonText(value) {
+	return Predicate.isObjectOrArray(value) && Option.isSome(nonEmptyText(Reflect.get(value, "reason")));
+}
+function failureValueDescription(value) {
+	return Match.value(value).pipe(Match.when(S.is(SurvivorsRejection), (rejected) => Option.some(rejected.remediation)), Match.when(declaresReasonText, (carrier) => Option.fromNullishOr(reasonOf(carrier))), Match.when(isMessageError, (error) => Option.some(error.message)), Match.when(isPrimitiveText, (primitive) => Option.some(String(primitive))), Match.orElse(() => Option.none()));
+}
+function failureDescriptionOf(exit) {
+	return failureValueDescription(failureValue(exit)).pipe(Option.orElse(() => Option.fromNullishOr(firstConfigErrorDetail(exit))), Option.orElse(() => Option.flatMap(failedExit(exit), (failure) => nonEmptyText(Cause.pretty(failure.cause)))));
 }
 function describeFailure(exit) {
-	if (!Exit.isFailure(exit)) return "Unknown failure";
-	const value = failureValue(exit);
-	if (value !== void 0) {
-		if (S.is(SurvivorsRejection)(value)) return value.remediation;
-		if (typeof value === "object" && value !== null) {
-			const reason = reasonOf(value);
-			if (reason !== void 0) return reason;
-		}
-		if (value instanceof Error && value.message.length > 0) return value.message;
-		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") return String(value);
-	}
-	if (collectExitClasses(exit).includes("ConfigError")) {
-		const detail = firstConfigErrorDetail(exit);
-		if (detail !== void 0) return detail;
-	}
-	const rendered = Cause.pretty(exit.cause);
-	if (rendered.length > 0) return rendered;
-	return "Unknown failure";
+	return Option.getOrElse(failureDescriptionOf(exit), () => UNKNOWN_FAILURE);
 }
 function unrecognizedArgumentOf(exit, argv) {
-	if (!Exit.isFailure(exit)) return;
-	const value = failureValue(exit);
-	if (value === void 0 || !CliError.isCliError(value)) return;
-	const errors = (() => {
-		if (S.is(CliError.ShowHelp)(value)) return value.errors;
-		return [value];
-	})();
-	for (const error of errors) {
-		if (S.is(CliError.UnrecognizedOption)(error)) {
-			const at = argv.indexOf(error.option);
-			const next = (() => {
-				if (at >= 0) return argv[at + 1];
-			})();
-			if (next !== void 0 && !next.startsWith("-")) return next;
-			return error.option;
-		}
-		if (S.is(CliError.UnexpectedArgument)(error)) return error.arguments[0];
-		if (S.is(CliError.UnknownSubcommand)(error)) return error.subcommand;
-	}
+	return Option.getOrUndefined(cliErrorList(exit).pipe(Option.flatMap((errors) => Arr.findFirst(errors, (error) => argumentHintOf(error, argv)))));
+}
+function cliErrorList(exit) {
+	return Match.value(failureValue(exit)).pipe(Match.when(S.is(CliError.ShowHelp), (help) => Option.some(help.errors)), Match.when(CliError.isCliError, (cliError) => Option.some([cliError])), Match.orElse(() => Option.none()));
+}
+function argumentHintOf(error, argv) {
+	return Match.value(error).pipe(Match.tag("UnrecognizedOption", (unrecognized) => Option.some(unrecognizedArgument(argv, unrecognized.option))), Match.tag("UnexpectedArgument", (unexpected) => Option.fromNullishOr(unexpected.arguments[0])), Match.tag("UnknownSubcommand", (unknown) => Option.some(unknown.subcommand)), Match.orElse(() => Option.none()));
+}
+function unrecognizedArgument(argv, option) {
+	return followingArgument(argv, option).pipe(Option.filter((argument) => !argument.startsWith("-")), Option.getOrElse(() => option));
+}
+function followingArgument(argv, option) {
+	return Match.value(argv.indexOf(option)).pipe(Match.when((at) => at >= 0, (at) => Option.fromNullishOr(argv[at + 1])), Match.orElse(() => Option.none()));
 }
 function failureValue(exit) {
-	if (!Exit.isFailure(exit)) return;
-	const failure = Cause.findErrorOption(exit.cause);
-	if (Option.isSome(failure)) return failure.value;
+	return Option.getOrUndefined(Option.flatMap(failedExit(exit), (failure) => Cause.findErrorOption(failure.cause)));
 }
 const SIGNAL_REMEDIATION = "the run was interrupted by a signal; re-run it to continue";
 const PARSE_REMEDIATION = "re-run with --help to see the full usage";
 const DEFAULT_REMEDIATION = "see --reportFile or the verdict envelope on stdout";
+function verdictExitClass(value) {
+	return Match.value(value).pipe(Match.when(Predicate.hasProperty("verdict"), (carrier) => Option.getOrUndefined(asExitClass(carrier.verdict))), Match.orElse(() => void 0));
+}
 function successExitClassOf(exit) {
-	if (!Exit.isSuccess(exit)) return;
-	const value = exit.value;
-	if (!Predicate.hasProperty(value, "verdict")) return;
-	const candidate = value.verdict;
-	if (!isExitClass(candidate)) return;
-	return candidate;
+	return Match.value(exit).pipe(Match.when(Exit.isSuccess, (success) => verdictExitClass(success.value)), Match.orElse(() => void 0));
 }
 function helpErrorCountOf(value) {
-	if (value === void 0) return;
-	if (!S.is(CliError.ShowHelp)(value)) return;
-	return value.errors.length;
+	return Match.value(value).pipe(Match.when(S.is(CliError.ShowHelp), (help) => help.errors.length), Match.orElse(() => void 0));
 }
 function survivorsRejectionOf(value) {
-	if (value === void 0) return;
-	if (!S.is(SurvivorsRejection)(value)) return;
-	return value;
+	return Match.value(value).pipe(Match.when(S.is(SurvivorsRejection), (survivors) => survivors), Match.orElse(() => void 0));
 }
 function present(value) {
 	if (value === null) return;
@@ -512,12 +429,20 @@ function survivorsDiagnosticOf(survivors) {
 	return survivors.remediation;
 }
 function omitUnknownFailure(diagnostic) {
-	if (diagnostic === "Unknown failure") return;
+	if (diagnostic === UNKNOWN_FAILURE) return;
 	return diagnostic;
 }
 function capturedOrUnknown(captured) {
-	if (captured.length > 0) return captured;
-	return "Unknown failure";
+	return Option.getOrElse(nonEmptyText(captured), () => UNKNOWN_FAILURE);
+}
+function hasOnlyInterrupts(exit) {
+	return Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause);
+}
+function carriesCliError(value) {
+	return value !== void 0 && CliError.isCliError(value);
+}
+function carriesSchemaError(value) {
+	return value !== void 0 && S.isSchemaError(value);
 }
 function gatherRunOutcome(exit, signal, argv) {
 	const value = failureValue(exit);
@@ -525,35 +450,24 @@ function gatherRunOutcome(exit, signal, argv) {
 	return RunOutcomeCommand.make({
 		succeeded: Exit.isSuccess(exit),
 		signal: present(signal),
-		interrupted: Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause),
+		interrupted: hasOnlyInterrupts(exit),
 		helpErrorCount: helpErrorCountOf(value),
-		cliError: value !== void 0 && CliError.isCliError(value),
+		cliError: carriesCliError(value),
 		unrecognized: unrecognizedArgumentOf(exit, argv),
 		survivorsReason: survivorsReasonOf(survivors),
 		survivorsDiagnostic: survivorsDiagnosticOf(survivors),
-		schemaError: value !== void 0 && S.isSchemaError(value),
+		schemaError: carriesSchemaError(value),
 		successExitClass: successExitClassOf(exit),
 		highestExitClass: present(highestExitClass(collectExitClasses(exit))),
 		configDetail: firstConfigErrorDetail(exit),
 		diagnostic: omitUnknownFailure(describeFailure(exit))
 	});
 }
+function capturedThenRecorded(captured, recorded) {
+	return Option.getOrElse(nonEmptyText(captured), () => Option.getOrElse(Option.fromNullishOr(recorded), () => UNKNOWN_FAILURE));
+}
 function errorText(error, captured) {
-	return Match.value(error).pipe(Match.tag("RunParseFailed", (failed) => {
-		if (failed.unrecognized !== void 0) return `Received unknown argument: '${failed.unrecognized}'`;
-		return capturedOrUnknown(captured);
-	}), Match.tag("RunSurvivorsRejected", (failed) => {
-		if (failed.diagnostic !== void 0) return failed.diagnostic;
-		return "Unknown failure";
-	}), Match.tag("RunInterrupted", () => capturedOrUnknown(captured)), Match.tag("RunConfigFailed", (failed) => {
-		if (captured.length > 0) return captured;
-		if (failed.detail !== void 0) return failed.detail;
-		return "Unknown failure";
-	}), Match.tag("RunFailed", (failed) => {
-		if (captured.length > 0) return captured;
-		if (failed.diagnostic !== void 0) return failed.diagnostic;
-		return "Unknown failure";
-	}), Match.exhaustive);
+	return Match.value(error).pipe(Match.tag("RunParseFailed", (failed) => Option.getOrElse(Option.map(Option.fromNullishOr(failed.unrecognized), (value) => `Received unknown argument: '${value}'`), () => capturedOrUnknown(captured))), Match.tag("RunSurvivorsRejected", (failed) => Option.getOrElse(Option.fromNullishOr(failed.diagnostic), () => UNKNOWN_FAILURE)), Match.tag("RunInterrupted", () => capturedOrUnknown(captured)), Match.tag("RunConfigFailed", (failed) => capturedThenRecorded(captured, failed.detail)), Match.tag("RunFailed", (failed) => capturedThenRecorded(captured, failed.diagnostic)), Match.exhaustive);
 }
 function remediationText(error) {
 	return Match.value(error).pipe(Match.tag("RunInterrupted", (failed) => {
@@ -585,35 +499,52 @@ function inspectValue(value) {
 	if (typeof value === "string") return value;
 	return Formatter.format(value);
 }
-function formatArgs(args) {
-	if (args.length === 0) return "";
-	const first = args[0];
-	if (typeof first === "string") {
-		let index = 1;
-		let result = first.replace(/%[sdijfopO%]/g, (match) => {
-			if (match === "%%") return "%";
-			if (index >= args.length) return match;
-			const arg = args[index++];
-			switch (match) {
-				case "%s": return String(arg);
-				case "%d":
-				case "%i":
-				case "%f": return Number(arg).toString();
-				case "%j": try {
-					return String(JSON.stringify(arg));
-				} catch {
-					return "[Circular]";
-				}
-				case "%o":
-				case "%O":
-				case "%p": return inspectValue(arg);
-				default: return match;
-			}
-		});
-		for (; index < args.length; index++) result += ` ${inspectValue(args[index])}`;
-		return result;
+const PLACEHOLDER = /(%[sdijfopO%])/g;
+const PLACEHOLDER_PART = /^%[sdijfopO%]$/;
+function jsonArgumentText(argument) {
+	try {
+		return String(JSON.stringify(argument));
+	} catch {
+		return "[Circular]";
 	}
-	return args.map(inspectValue).join(" ");
+}
+function placeholderText(placeholder, argument) {
+	return Match.value(placeholder).pipe(Match.when(Match.is("%s"), () => String(argument)), Match.when(Match.is("%d", "%i", "%f"), () => Number(argument).toString()), Match.when(Match.is("%j"), () => jsonArgumentText(argument)), Match.when(Match.is("%o", "%O", "%p"), () => inspectValue(argument)), Match.orElse((unmatched) => unmatched));
+}
+function appendLiteral(progress, literal) {
+	return {
+		args: progress.args,
+		cursor: progress.cursor,
+		text: progress.text + literal
+	};
+}
+function substitutePlaceholder(progress, placeholder) {
+	return Match.value(progress.cursor).pipe(Match.when((cursor) => cursor < progress.args.length, (cursor) => ({
+		args: progress.args,
+		cursor: cursor + 1,
+		text: progress.text + placeholderText(placeholder, progress.args[cursor])
+	})), Match.orElse(() => appendLiteral(progress, placeholder)));
+}
+function consumePlaceholder(progress, placeholder) {
+	return Match.value(placeholder).pipe(Match.when(Match.is("%%"), () => appendLiteral(progress, "%")), Match.orElse(() => substitutePlaceholder(progress, placeholder)));
+}
+function formatStep(progress, part) {
+	return Match.value(part).pipe(Match.when((candidate) => PLACEHOLDER_PART.test(candidate), (placeholder) => consumePlaceholder(progress, placeholder)), Match.orElse((literal) => appendLiteral(progress, literal)));
+}
+function formatTemplate(template, args) {
+	const progress = template.split(PLACEHOLDER).reduce(formatStep, {
+		args,
+		cursor: 0,
+		text: ""
+	});
+	const trailing = progress.args.slice(progress.cursor).map((argument) => ` ${inspectValue(argument)}`);
+	return progress.text + trailing.join("");
+}
+function isTextTemplate(args) {
+	return typeof args[0] === "string";
+}
+function formatArgs(args) {
+	return Match.value(args).pipe(Match.when(isTextTemplate, (values) => formatTemplate(values[0], values.slice(1))), Match.orElse((values) => values.map(inspectValue).join(" ")));
 }
 function captureSync(args) {
 	capturedConsoleChunks.push(formatArgs(args));
@@ -621,21 +552,39 @@ function captureSync(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;
+const DEFAULT_CONSOLE_LABEL = "default";
+function consoleLabel(label) {
+	return Option.getOrElse(Option.fromNullishOr(label), () => DEFAULT_CONSOLE_LABEL);
+}
+function incrementCount(key) {
+	const next = Option.getOrElse(Option.fromNullishOr(countByLabel.get(key)), () => 0) + 1;
 	countByLabel.set(key, next);
+	return next;
+}
+function captureCount(label) {
+	const key = consoleLabel(label);
+	const next = incrementCount(key);
 	capturedConsoleChunks.push(`${key}: ${next}`);
 }
+function elapsedMs(started, nowNanos) {
+	return Number(nowNanos - started) / 1e6;
+}
 function captureTimeEnd(label, nowNanos) {
-	const key = label ?? "default";
+	const key = consoleLabel(label);
 	const started = timeByLabel.get(key);
 	if (started !== void 0) {
 		timeByLabel.delete(key);
-		const diffMs = Number(nowNanos - started) / 1e6;
-		capturedConsoleChunks.push(`${key}: ${diffMs}ms`);
+		capturedConsoleChunks.push(`${key}: ${elapsedMs(started, nowNanos)}ms`);
 	}
 }
+function captureTimeLog(label, args, clock) {
+	const key = consoleLabel(label);
+	const started = timeByLabel.get(key);
+	if (started === void 0) return;
+	const elapsed = elapsedMs(started, clock.monotonicTimeNanosUnsafe());
+	const elapsedText = Match.value(args).pipe(Match.when((values) => values.length === 0, () => `${key}: ${elapsed}ms`), Match.orElse((values) => `${key}: ${elapsed}ms ${formatArgs(values)}`));
+	capturedConsoleChunks.push(elapsedText);
+}
 function captureTrace(args) {
 	capturedConsoleChunks.push(`Trace: ${formatArgs(args)}\n${(/* @__PURE__ */ new Error()).stack ?? ""}`);
 }
@@ -643,7 +592,7 @@ const makeCapturingConsole = (clock) => ({
 	assert: (condition, ...args) => captureAssert(condition, args),
 	clear: () => {},
 	count: (label) => captureCount(label),
-	countReset: (label) => countByLabel.delete(label ?? "default"),
+	countReset: (label) => countByLabel.delete(consoleLabel(label)),
 	debug: (...args) => captureSync(args),
 	dir: (item, _options) => capturedConsoleChunks.push(Formatter.format(item)),
 	dirxml: (item) => capturedConsoleChunks.push(Formatter.format(item)),
@@ -654,19 +603,9 @@ const makeCapturingConsole = (clock) => ({
 	info: (...args) => captureSync(args),
 	log: (...args) => captureSync(args),
 	table: (tabularData) => capturedConsoleChunks.push(Formatter.format(tabularData)),
-	time: (label) => timeByLabel.set(label ?? "default", clock.monotonicTimeNanosUnsafe()),
+	time: (label) => timeByLabel.set(consoleLabel(label), clock.monotonicTimeNanosUnsafe()),
 	timeEnd: (label) => captureTimeEnd(label, clock.monotonicTimeNanosUnsafe()),
-	timeLog: (label, ...args) => {
-		const key = label ?? "default";
-		const started = timeByLabel.get(key);
-		if (started === void 0) return;
-		const diffMs = Number(clock.monotonicTimeNanosUnsafe() - started) / 1e6;
-		if (args.length === 0) {
-			capturedConsoleChunks.push(`${key}: ${diffMs}ms`);
-			return;
-		}
-		capturedConsoleChunks.push(`${key}: ${diffMs}ms ${formatArgs(args)}`);
-	},
+	timeLog: (label, ...args) => captureTimeLog(label, args, clock),
 	trace: (...args) => captureTrace(args),
 	warn: (...args) => captureSync(args)
 });
@@ -683,6 +622,506 @@ function resetCapturedConsole() {
 	timeByLabel.clear();
 }
 //#endregion
+//#region src/merge-reports.schema.ts
+var MergeReportsFailed = class extends S.TaggedError()("MergeReportsFailed", { reason: S.String }) {};
+const PartMetaSchema = S.Struct({
+	package: S.String,
+	outcome: S.String
+});
+const StreamMutantLineSchema = S.Struct({
+	kind: S.Literal("mutant"),
+	id: S.String,
+	status: MutantStatusSchema,
+	file: S.String,
+	location: LocationSchema,
+	mutator: S.String,
+	replacement: S.NullOr(S.String)
+});
+//#endregion
+//#region src/merge-report-parts.workflow.ts
+const MERGED_SCHEMA_VERSION = "1.7";
+const DEFAULT_THRESHOLDS = {
+	high: 80,
+	low: 60
+};
+const FAILING_OUTCOME = "failure";
+const PASSING_OUTCOME = "success";
+const PERFECT_MUTATION_SCORE = 100;
+const SURVIVOR_STATUSES = {
+	Survived: true,
+	NoCoverage: true
+};
+const SCORE_INCOMPLETE = "incomplete";
+const SCORE_ABSENT = "no report";
+const SCORE_UNDEFINED = "n/a";
+const SCORE_PERFECT = "100.00";
+const VERDICT_OK = "✅";
+const VERDICT_FAIL = "❌";
+const VERDICT_WARN = "⚠️";
+const ABSENT_CELLS = [
+	"—",
+	"—",
+	"—",
+	"—",
+	"—"
+];
+const ALL_PACKAGES_LABEL$1 = "**all**";
+const SEGMENT_SEPARATORS = /[/\\]/;
+const EMPTY_SEGMENTS = [];
+const EMPTY_PACKAGES = [];
+const EMPTY_TEST_FILES = {};
+const ReportPart = S.Struct({
+	label: S.String,
+	outcome: S.String,
+	incomplete: S.Boolean,
+	report: S.optional(MutationTestResultSchema)
+});
+const MergeVerdictRow = S.Struct({
+	label: S.String,
+	score: S.String,
+	cells: S.Array(S.String),
+	verdict: S.String
+});
+const MergeSurvivor = S.Struct({
+	file: S.String,
+	line: S.Finite,
+	column: S.Finite,
+	status: S.String,
+	mutatorName: S.String,
+	replacement: S.String
+});
+var MergeReportPartsCommand = class extends S.Class("MergeReportPartsCommand")({
+	parts: S.Array(ReportPart),
+	expectedPackages: S.optional(S.Array(S.String))
+}) {};
+const MergeReportPartsTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/MergeReportParts");
+var MergedReports = class extends S.TaggedClass()("MergedReports", {
+	report: MutationTestResultSchema,
+	rows: S.Array(MergeVerdictRow),
+	survivors: S.Array(MergeSurvivor)
+}) {
+	[MergeReportPartsTypeId] = MergeReportPartsTypeId;
+};
+var NoMergedReports = class extends S.TaggedClass()("NoMergedReports", { rows: S.Array(MergeVerdictRow) }) {
+	[MergeReportPartsTypeId] = MergeReportPartsTypeId;
+};
+var DuplicatePackageLabel = class extends S.TaggedError()("DuplicatePackageLabel", { label: S.String }) {};
+var MissingPackages = class extends S.TaggedError()("MissingPackages", { packages: S.Array(S.String) }) {};
+/** The value a present option carries, or the fallback a missing one takes. */
+const orDefault = (present, fallback) => Option.getOrElse(present, () => fallback);
+const thresholdsOf = (part) => orDefault(Option.map(Option.fromUndefinedOr(part), (present) => present.report.thresholds), DEFAULT_THRESHOLDS);
+const hasReport = (part) => part.report !== void 0;
+const scoreFor = (part) => Option.getOrUndefined(Option.map(Option.filter(Option.fromUndefinedOr(part), hasReport), (present) => scoreOf(present.report.files)));
+const outcomeOf = (reports) => Match.value(reports.some((part) => part.outcome === FAILING_OUTCOME)).pipe(Match.when(true, () => FAILING_OUTCOME), Match.when(false, () => PASSING_OUTCOME), Match.exhaustive);
+const normalizeName = (fileName) => fileName.split(SEGMENT_SEPARATORS).filter(Boolean).join("/");
+const commonBasePath = (fileNames) => {
+	const directories = fileNames.map((fileName) => fileName.split(SEGMENT_SEPARATORS).slice(0, -1));
+	return Arr.reduce(directories, orDefault(Arr.head(directories), EMPTY_SEGMENTS), (left, right) => Arr.takeWhile(left, (segment, index) => right[index] === segment)).join("/");
+};
+const normalizedNames = (input) => {
+	const base = commonBasePath(Object.keys(input));
+	return Object.fromEntries(Object.entries(input).map(([fileName, value]) => [normalizeName(fileName.slice(base.length)), value]));
+};
+const uniqueId = (label, id) => `${label}_${id}`;
+const uniqueIds = (label, ids) => Option.getOrUndefined(Option.map(Option.fromUndefinedOr(ids), (present) => present.map((id) => uniqueId(label, id))));
+const rewrittenMutant = (label, mutant) => ({
+	...mutant,
+	id: uniqueId(label, mutant.id),
+	killedBy: uniqueIds(label, mutant.killedBy),
+	coveredBy: uniqueIds(label, mutant.coveredBy)
+});
+const withProjectRoot = (report, projectRoot) => Option.match(Option.fromUndefinedOr(projectRoot), {
+	onNone: () => report,
+	onSome: (root) => ({
+		...report,
+		projectRoot: root
+	})
+});
+const mergedFiles = (parts) => Object.fromEntries(parts.flatMap((part) => Object.entries(normalizedNames(part.report.files)).map(([fileName, file]) => [`${part.label}/${fileName}`, {
+	...file,
+	mutants: file.mutants.map((mutant) => rewrittenMutant(part.label, mutant))
+}])));
+const mergedTestFiles = (parts) => Object.fromEntries(parts.flatMap((part) => Object.entries(normalizedNames(orDefault(Option.fromUndefinedOr(part.report.testFiles), EMPTY_TEST_FILES))).map(([fileName, testFile]) => [`${part.label}/${fileName}`, {
+	...testFile,
+	tests: testFile.tests.map((test) => ({
+		...test,
+		id: uniqueId(part.label, test.id)
+	}))
+}])));
+const withTestFiles = (report, testFiles) => Match.value(Object.keys(testFiles).length > 0).pipe(Match.when(true, () => ({
+	...report,
+	testFiles
+})), Match.when(false, () => report), Match.exhaustive);
+const mergeParts = (parts) => {
+	const merged = {
+		files: mergedFiles(parts),
+		schemaVersion: MERGED_SCHEMA_VERSION,
+		thresholds: thresholdsOf(parts[0]),
+		config: {}
+	};
+	const projectRoots = parts.flatMap((part) => Option.toArray(Option.fromUndefinedOr(part.report.projectRoot)));
+	return withProjectRoot(withTestFiles(merged, mergedTestFiles(parts)), commonProjectRoot(projectRoots));
+};
+const commonProjectRoot = (roots) => Option.getOrUndefined(Option.map(Option.liftPredicate(roots, Arr.isReadonlyArrayNonEmpty), commonBasePath));
+const mutationScoreOf = (totalDetected, totalValid) => Match.value(totalValid === 0).pipe(Match.when(true, () => NaN), Match.when(false, () => totalDetected / totalValid * 100), Match.exhaustive);
+const scoreOf = (files) => {
+	const mutants = Object.values(files).flatMap((file) => file.mutants);
+	const count = (status) => mutants.filter((mutant) => mutant.status === status).length;
+	const killed = count("Killed");
+	const timeout = count("Timeout");
+	const survived = count("Survived");
+	const noCoverage = count("NoCoverage");
+	const compileErrors = count("CompileError");
+	const totalDetected = timeout + killed;
+	const cells = [
+		String(killed),
+		String(survived),
+		String(noCoverage),
+		String(timeout),
+		String(compileErrors)
+	];
+	return {
+		mutationScore: mutationScoreOf(totalDetected, survived + noCoverage + totalDetected),
+		cells
+	};
+};
+const cellsFor = (score) => orDefault(Option.map(Option.fromUndefinedOr(score), (present) => present.cells), ABSENT_CELLS);
+const incompleteVerdict = (outcome) => Match.value(outcome === PASSING_OUTCOME).pipe(Match.when(true, () => VERDICT_WARN), Match.when(false, () => VERDICT_FAIL), Match.exhaustive);
+const passingVerdict = (score, outcome) => Match.value({
+	perfect: score.mutationScore === PERFECT_MUTATION_SCORE,
+	passing: outcome === PASSING_OUTCOME
+}).pipe(Match.when({
+	perfect: true,
+	passing: true
+}, () => VERDICT_OK), Match.orElse(() => VERDICT_FAIL));
+const renderedScore = (mutationScore) => Match.value(mutationScore).pipe(Match.when(PERFECT_MUTATION_SCORE, () => SCORE_PERFECT), Match.orElse(() => mutationScore.toFixed(2)));
+const scoredRow = (label, score, outcome) => Match.value(Number.isNaN(score.mutationScore)).pipe(Match.when(true, () => ({
+	label,
+	score: SCORE_UNDEFINED,
+	cells: score.cells,
+	verdict: VERDICT_WARN
+})), Match.when(false, () => ({
+	label,
+	score: renderedScore(score.mutationScore),
+	cells: score.cells,
+	verdict: passingVerdict(score, outcome)
+})), Match.exhaustive);
+const completeRow = (label, score, outcome) => Option.match(Option.fromUndefinedOr(score), {
+	onNone: () => ({
+		label,
+		score: SCORE_ABSENT,
+		cells: ABSENT_CELLS,
+		verdict: VERDICT_WARN
+	}),
+	onSome: (present) => scoredRow(label, present, outcome)
+});
+const verdictOf = (label, score, outcome, incomplete) => Match.value(incomplete).pipe(Match.when(true, () => ({
+	label,
+	score: SCORE_INCOMPLETE,
+	cells: cellsFor(score),
+	verdict: incompleteVerdict(outcome)
+})), Match.when(false, () => completeRow(label, score, outcome)), Match.exhaustive);
+/** The label a second part repeats, and `none` when it repeats none a report can name. */
+const repeatedLabel = (parts) => Option.filter(Option.map(Option.fromUndefinedOr(parts.find((part, index) => parts.slice(0, index).some((earlier) => earlier.label === part.label))), (duplicate) => duplicate.label), (label) => label !== "");
+const uniqueParts = (parts) => parts.filter((part, index) => parts.slice(0, index).every((earlier) => earlier.label !== part.label));
+const chooseReports = (parts) => parts.flatMap((part) => Option.toArray(Option.map(Option.fromUndefinedOr(part.report), (report) => ({
+	...part,
+	report
+}))));
+const byFileThenLine = (left, right) => orDefault(Option.liftPredicate(left.file.localeCompare(right.file), (ordered) => ordered !== 0), left.line - right.line);
+const survivorsOf = (report) => Object.entries(report.files).flatMap(([file, fileResult]) => fileResult.mutants.filter((mutant) => SURVIVOR_STATUSES[mutant.status] === true).map((mutant) => ({
+	file,
+	line: mutant.location.start.line,
+	column: mutant.location.start.column,
+	status: mutant.status,
+	mutatorName: mutant.mutatorName,
+	replacement: orDefault(Option.fromNullishOr(mutant.replacement), "")
+}))).sort(byFileThenLine);
+const rowOf = (label, part) => Option.match(Option.fromUndefinedOr(part), {
+	onNone: () => verdictOf(label, void 0, void 0, false),
+	onSome: (present) => verdictOf(label, scoreFor(present), present.outcome, present.incomplete)
+});
+const packageRows = (parts, expected) => {
+	const absent = expected.filter((name) => !parts.some((part) => part.label === name));
+	return [...parts.map((part) => part.label), ...absent].sort().map((label) => rowOf(label, parts.find((candidate) => candidate.label === label)));
+};
+const allPackagesRow = (reports, merged) => verdictOf(ALL_PACKAGES_LABEL$1, scoreOf(merged.files), outcomeOf(reports), reports.some((part) => part.incomplete));
+const mergedReports = (reports, rows) => {
+	const report = mergeParts(reports);
+	return MergedReports.make({
+		report,
+		rows: [allPackagesRow(reports, report), ...rows],
+		survivors: survivorsOf(report)
+	});
+};
+const mergedOutcome = (reports, rows) => Match.value(reports.length === 0).pipe(Match.when(true, () => Result.succeed(NoMergedReports.make({ rows }))), Match.when(false, () => Result.succeed(mergedReports(reports, rows))), Match.exhaustive);
+const decideMerge = (command) => {
+	const parts = uniqueParts(command.parts);
+	const expected = orDefault(Option.fromNullishOr(command.expectedPackages), EMPTY_PACKAGES);
+	const rows = packageRows(parts, expected);
+	return Match.value(parts.length === 0).pipe(Match.when(true, () => Result.fail(MissingPackages.make({ packages: [...expected] }))), Match.when(false, () => mergedOutcome(chooseReports(parts), rows)), Match.exhaustive);
+};
+const DuplicateLabelFound = S.TaggedStruct("DuplicateLabelFound", { label: S.String });
+const LabelsDistinct = S.TaggedStruct("LabelsDistinct", {});
+S.Union([DuplicateLabelFound, LabelsDistinct]);
+const labelCheckOf = (parts) => Option.match(repeatedLabel(parts), {
+	onNone: () => LabelsDistinct.make({}),
+	onSome: (label) => DuplicateLabelFound.make({ label })
+});
+const decide = (command) => Match.value(labelCheckOf(command.parts)).pipe(Match.tag("DuplicateLabelFound", (found) => Result.fail(DuplicatePackageLabel.make({ label: found.label }))), Match.tag("LabelsDistinct", () => decideMerge(command)), Match.exhaustive);
+const mergeReportParts = Workflow.make(MergeReportPartsCommand, decide);
+//#endregion
+//#region src/MergeReports.ts
+const PART_MARKER_FILE = "mutation-part.json";
+const PART_REPORT_FILE = "mutation-report.json";
+const PART_STREAM_FILE = "mutation-stream.jsonl";
+const MERGED_REPORT_FILE = "mutation-report.json";
+const MERGED_HTML_FILE = "mutation-report.html";
+const MERGED_SUMMARY_FILE = "summary.md";
+const STREAM_REPORT_THRESHOLDS = {
+	high: 100,
+	low: 80
+};
+const SURVIVOR_CAP = 100;
+const ALL_PACKAGES_LABEL = "**all**";
+const STEP_SUMMARY_VARIABLE = "GITHUB_STEP_SUMMARY";
+/** The value when the condition holds, the fallback otherwise. */
+const whenHolds = (condition, value, fallback) => Option.getOrElse(Option.filter(Option.some(value), () => condition), () => fallback);
+const failMerge = (reason) => Effect.gen(function* () {
+	yield* Console.error(`stryker merge-reports: ${reason}`);
+	return yield* Effect.fail(MergeReportsFailed.make({ reason }));
+});
+const readOptional = (file) => Effect.gen(function* () {
+	return yield* (yield* FileSystem.FileSystem).readFileString(file).pipe(Effect.orElseSucceed(() => void 0));
+});
+const streamMutant = (line) => {
+	const mutant = {
+		id: line.id,
+		mutatorName: line.mutator,
+		status: line.status,
+		location: line.location
+	};
+	if (line.replacement === null) return mutant;
+	return {
+		...mutant,
+		replacement: line.replacement
+	};
+};
+const decodeStreamLines = (text) => text.split("\n").map((raw) => raw.trim()).filter((line) => line.length > 0).flatMap((line) => Option.toArray(S.decodeUnknownOption(S.fromJsonString(StreamMutantLineSchema))(line)));
+const groupStreamMutant = (groups, value) => {
+	const mutants = Option.getOrElse(Option.fromNullishOr(groups[value.file]), () => []);
+	mutants.push(streamMutant(value));
+	groups[value.file] = mutants;
+	return groups;
+};
+const groupedMutants = (text) => decodeStreamLines(text).reduce(groupStreamMutant, {});
+const fileResults = (grouped) => Object.fromEntries(Object.entries(grouped).map(([file, mutants]) => [file, {
+	language: "javascript",
+	source: "",
+	mutants
+}]));
+const streamReport = (text) => Option.getOrUndefined(Option.map(Option.filter(Option.some(groupedMutants(text)), (grouped) => Object.keys(grouped).length > 0), (grouped) => ({
+	schemaVersion: "1.0",
+	thresholds: STREAM_REPORT_THRESHOLDS,
+	files: fileResults(grouped)
+})));
+const listDirectory = (dir) => Effect.gen(function* () {
+	return yield* (yield* FileSystem.FileSystem).readDirectory(dir).pipe(Effect.orElseSucceed(() => []));
+});
+const isDirectory = (full) => Effect.gen(function* () {
+	const info = yield* (yield* FileSystem.FileSystem).stat(full).pipe(Effect.orElseSucceed(() => void 0));
+	return Option.match(Option.fromUndefinedOr(info), {
+		onNone: () => false,
+		onSome: (entry) => entry.type === "Directory"
+	});
+});
+const childPartDirs = (dir, name) => Effect.gen(function* () {
+	const full = (yield* Path.Path).join(dir, name);
+	if (yield* isDirectory(full)) return yield* findPartDirs(full);
+	return whenHolds(name === PART_MARKER_FILE, [dir], []);
+});
+const findPartDirs = (dir) => Effect.gen(function* () {
+	const names = [...yield* listDirectory(dir)].sort();
+	return (yield* Effect.forEach(names, (name) => childPartDirs(dir, name))).flat();
+});
+const partBase = (meta) => ({
+	label: meta.package,
+	outcome: meta.outcome,
+	incomplete: false
+});
+const partFromReportText = (dir, base, text) => {
+	const report = S.decodeUnknownOption(S.fromJsonString(MutationTestResultSchema))(text);
+	return Option.match(report, {
+		onNone: () => ({
+			dir,
+			part: Option.some(base),
+			unreadable: true
+		}),
+		onSome: (value) => ({
+			dir,
+			part: Option.some({
+				...base,
+				report: value
+			}),
+			unreadable: false
+		})
+	});
+};
+const readPartStream = (dir, base) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const text = yield* readOptional(path.join(dir, PART_STREAM_FILE));
+	const report = Option.fromNullishOr(text).pipe(Option.flatMap((streamed) => Option.fromNullishOr(streamReport(streamed))));
+	return Option.match(report, {
+		onNone: () => ({
+			dir,
+			part: Option.some(base),
+			unreadable: false
+		}),
+		onSome: (value) => ({
+			dir,
+			part: Option.some({
+				...base,
+				incomplete: true,
+				report: value
+			}),
+			unreadable: false
+		})
+	});
+});
+const readPartReport = (dir, base) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const text = yield* readOptional(path.join(dir, PART_REPORT_FILE));
+	return yield* Option.match(Option.fromUndefinedOr(text), {
+		onNone: () => readPartStream(dir, base),
+		onSome: (present) => Effect.succeed(partFromReportText(dir, base, present))
+	});
+});
+const readPart = (dir) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const metaText = yield* readOptional(path.join(dir, PART_MARKER_FILE));
+	const meta = Option.fromNullishOr(metaText).pipe(Option.flatMap((text) => S.decodeUnknownOption(S.fromJsonString(PartMetaSchema))(text)));
+	return yield* Option.match(meta, {
+		onNone: () => Effect.succeed({
+			dir,
+			part: Option.none(),
+			unreadable: false
+		}),
+		onSome: (present) => readPartReport(dir, partBase(present))
+	});
+});
+const readParts = (partsDir) => Effect.gen(function* () {
+	const dirs = yield* findPartDirs(partsDir);
+	const reads = yield* Effect.forEach(dirs, readPart);
+	return {
+		parts: reads.flatMap((read) => Option.toArray(read.part)),
+		skipped: reads.filter((read) => Option.isNone(read.part)).map((read) => read.dir),
+		unreadable: reads.filter((read) => read.unreadable).map((read) => read.dir)
+	};
+});
+const decodePackageList = (raw) => Option.match(S.decodeUnknownOption(S.fromJsonString(S.Array(S.String)))(raw), {
+	onNone: () => failMerge(`--packages is not a JSON array: ${raw}`),
+	onSome: (packages) => Effect.succeed(packages)
+});
+const parsePackages = (raw) => Option.match(Option.filter(Option.fromNullishOr(raw), (text) => text.length > 0), {
+	onNone: () => Effect.succeed(void 0),
+	onSome: decodePackageList
+});
+const SUMMARY_TABLE_HEADER = ["| package | score | killed | survived | no cov | timeout | compile err | verdict |", "| --- | --: | --: | --: | --: | --: | --: | :-: |"];
+const verdictRow = (row) => `| ${row.label} | ${row.score} | ${row.cells.join(" | ")} | ${row.verdict} |`;
+const survivorLine = (survivor) => `- \`${survivor.file}:${survivor.line}:${survivor.column}\` ${survivor.status} \`${survivor.mutatorName}\` → \`${survivor.replacement}\``;
+const survivorSection = (survivors) => [
+	"",
+	"### Survivors",
+	"",
+	...survivors.slice(0, SURVIVOR_CAP).map(survivorLine),
+	...whenHolds(survivors.length > SURVIVOR_CAP, [`- … and ${survivors.length - SURVIVOR_CAP} more; see mutation-report.html in the run artifact.`], [])
+];
+const warningSection = (skipped) => [
+	"",
+	"### Warnings",
+	"",
+	...skipped.map((name) => `- \`${name}\`: no readable mutation-part.json`)
+];
+const mergedCountLine = (packageRows) => `Merged ${packageRows.filter((row) => row.score !== "no report").length} of ${packageRows.length} package report(s).`;
+const summaryMarkdown = (rows, survivors, skipped, unreadableCount) => {
+	const packageRows = rows.filter((row) => row.label !== ALL_PACKAGES_LABEL);
+	return `${[
+		"## Mutation",
+		"",
+		mergedCountLine(packageRows),
+		"",
+		...SUMMARY_TABLE_HEADER,
+		...rows.map(verdictRow),
+		...whenHolds(survivors.length > 0, survivorSection(survivors), []),
+		...whenHolds(skipped.length > 0, warningSection(skipped), []),
+		...whenHolds(unreadableCount > 0, ["", `Report exited non-zero: ${unreadableCount} unreadable part(s).`], [])
+	].join("\n")}\n`;
+};
+const writeFile = (file, content, append) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	if (append) {
+		yield* fs.writeFileString(file, content, { flag: "a" });
+		return;
+	}
+	yield* fs.writeFileString(file, content);
+}).pipe(Effect.catchCause(() => failMerge(`cannot write ${file}`)));
+async function* toStream(events) {
+	yield* events;
+}
+const writeHtmlReport = (fileName, report) => Effect.gen(function* () {
+	const decoded = S.decodeUnknownOption(StrykerOptionsSchema)({ htmlReporter: { fileName } });
+	if (Option.isNone(decoded)) return yield* failMerge(`cannot configure the html report at ${fileName}`);
+	const metrics = calculateMetrics(report.files);
+	yield* Effect.promise(() => makeHtmlReporter(decoded.value, {})(toStream([new MutationTestReportReady({
+		report,
+		metrics
+	})])));
+});
+const failureReason = (error, partsDir) => Match.value(error).pipe(Match.tag("DuplicatePackageLabel", (duplicate) => `duplicate package ${duplicate.label}`), Match.tag("MissingPackages", (missing) => {
+	if (missing.packages.length === 0) return `no mutation report parts under ${partsDir}`;
+	return `no mutation report parts under ${partsDir} for ${missing.packages.join(", ")}`;
+}), Match.exhaustive);
+const survivorList = (decision) => {
+	if (S.is(MergedReports)(decision)) return decision.survivors;
+	return [];
+};
+const mergedReport = (decision) => {
+	if (S.is(MergedReports)(decision)) return decision.report;
+};
+const ensurePartsDir = (fs, partsDir) => Effect.gen(function* () {
+	if (yield* fs.exists(partsDir).pipe(Effect.orElseSucceed(() => false))) return;
+	return yield* failMerge(`no such parts directory ${partsDir}`);
+});
+const decideReports = (parts, expectedPackages, partsDir) => Effect.gen(function* () {
+	const decision = mergeReportParts(MergeReportPartsCommand.make({
+		parts,
+		expectedPackages
+	}));
+	if (Result.isSuccess(decision)) return decision.success;
+	return yield* failMerge(failureReason(decision.failure, partsDir));
+});
+const writeReportOutputs = (path, out, report) => Effect.forEach(Option.toArray(Option.fromUndefinedOr(report)), (present) => Effect.gen(function* () {
+	yield* writeFile(path.join(out, MERGED_REPORT_FILE), JSON.stringify(present), false);
+	yield* writeHtmlReport(path.join(out, MERGED_HTML_FILE), present);
+}), { discard: true });
+const appendStepSummary = (summary) => Effect.forEach(Option.toArray(Option.filter(Option.fromNullishOr(process.env[STEP_SUMMARY_VARIABLE]), (file) => file.length > 0)), (file) => writeFile(file, summary, true), { discard: true });
+const runMergeReports = (request) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const out = request.out;
+	const expectedPackages = yield* parsePackages(request.packages);
+	yield* ensurePartsDir(fs, request.parts);
+	const { parts, skipped, unreadable } = yield* readParts(request.parts);
+	const decision = yield* decideReports(parts, expectedPackages, request.parts);
+	yield* fs.makeDirectory(out, { recursive: true }).pipe(Effect.catchCause(() => failMerge(`cannot create ${out}`)));
+	yield* writeReportOutputs(path, out, mergedReport(decision));
+	const summary = summaryMarkdown(decision.rows, survivorList(decision), skipped, unreadable.length);
+	yield* writeFile(path.join(out, MERGED_SUMMARY_FILE), summary, false);
+	yield* appendStepSummary(summary);
+	yield* Console.log(summary);
+	yield* Effect.forEach(whenHolds(unreadable.length > 0, [`${unreadable.length} unreadable part(s): ${unreadable.join(", ")}`], []), failMerge, { discard: true });
+});
+//#endregion
 //#region src/resolve-output-mode.workflow.ts
 const TOOL_VARIABLES$1 = ["CLAUDECODE", "CODEX_SANDBOX"];
 var ResolveModeCommand = class extends S.TaggedClass()("ResolveModeCommand", {
@@ -721,62 +1160,62 @@ var MachineOutput = class extends S.TaggedClass()("MachineOutput", {
 	[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({
-		option: "json",
-		value: "text",
-		expected: CONFLICT_EXPECTED
-	}));
-	if (command.text === true) return Result.succeed(HumanOutput.make({
-		signal: "flag",
-		stdoutIsTTY: command.stdoutIsTTY
-	}));
-	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(MachineOutput.make({
-			signal: "env",
-			stdoutIsTTY: command.stdoutIsTTY
-		}));
-		return Result.succeed(HumanOutput.make({
-			signal: "env",
-			stdoutIsTTY: command.stdoutIsTTY
-		}));
-	}
-	if (!command.stdoutIsTTY) return Result.succeed(MachineOutput.make({
-		signal: "tty",
-		stdoutIsTTY: false
-	}));
-	if (command.agent !== void 0 && command.agent.length > 0) return Result.succeed(MachineOutput.make({
+const configured = (value) => Option.filter(Option.fromNullishOr(value), (text) => text.length > 0);
+const modeFromEnv = (envMode, stdoutIsTTY) => Match.value(envMode).pipe(Match.when("machine", () => MachineOutput.make({
+	signal: "env",
+	stdoutIsTTY
+})), Match.orElse(() => HumanOutput.make({
+	signal: "env",
+	stdoutIsTTY
+})));
+const modeFromAgent = (command) => Option.match(configured(command.agent), {
+	onNone: () => modeFromTools(command),
+	onSome: () => 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(MachineOutput.make({
-			signal: "tool",
-			stdoutIsTTY: true
-		}));
-	}
-	return Result.succeed(HumanOutput.make({
-		signal: "tty",
-		stdoutIsTTY: true
-	}));
-}
-function modeDecision(command) {
-	return r4(command);
-}
-const resolveOutputMode = Workflow.make(ResolveModeCommand, modeDecision);
+	})
+});
+const modeFromTools = (command) => Match.value(anyToolVariableSet(command.toolVars)).pipe(Match.when(true, () => MachineOutput.make({
+	signal: "tool",
+	stdoutIsTTY: true
+})), Match.orElse(() => HumanOutput.make({
+	signal: "tty",
+	stdoutIsTTY: true
+})));
+const anyToolVariableSet = (toolVars) => Option.match(Option.fromNullishOr(toolVars), {
+	onNone: () => false,
+	onSome: (named) => TOOL_VARIABLES$1.some((variable) => Option.isSome(configured(named[variable])))
+});
+const modeBelowEnv = (command) => Match.value(command.stdoutIsTTY).pipe(Match.when(false, () => MachineOutput.make({
+	signal: "tty",
+	stdoutIsTTY: false
+})), Match.orElse(() => modeFromAgent(command)));
+const modeFromEnvironment = (command) => Option.match(configured(command.envMode), {
+	onNone: () => modeBelowEnv(command),
+	onSome: (envMode) => modeFromEnv(envMode, command.stdoutIsTTY)
+});
+const decideMode = (command) => Match.value(command).pipe(Match.when({
+	text: true,
+	json: true
+}, () => Result.fail(ModeConflictError.make({
+	option: "json",
+	value: "text",
+	expected: CONFLICT_EXPECTED
+}))), Match.when({ text: true }, (texted) => Result.succeed(HumanOutput.make({
+	signal: "flag",
+	stdoutIsTTY: texted.stdoutIsTTY
+}))), Match.when({ json: true }, (jsoned) => Result.succeed(MachineOutput.make({
+	signal: "flag",
+	stdoutIsTTY: jsoned.stdoutIsTTY
+}))), Match.orElse((rest) => Result.succeed(modeFromEnvironment(rest))));
+const resolveOutputMode = Workflow.make(ResolveModeCommand, decideMode);
 //#endregion
 //#region src/Output.ts
 const TICK_INTERVAL_MS = 1e4;
 var RunEventStreamPortTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/Output/RunEventStreamPortTag") {};
 const RunEventStreamPort = RunEventStreamPortTag;
-const isTerminalEvent = (event) => Match.value(event).pipe(Match.tag("verdict", () => true), Match.tag("error", () => true), Match.tag("help", () => true), Match.tag("manifest", () => true), Match.orElse(() => false));
-const wireKind = (event) => Match.value(event).pipe(Match.tag("stream", () => "stream"), Match.tag("phase", () => "phase"), Match.tag("plan", () => "plan"), Match.tag("mutant", () => "mutant"), Match.tag("tick", () => "tick"), Match.tag("verdict", () => "verdict"), Match.tag("error", () => "error"), Match.tag("help", () => "help"), Match.tag("manifest", () => "manifest"), Match.exhaustive);
+const isTerminalEvent = (event) => Match.value(event).pipe(Match.tag("verdict", () => true), Match.tag("error", () => true), Match.tag("help", () => true), Match.orElse(() => false));
+const wireKind = (event) => Match.value(event).pipe(Match.tag("stream", () => "stream"), Match.tag("phase", () => "phase"), Match.tag("plan", () => "plan"), Match.tag("mutant", () => "mutant"), Match.tag("tick", () => "tick"), Match.tag("verdict", () => "verdict"), Match.tag("error", () => "error"), Match.tag("help", () => "help"), Match.exhaustive);
 const toWireLine = (event) => {
 	const fields = Object.fromEntries(Object.entries(event).filter(([key]) => key !== "_tag"));
 	return JSON.stringify({
@@ -813,8 +1252,7 @@ const makeRunEventStream = (stdio, resolved, drainFramed = drainOf.bind(null, st
 		progress: {
 			completed: 0,
 			total: null
-		},
-		findingsPrinted: 0
+		}
 	};
 	const queueStream = Stream.fromQueue(queue).pipe(Stream.tap((event) => Effect.sync(() => {
 		Match.value(event).pipe(Match.tag("plan", (e) => {
@@ -838,41 +1276,57 @@ const makeRunEventStream = (stdio, resolved, drainFramed = drainOf.bind(null, st
 		});
 	})));
 	let terminalSeen = false;
-	const drain = drainFramed(Stream.merge(queueStream, tickStream, { haltStrategy: "either" }).pipe(Stream.tap((event) => {
+	const noteTerminal = (event) => {
+		state.terminalWritten = state.terminalWritten || isTerminalEvent(event);
+	};
+	const progressTap = (event) => {
 		const line = stderrProgressLine(event, state.terminalWritten);
-		if (isTerminalEvent(event)) state.terminalWritten = true;
-		if (line === void 0) return Effect.void;
-		return writeStderr(stdio, line);
-	})).pipe(Stream.filter((event) => {
-		if (state.mode !== "machine") return false;
-		if (terminalSeen) return false;
-		if (isTerminalEvent(event)) terminalSeen = true;
+		noteTerminal(event);
+		return Option.match(Option.fromUndefinedOr(line), {
+			onNone: () => Effect.void,
+			onSome: (text) => writeStderr(stdio, text)
+		});
+	};
+	const framingOpen = () => state.mode === "machine" && !terminalSeen;
+	const markTerminalFramed = (event) => {
+		terminalSeen = terminalSeen || isTerminalEvent(event);
+	};
+	const frameEvent = (event) => {
+		if (!framingOpen()) return false;
+		markTerminalFramed(event);
 		return true;
-	}), Stream.map((event) => `${toWireLine(event)}\n`)));
+	};
+	const drain = drainFramed(Stream.merge(queueStream, tickStream, { haltStrategy: "either" }).pipe(Stream.tap(progressTap)).pipe(Stream.filter(frameEvent), Stream.map((event) => `${toWireLine(event)}\n`)));
 	let drainFiber = null;
+	const outputOpen = () => state.mode === "machine" && !state.terminalWritten;
+	const offerStarted = () => Effect.gen(function* () {
+		if (state.mode !== "machine") return;
+		yield* Queue.offer(queue, RunStarted.make({
+			schemaVersion: "1.0",
+			runId,
+			mode: state.mode,
+			signal: state.signal
+		}));
+	});
+	const openHeader = () => Effect.gen(function* () {
+		if (state.headerWritten) return;
+		state.headerWritten = true;
+		yield* offerStarted();
+	});
 	return {
 		queue,
 		runId,
 		startedAt,
-		isOpen: () => state.mode === "machine" && !state.terminalWritten && drainFiber !== null,
+		isOpen: () => outputOpen() && drainFiber !== null,
 		ensureOpen: (openResolved) => {
 			if (state.headerWritten) return;
 			state.mode = openResolved.mode;
 			state.signal = openResolved.signal;
 		},
 		open: Effect.gen(function* () {
-			if (drainFiber === null) {
-				if (!state.headerWritten) {
-					state.headerWritten = true;
-					if (state.mode === "machine") yield* Queue.offer(queue, RunStarted.make({
-						schemaVersion: "1.0",
-						runId,
-						mode: state.mode,
-						signal: state.signal
-					}));
-				}
-				drainFiber = yield* Effect.forkDetach(drain);
-			}
+			if (drainFiber !== null) return;
+			yield* openHeader();
+			drainFiber = yield* Effect.forkDetach(drain);
 		}),
 		closeAndDrain: Effect.gen(function* () {
 			state.terminalWritten = true;
@@ -892,74 +1346,33 @@ const decisionToResolvedMode = (decision) => Match.value(decision).pipe(Match.ta
 	signal: machine.signal,
 	stdoutIsTTY: machine.stdoutIsTTY
 })), Match.exhaustive);
+const definedToolVars = (vars) => Object.fromEntries(Object.entries(vars ?? {}).filter((entry) => entry[1] !== void 0));
+const commandFor = (input) => ResolveModeCommand.make({
+	stdoutIsTTY: input.stdoutIsTTY,
+	text: input.text,
+	json: input.json,
+	envMode: input.envMode,
+	agent: input.agent,
+	toolVars: definedToolVars(input.toolVars)
+});
 function isColorEnabled(resolved, noColor) {
-	if (resolved.mode !== "human") return false;
-	if (noColor === void 0) return true;
-	if (noColor.length === 0) return true;
-	return false;
+	const requested = Option.exists(Option.fromUndefinedOr(noColor), (value) => value.length > 0);
+	return resolved.mode === "human" && !requested;
 }
 var OutputModeProbeTag = class extends Context.Service()("@systemfsoftware/stryker-js-cli/Output/OutputModeProbeTag") {};
 const OutputModeProbe = OutputModeProbeTag;
+const envToolVars = () => definedToolVars(Object.fromEntries(TOOL_VARIABLES.map((variable) => [variable, process.env[variable]])));
+const probeInput = (command) => ({
+	stdoutIsTTY: process.stdout.isTTY === true,
+	text: command.text,
+	json: command.json,
+	envMode: process.env["STRYKER_MODE"],
+	agent: process.env["AGENT"],
+	toolVars: envToolVars()
+});
 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);
-	})()),
+	read: (command) => Effect.succeed(probeInput(command)),
+	decode: (raw) => Result.succeed(commandFor(raw)),
 	decide: resolveOutputMode,
 	encode: (outcome) => Result.map(outcome, decisionToResolvedMode),
 	write: (outcome) => Result.match(outcome, {
@@ -1007,29 +1420,24 @@ function offerFailureEnvelope(stream, failed, captured) {
 		remediation: envelope.remediation
 	}));
 }
+const emitHelpEnvelope = (stream, help) => Queue.offer(stream.queue, HelpRendered.make({
+	schemaVersion: "1.0",
+	code: 0,
+	help
+}));
+const helpPayload = (ok, captured) => Option.filter(Option.some(captured), () => ok.help || captured.length > 0);
+const emitNullScoreVerdictWhenOpen = (stream, mode, basePath, pathService) => Effect.gen(function* () {
+	if (!stream.isOpen()) return;
+	yield* emitNullScoreVerdict(stream, mode, (yield* defaultOptions).thresholds, {}, basePath, pathService);
+});
 function emitMachineModeOutput(stream, mode, outcome, basePath, pathService) {
 	return Effect.gen(function* () {
 		const captured = readCapturedConsole();
 		if (Result.isSuccess(outcome)) {
 			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);
+			return yield* Match.value(decision).pipe(Match.tag("RunOk", (ok) => Option.match(helpPayload(ok, captured), {
+				onSome: (help) => emitHelpEnvelope(stream, help),
+				onNone: () => emitNullScoreVerdictWhenOpen(stream, mode, 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);
 		}
 		return yield* offerFailureEnvelope(stream, outcome.failure, captured);
@@ -1066,59 +1474,16 @@ const RunEventStreamFileLive = Layer.effect(RunEventStreamPort, Effect.gen(funct
 }));
 //#endregion
 //#region src/Survivors.ts
-/**
-* Survivors — the survivors-admission capability.
-*
-* The prior-report decoding, source hashing, mutant conversion, and admission
-* pipeline for --survivors runs. Pure admission decision lives in
-* admit-survivors-run.workflow.ts.
-*/
 const DEFAULT_SURVIVORS_PRIOR_REPORT = "reports/mutation-report.json";
-/**
-* 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.
-*/
-/**
-* The prior report as a document, decoded at the boundary. Module-internal: consumers
-* get the decode function, not the schema, so the report's wire shape is not a
-* surface commitment and the codec has exactly one caller.
-*
-* `status` is a bare string rather than the closed status set on purpose: the decide only
-* compares it to `'Survived'`, so a report written by a newer engine that added a status
-* must not be refused for carrying one.
-*/
-/**
-* Decodes a prior report read from disk. Pure, so it runs in the decode phase, whose
-* `Left` is fatal by construction — it reaches the derived error channel and no write
-* runs. A malformed report therefore never reaches the decider, and nothing here casts
-* a third-party report type.
-*/
 const decodePriorReport = S.decodeUnknownResult(PriorReportDocument);
 const { entries: objectEntries, fromEntries: objectFromEntries } = Object;
-/**
-* Thin by design: the digest is the caller's capability, and naming the call
-* keeps every hashing site in the admission path reading the same way.
-*/
+const EMPTY_CONFIG = {};
 function sourceContentHash(content, hash) {
 	return hash(content);
 }
-/**
-* The per-file source hashes of the sources a prior report embeds.
-*
-* The current run's side of the comparison is gathered by the shell from disk;
-* this is the recorded side, read back out of the report.
-*/
 function priorSourceHashes(priorReport, hashContent) {
 	return objectFromEntries(objectEntries(priorReport.files).map(([file, fileResult]) => [file, sourceContentHash(fileResult.source, hashContent)]));
 }
-/**
-* 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 Mutant.make({
 		id: mutant.id,
@@ -1137,34 +1502,11 @@ function reportMutantToMutant(file, mutant, resolveAbsolutePath) {
 		}
 	});
 }
-/**
-* 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;
+	return objectEntries(priorReport.files).flatMap(([file, fileResult]) => fileResult.mutants.filter((mutant) => mutant.status === "Survived").map((mutant) => reportMutantToMutant(file, mutant, resolveAbsolutePath)));
 }
-/**
-* 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, basePath) {
-	const spans = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const survivor of survivors) {
-		const file = toRelativeNormalizedFileName(survivor.fileName, basePath);
-		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;
+	return [...new Set(survivors.map((survivor) => `${toRelativeNormalizedFileName(survivor.fileName, basePath)}:${survivor.location.start.line + 1}:${survivor.location.start.column}-${survivor.location.end.line + 1}:${survivor.location.end.column}`))];
 }
 const hashContent = (content) => bytesToHex(sha256(utf8ToBytes(content)));
 const survivorsAdmissionCell = (basePath) => Cell.layer({
@@ -1195,8 +1537,8 @@ const survivorsAdmissionCell = (basePath) => Cell.layer({
 		}));
 		return Result.map(decodePriorReport(priorReportRaw), (document) => AdmitSurvivorsRunCommand.make({
 			priorReport: PriorReportFacts.make({
-				config: document.config ?? {},
-				frameworkVersion: document.framework?.version
+				config: Option.getOrElse(Option.fromNullishOr(document.config), () => EMPTY_CONFIG),
+				frameworkVersion: Option.getOrUndefined(Option.flatMap(Option.fromNullishOr(document.framework), (framework) => Option.fromNullishOr(framework.version)))
 			}),
 			currentConfig: resolvedOptions,
 			frameworkVersion: strykerVersion,
@@ -1245,11 +1587,7 @@ function readPriorReport(priorReportPath) {
 	});
 }
 function priorReportFileKeys(raw) {
-	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return [];
-	if (!("files" in raw)) return [];
-	const files = raw.files;
-	if (typeof files !== "object" || files === null || Array.isArray(files)) return [];
-	return Object.keys(files);
+	return Option.getOrElse(Option.map(Option.flatMap(Option.liftPredicate(raw, Match.record), (document) => Option.liftPredicate(document["files"], Match.record)), (files) => Object.keys(files)), () => []);
 }
 function readSourceFile(file) {
 	return Effect.flatMap(FileSystem.FileSystem, (fs) => fs.readFileString(file).pipe(Effect.mapError((cause) => ConfigFileUnreadableError.make({
@@ -1266,14 +1604,6 @@ const SIGNAL_NUMBERS = Object.freeze({
 	SIGINT: 2,
 	SIGTERM: 15
 });
-/**
-* Installs the listeners and returns the reader.
-*
-* The listener records and returns: interrupting the run is the runtime's job,
-* and doing it from here would race the run's own finalizer for the stream.
-* `once` per signal, because a second delivery of the same signal cannot
-* change the answer.
-*/
 function observeTerminatingSignal() {
 	let observed = null;
 	for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {
@@ -1281,269 +1611,23 @@ function observeTerminatingSignal() {
 	});
 	return () => observed;
 }
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringField(node, key) {
-	const value = node[key];
-	return (() => {
-		if (typeof value === "string") return value;
-	})();
-}
-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 (() => {
-		if (tag === void 0) return "unknown";
-		return 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;
-}
-const REPORTER_NAMES = [
-	"clear-text",
-	"progress",
-	"html",
-	"json",
-	"progress-stream"
-];
-/**
-* 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 (() => {
-				if (typeof value === "string") return value;
-				return "";
-			})();
-		}
-		default: return "";
-	}
-}
-function describeSingle(single, isOptional, out) {
-	const name = stringField(single, "name") ?? "";
-	const primitive = (() => {
-		if (isObject(single["primitiveType"])) return single["primitiveType"];
-		return {};
-	})();
-	const kind = kindOf(primitive);
-	const choices = (() => {
-		if (name === "reporters") return REPORTER_NAMES;
-		if (kind === "choice") return choiceValues(primitive);
-	})();
-	const description = descriptionOf(single);
-	const required = kind !== "boolean" && !isOptional;
-	const described = {
-		name,
-		aliases: stringArrayField(single, "aliases"),
-		kind,
-		required,
-		...(() => {
-			if (choices !== void 0) return { choices };
-			return {};
-		})(),
-		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 = (() => {
-				if (typeof index === "number") return orderedParams[index];
-			})();
-			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"])) {
-		let orderedParams = [];
-		const maybeOrdered = config["orderedParams"];
-		if (Array.isArray(maybeOrdered)) orderedParams = maybeOrdered;
-		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: (() => {
-			if (typeof node["description"] === "string") return node["description"];
-			return "";
-		})(),
-		options: out.flags,
-		args: out.args,
-		subcommands
-	};
-}
-function readCoreEntries() {
-	return Effect.gen(function* () {
-		const path = yield* Path.Path;
-		const fs = yield* FileSystem.FileSystem;
-		const resolved = import.meta.resolve("@systemfsoftware/stryker-js-engine/package.json");
-		const manifestPath = yield* path.fromFileUrl(new URL(resolved));
-		const raw = yield* fs.readFileString(manifestPath);
-		let parsed;
-		try {
-			parsed = JSON.parse(raw);
-		} catch {
-			return [];
-		}
-		const ExportsSchema = S.Struct({ exports: S.Record(S.String, S.Unknown) });
-		const decoded = S.decodeUnknownResult(ExportsSchema)(parsed);
-		if (Result.isSuccess(decoded)) return Object.keys(decoded.success.exports).filter((key) => key !== "./package.json");
-		return [];
-	}).pipe(Effect.catchCause(() => {
-		return Effect.succeed([]);
-	}));
-}
-function buildLLMSManifest(command, version) {
-	return Effect.gen(function* () {
-		const root = describeCommandNode(command) ?? {
-			name: "",
-			description: "",
-			options: [],
-			args: [],
-			subcommands: []
-		};
-		const entries = yield* readCoreEntries();
-		return {
-			schemaVersion: "1.0",
-			tool: root.name,
-			version,
-			commands: [root],
-			entries
-		};
-	});
-}
-function emitLLMSManifest(command, version) {
-	return Effect.map(buildLLMSManifest(command, version), (manifest) => JSON.stringify(manifest));
-}
 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.
-*/
+const CLEAN_TEMP_DIR_DISABLED = ["false", "0"];
 function parseCleanDirOption(value) {
-	const v = value.toLocaleLowerCase();
-	return (() => {
-		if (v === "always") return v;
-		return v !== "false" && v !== "0";
-	})();
+	const normalized = value.toLocaleLowerCase();
+	return Match.value(normalized).pipe(Match.when("always", () => "always"), Match.orElse(() => !CLEAN_TEMP_DIR_DISABLED.some((disabled) => disabled === normalized)));
 }
-/**
-* 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`. `Flag.optional` yields `Option.none` when the flag is absent and
-* `Option.some(false)` for an explicit `--no-x`, so both map back to
-* `undefined` and leave the config-file default in force (KTD4).
-*/
-const absentWhenFalse = (value) => {
-	if (Option.isSome(value) && value.value) return true;
-};
+const absentWhenFalse = (value) => Option.getOrUndefined(Option.filter(value, (present) => present));
+const isUnknownArgument = (argument) => Option.exists(Option.fromUndefinedOr(argument), (text) => text.startsWith("-"));
 function setLogLevel(target, key, value) {
 	const unwrapped = unwrap(value);
 	if (unwrapped !== void 0) target[key] = unwrapped;
@@ -1607,7 +1691,11 @@ const runConfig = {
 	...runOptions,
 	...runArgs
 };
-const rootConfig = { llms: Flag.map(optional(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.")) };
+const mergeReportsOptions = {
+	parts: Flag.string("parts").pipe(Flag.withDescription("The directory holding the downloaded mutation report parts (any download layout).")),
+	out: Flag.string("out").pipe(Flag.withDescription("The directory to write the merged report, its html view, and the summary into.")),
+	packages: Flag.string("packages").pipe(Flag.withDescription("A JSON array of the package names the run expected, falling back to the PACKAGES environment variable."), optional)
+};
 function unwrap(value) {
 	if (Option.isOption(value)) return Option.match(value, {
 		onNone: () => void 0,
@@ -1619,30 +1707,16 @@ 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] }))));
+		if (isUnknownArgument(configFile)) 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);
@@ -1679,25 +1753,18 @@ function makeStrykerCommand(requestRef) {
 		if (Option.isSome(config["configFile"])) options["configFile"] = config["configFile"].value;
 		return options;
 	}
-	const strykerCommand = Command.make("stryker", rootConfig, (config) => Effect.gen(function* () {
-		if (config.llms === true) {
-			const document = {
-				_tag: "manifest",
-				schemaVersion: "1.0",
-				code: 0,
-				manifest: yield* emitLLMSManifest(strykerCommand, strykerVersion)
-			};
-			return yield* Ref.set(requestRef, Option.some({
-				_tag: "llms",
-				document
-			}));
-		}
+	const mergeReportsCommand = Command.make("merge-reports", mergeReportsOptions, (config) => Ref.set(requestRef, Option.some({
+		_tag: "merge-reports",
+		parts: config.parts,
+		out: config.out,
+		packages: Option.getOrUndefined(config.packages) ?? process.env["PACKAGES"]
+	}))).pipe(Command.withDescription("Merge per-package mutation reports into one report"));
+	return Command.make("stryker", {}, (_config) => Effect.gen(function* () {
 		return yield* Effect.failSync(() => CliError.ShowHelp.make({
 			commandPath: ["stryker"],
 			errors: []
 		}));
-	})).pipe(Command.withSubcommands([runCommand]));
-	return strykerCommand;
+	})).pipe(Command.withSubcommands([runCommand, mergeReportsCommand]));
 }
 const terminalLayer = Layer.succeed(Terminal.Terminal, Terminal.make({
 	columns: Effect.sync(() => process.stdout.columns),
@@ -1748,10 +1815,19 @@ function hostOptionsOf(mode, stream) {
 		resolvedMode: mode,
 		runStartedAt: stream.startedAt,
 		basePath: process.cwd(),
-		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-html-reporter"), import.meta.resolve("@systemfsoftware/stryker-js-engine/builtin-reporters")],
+		reporterPluginModules: [import.meta.resolve("@systemfsoftware/stryker-js-html-reporter")],
 		allowConsoleColors: isColorEnabled(mode, process.env["NO_COLOR"])
 	};
 }
+const isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+const progressStreamFileName = (request) => Option.match(request, {
+	onNone: () => DEFAULT_PROGRESS_STREAM_FILE,
+	onSome: (cliRequest) => Match.value(cliRequest).pipe(Match.tag("merge-reports", () => DEFAULT_PROGRESS_STREAM_FILE), Match.tag("run", (runRequest) => Option.getOrElse(Option.filter(Option.fromNullishOr(runRequest.options["progressStreamFile"]), isNonEmptyString), () => DEFAULT_PROGRESS_STREAM_FILE)), Match.exhaustive)
+});
+const applyProgressStreamFile = (stream, fileName) => Option.match(Option.fromUndefinedOr(stream.setProgressStreamFile), {
+	onNone: () => Effect.void,
+	onSome: (setFileName) => setFileName(fileName)
+});
 const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 	const stream = yield* createRunEventStream(input.mode);
 	const hostOptions = hostOptionsOf(input.mode, stream);
@@ -1764,7 +1840,7 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 		process.removeListener("SIGTERM", onSignal);
 		if (currentFiber !== null) currentFiber.interruptUnsafe(currentFiber.id);
 	};
-	const dispatch = (request) => Match.value(request).pipe(Match.tag("run", (runRequest) => (() => {
+	const dispatch = (request) => Match.value(request).pipe(Match.tag("merge-reports", (mergeRequest) => runMergeReports(mergeRequest).pipe(Effect.provide(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)))), Match.tag("run", (runRequest) => (() => {
 		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) => {
@@ -1780,18 +1856,7 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 			}), Match.exhaustive);
 		});
 		return runMutationTestImpl(runRequest.options).pipe(Effect.orDie);
-	})()), Match.tag("llms", (llmsRequest) => Effect.gen(function* () {
-		stream.ensureOpen({
-			mode: "machine",
-			signal: "flag",
-			stdoutIsTTY: process.stdout.isTTY === true
-		});
-		yield* Queue.offer(stream.queue, ManifestRendered.make({
-			schemaVersion: "1.0",
-			code: 0,
-			manifest: llmsRequest.document.manifest
-		}));
-	})), Match.orElse(() => Effect.die("unreachable cli request variant")));
+	})()), Match.exhaustive);
 	const program = Effect.acquireUseRelease(Effect.sync(() => {
 		currentFiber = Fiber.getCurrent() ?? null;
 		process.on("SIGINT", onSignal);
@@ -1799,15 +1864,7 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 	}), () => Effect.gen(function* () {
 		const parsed = yield* Effect.result(input.program);
 		const request = yield* Ref.get(input.requestRef);
-		const fileName = Option.match(request, {
-			onNone: () => DEFAULT_PROGRESS_STREAM_FILE,
-			onSome: (cliRequest) => Match.value(cliRequest).pipe(Match.tag("run", (runRequest) => {
-				const fromCli = runRequest.options["progressStreamFile"];
-				if (typeof fromCli === "string" && fromCli.length > 0) return fromCli;
-				return DEFAULT_PROGRESS_STREAM_FILE;
-			}), Match.orElse(() => DEFAULT_PROGRESS_STREAM_FILE))
-		});
-		if (stream.setProgressStreamFile !== void 0) yield* stream.setProgressStreamFile(fileName);
+		yield* applyProgressStreamFile(stream, progressStreamFileName(request));
 		yield* stream.open;
 		if (Result.isFailure(parsed)) return yield* Effect.fail(parsed.failure);
 		return yield* Option.match(request, {
@@ -1829,14 +1886,18 @@ const runStrykerCli = (input, createRunEventStream) => Effect.gen(function* () {
 //#endregion
 //#region src/main.ts
 const EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER = 1;
+/** The major version `engines.node` floors the CLI at. */
+const SUPPORTED_NODE_MAJOR = 20;
 process.title = "stryker";
 const lastSignal = observeTerminatingSignal();
+/** The numbers a `process.version` names; a component that does not parse stays `NaN`. */
+const versionNumbers = (version) => version.replace(/^v/, "").split(/[-+]/).slice(0, 1).flatMap((base) => base.split(".")).map((part) => Number.parseInt(part, 10));
+const componentAt = (numbers, index) => Option.getOrElse(Option.fromUndefinedOr(numbers[index]), () => 0);
+/** Every reason the CLI refuses the running Node.js, checked against the parsed version numbers. */
+const NODE_VERSION_REJECTIONS = [(numbers) => numbers.some(Number.isNaN), (numbers) => componentAt(numbers, 0) < SUPPORTED_NODE_MAJOR];
 function isSupportedNodeVersion(version) {
-	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;
+	const numbers = versionNumbers(version);
+	return !NODE_VERSION_REJECTIONS.some((rejects) => rejects(numbers));
 }
 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* () {
@@ -1844,17 +1905,12 @@ const program = Effect.gen(function* () {
 	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.layer, NodePath.layer)))));
+const publishedExitCode = (exit) => Option.flatMap(Option.liftPredicate(exit, Exit.isSuccess), (succeeded) => Option.liftPredicate(succeeded.value, (value) => typeof value === "number"));
+const signalExitCode = (signal) => Option.getOrElse(Option.map(Option.fromNullishOr(signal), (stopped) => 128 + stopped), () => EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER);
+const teardownExitCode = (exit, signal) => Option.getOrElse(publishedExitCode(exit), () => signalExitCode(signal));
 NodeRuntime.runMain(program, {
 	disableErrorReporting: true,
-	teardown: (exit, onExit) => {
-		if (Exit.isSuccess(exit) && typeof exit.value === "number") {
-			onExit(exit.value);
-			return;
-		}
-		const signal = lastSignal();
-		if (signal === null) onExit(EXIT_CODE_RUN_NEVER_REACHED_ITS_FINALIZER);
-		else onExit(128 + signal);
-	}
+	teardown: (exit, onExit) => onExit(teardownExitCode(exit, lastSignal()))
 });
 //#endregion
 export {};