@systemfsoftware/stryker-js-cli 3.0.0 → 3.0.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @systemfsoftware/stryker-js-cli
 
+## 3.0.1
+
+### Patch Changes
+
+- A `--survivors` run given a prior report that exists but does not parse now stops and names the parse failure. It previously reported that no prior report was found — the same message as an absent report — so a corrupted or truncated report looked like a missing one.
+
+  The exit code is unchanged, and so is every admission verdict: a report whose recorded options, framework version or source content disagree with the current run still reports a mismatch, a report a `--survivors` run produced itself is still refused, an absent report still reports that none was found, and a report with no surviving mutants still ends the run without re-testing.
+
+- Fix the CLI refusing to start with a missing-flag error when optional boolean flags were omitted. Starting a mutation run, printing help, or emitting the agent manifest now works without explicitly passing `incremental`, `force`, `ignoreStatic`, or the other boolean flags.
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@4.0.0
+  - @systemfsoftware/stryker-js-mutation-run@4.0.0
+
 ## 3.0.0
 
 ### Major Changes

package/dist/main.mjs

@@ -34,9 +34,9 @@ import { strykerPlugins } from "@systemfsoftware/stryker-js-mutation-report/stry
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { noopLogger } from "@stryker-mutator/util";
 import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
 import "@systemfsoftware/stryker-js-plugin-api/core";
+import { noopLogger } from "@systemfsoftware/stryker-js-util";
 import * as Exit from "effect/Exit";
 import { pipe } from "effect/Function";
 import * as Match from "effect/Match";
@@ -670,10 +670,6 @@ function sortKeys(value) {
 	if (isRecord(value)) return objectFromEntries(objectKeys(value).sort().map((key) => [key, sortKeys(value[key])]));
 	return value;
 }
-/** The single structural hash the admission compares (KTD6). */
-function structuralHash(input, hash) {
-	return hash(serializeSurvivorsHashInput(input));
-}
 /**
 * Converts a report mutant (1-based schema location) into the internal mutant
 * shape a run consumes (0-based positions, absolute file name) — the exact
@@ -729,6 +725,106 @@ function survivorMutateSpans(survivors) {
 	}
 	return spans;
 }
+/**
+* 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,
+	mutatorName: S.String,
+	replacement: S.String,
+	location: S.Struct({
+		start: S.Struct({
+			line: S.Finite,
+			column: S.Finite
+		}),
+		end: S.Struct({
+			line: S.Finite,
+			column: S.Finite
+		})
+	})
+});
+/**
+* The prior report as a document, decoded at the boundary. Module-internal: consumers
+* get {@link decodePriorReport}, 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.
+*/
+const PriorReportDocument = S.Struct({
+	config: S.optional(S.Record(S.String, S.Unknown)),
+	framework: S.optional(S.Struct({ version: S.optional(S.String) })),
+	files: S.Record(S.String, S.Struct({
+		source: S.String,
+		mutants: S.Array(S.Struct({
+			id: S.String,
+			mutatorName: S.String,
+			replacement: S.optional(S.String),
+			status: S.String,
+			location: S.Struct({
+				start: S.Struct({
+					line: S.Finite,
+					column: S.Finite
+				}),
+				end: S.Struct({
+					line: S.Finite,
+					column: S.Finite
+				})
+			})
+		}))
+	}))
+});
+/**
+* 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);
+/**
+* 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).";
@@ -737,19 +833,23 @@ function priorSourceHashes(priorReport, hashContent) {
 	return objectFromEntries(objectEntries(priorReport.files).map(([file, fileResult]) => [file, sourceContentHash(fileResult.source, hashContent)]));
 }
 /**
-* Whether the admission hashes agree: the prior report's embedded resolved
-* options, framework version and source content against the current run's.
+* 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 structuralHash({
+	return serializeSurvivorsHashInput({
 		resolvedOptions: stripSurvivorsKeys(priorReport.config),
-		frameworkVersion: priorReport.framework?.version,
-		sourceContentHashes: priorSourceHashes(priorReport, input.hashContent)
-	}, input.hashContent) === structuralHash({
+		frameworkVersion: priorReport.frameworkVersion,
+		sourceContentHashes: input.priorSourceHashes
+	}) === serializeSurvivorsHashInput({
 		resolvedOptions: stripSurvivorsKeys(input.currentConfig),
 		frameworkVersion: input.frameworkVersion,
 		sourceContentHashes: input.sourceContentHashes
-	}, input.hashContent);
+	});
 }
 const rejection = (reason, detail) => ({
 	kind: "reject",
@@ -760,31 +860,15 @@ function admissionVerdict(input) {
 	const priorReport = input.priorReport;
 	if (priorReport === void 0) return rejection("no-report", NO_REPORT_DETAIL);
 	if (wasProducedBySurvivorsRun(priorReport)) return rejection("mismatch", SURVIVORS_RUN_SOURCE_DETAIL);
-	const survivors = extractSurvivors(priorReport, input.resolveAbsolutePath);
-	if (survivors.length === 0) return { kind: "no-survivors" };
+	if (input.priorSurvivors.length === 0) return { kind: "no-survivors" };
 	if (!hashesMatch(priorReport, input)) return rejection("mismatch", MISMATCH_DETAIL);
 	return {
 		kind: "admit",
-		survivors
+		survivors: input.priorSurvivors
 	};
 }
 const SurvivorsAdmissionTypeId = Symbol.for("@systemfsoftware/stryker-js-cli/SurvivorsAdmission");
-var Admitted = class extends S.TaggedClass()("Admitted", { survivors: S.Array(S.Struct({
-	id: S.String,
-	fileName: S.String,
-	mutatorName: S.String,
-	replacement: S.String,
-	location: S.Struct({
-		start: S.Struct({
-			line: S.Finite,
-			column: S.Finite
-		}),
-		end: S.Struct({
-			line: S.Finite,
-			column: S.Finite
-		})
-	})
-})) }) {
+var Admitted = class extends S.TaggedClass()("Admitted", { survivors: S.Array(MutantShape) }) {
 	[SurvivorsAdmissionTypeId] = SurvivorsAdmissionTypeId;
 };
 var NoSurvivors = class extends S.TaggedClass()("NoSurvivors", {}) {
@@ -804,7 +888,7 @@ var SurvivorsRejection = class extends S.TaggedError()("SurvivorsRejection", {
 * the same reject outcome with different reasons; only the rejection's
 * remediation names the full run to do first (R10).
 */
-const admitSurvivorsRun = Workflow.make((command) => Match.value(admissionVerdict(command)).pipe(Match.discriminator("kind")("reject", (verdict) => Result.fail(SurvivorsRejection.make({
+const admitSurvivorsRun = Workflow.make(AdmitSurvivorsRunCommand, (command) => Match.value(admissionVerdict(command)).pipe(Match.discriminator("kind")("reject", (verdict) => Result.fail(SurvivorsRejection.make({
 	reason: verdict.reason,
 	remediation: verdict.remediation
 }))), Match.discriminator("kind")("no-survivors", () => Result.succeed(NoSurvivors.make())), Match.discriminator("kind")("admit", (verdict) => Result.succeed(Admitted.make({ survivors: verdict.survivors }))), Match.exhaustive));
@@ -812,10 +896,14 @@ const admitSurvivorsRun = Workflow.make((command) => Match.value(admissionVerdic
 //#region src/SurvivorsExit.ts
 /** The exit class a rejected survivors run exits with (R6: exit 2). */
 const SURVIVORS_REJECT_EXIT_CLASS = ExitClass.ConfigError;
-S.Union([S.TaggedStruct("run", {
+//#endregion
+//#region src/cli-request.schema.ts
+const RunRequestSchema = S.TaggedStruct("run", {
 	options: S.Any,
 	survivors: S.Boolean
-}), S.TaggedStruct("llms", { document: S.Any })]);
+});
+const LlmsRequestSchema = S.TaggedStruct("llms", { document: S.Any });
+S.Union([RunRequestSchema, LlmsRequestSchema]);
 //#endregion
 //#region src/StrykerCliExecutor.ts
 /**
@@ -866,48 +954,80 @@ function hostOptionsOf(mode, stream) {
 * stashed context back and dispatches the decision to the verdict/run,
 * failing the run with a rejection.
 */
-const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext) => pipe(Cell.read((cliOptions) => Effect.promise(() => resolveSurvivorsRunOptions(cliOptions)).pipe(Effect.flatMap((resolvedOptions) => {
-	const priorReportPath = priorReportPathOf(resolvedOptions);
-	const priorReport = readPriorReport(priorReportPath);
-	return Ref.set(runContext, {
-		resolvedOptions,
-		priorReportPath
-	}).pipe(Effect.as({
-		resolvedOptions,
-		priorReport,
-		priorReportPath,
-		sourceContentHashes: sourceContentHashesOf(priorReport)
-	}));
-}))), Cell.decode(({ resolvedOptions, priorReport, sourceContentHashes }) => Result.succeed({
-	priorReport,
-	currentConfig: resolvedOptions,
-	frameworkVersion: strykerVersion,
-	sourceContentHashes,
-	hashContent,
-	resolveAbsolutePath
-})), Cell.decide(admitSurvivorsRun), Cell.encode((outcome) => outcome), Cell.write((outcome) => Effect.flatMap(Ref.get(runContext), (context) => {
-	if (context === void 0) return Effect.die("the survivors admission read must run before its write");
-	const { resolvedOptions, priorReportPath } = context;
-	return Result.match(outcome, {
-		onSuccess: (decision) => Match.value(decision).pipe(Match.tag("NoSurvivors", () => Effect.sync(() => emitEmptySurvivorsVerdict(stream, mode, resolvedOptions))), Match.tag("Admitted", (admitted) => {
-			const restricted = {
-				...resolvedOptions,
-				survivors: admitted.survivors,
-				mutate: survivorMutateSpans(admitted.survivors),
-				survivorsPriorReport: priorReportPath,
-				incremental: false
-			};
-			return Effect.promise(() => runMutationTest(restricted));
-		}), Match.orElse(() => Effect.die("unreachable admission decision variant"))),
-		onFailure: (rejection) => Effect.fail(rejection)
-	});
-})));
+const survivorsAdmissionDescription = (runMutationTest, stream, mode, runContext) => pipe(
+	Cell.read((cliOptions) => Effect.promise(() => resolveSurvivorsRunOptions(cliOptions)).pipe(Effect.flatMap((resolvedOptions) => {
+		const priorReportPath = priorReportPathOf(resolvedOptions);
+		const read = readPriorReport(priorReportPath);
+		return Ref.set(runContext, {
+			resolvedOptions,
+			priorReportPath
+		}).pipe(Effect.as({
+			resolvedOptions,
+			priorReportRaw: read.raw,
+			priorReportFound: read.found,
+			priorReportPath,
+			sourceContentHashes: currentSourceHashesFor(priorReportFileKeys(read.raw))
+		}));
+	}))),
+	/**
+	* The one place the prior report is decoded, and the one place the two capabilities
+	* are applied. A report that was never there yields a command with no facts, which
+	* the decider rejects as `no-report`; a report that was there and does not decode
+	* yields a `Left`, which stops the run before the decider sees it.
+	*/
+	Cell.decode(({ resolvedOptions, priorReportRaw, priorReportFound, sourceContentHashes }) => {
+		if (!priorReportFound) return Result.succeed(AdmitSurvivorsRunCommand.make({
+			priorReport: void 0,
+			currentConfig: resolvedOptions,
+			frameworkVersion: strykerVersion,
+			sourceContentHashes,
+			priorSourceHashes: {},
+			priorSurvivors: []
+		}));
+		return Result.map(decodePriorReport(priorReportRaw), (document) => AdmitSurvivorsRunCommand.make({
+			priorReport: PriorReportFacts.make({
+				config: document.config ?? {},
+				frameworkVersion: document.framework?.version
+			}),
+			currentConfig: resolvedOptions,
+			frameworkVersion: strykerVersion,
+			sourceContentHashes,
+			priorSourceHashes: priorSourceHashes(document, hashContent),
+			priorSurvivors: extractSurvivors(document, resolveAbsolutePath)
+		}));
+	}),
+	Cell.decide(admitSurvivorsRun),
+	Cell.encode((outcome) => outcome),
+	Cell.write((outcome) => Effect.flatMap(Ref.get(runContext), (context) => {
+		if (context === void 0) return Effect.die("the survivors admission read must run before its write");
+		const { resolvedOptions, priorReportPath } = context;
+		return Result.match(outcome, {
+			onSuccess: (decision) => Match.value(decision).pipe(Match.tag("NoSurvivors", () => Effect.sync(() => emitEmptySurvivorsVerdict(stream, mode, resolvedOptions))), Match.tag("Admitted", (admitted) => {
+				const restricted = {
+					...resolvedOptions,
+					survivors: admitted.survivors,
+					mutate: survivorMutateSpans(admitted.survivors),
+					survivorsPriorReport: priorReportPath,
+					incremental: false
+				};
+				return Effect.promise(() => runMutationTest(restricted));
+			}), Match.orElse(() => Effect.die("unreachable admission decision variant"))),
+			onFailure: (rejection) => Effect.fail(rejection)
+		});
+	}))
+);
 /**
 * The `--survivors` request: re-test exactly the prior report's survivor set.
 * The survivors flag was parsed as a boolean; the admission decides between
 * running the survivors and the plain pipeline. The chain's order is carried by
 * the description's phase types; the run's resolved context cell is created
 * here, beside the description it feeds.
+*
+* Two failures reach the caller, and they are not the same thing. A rejection is the
+* decision's own outcome — the run was inspected and refused. A `SchemaError` is a prior
+* report that was present and did not decode, which stops the chain before any decision
+* is made; it is in this signature because the phase types put it there, not because the
+* admission chose it.
 */
 function runSurvivorsAdmission(runMutationTest, stream, mode, cliOptions) {
 	return Effect.gen(function* () {
@@ -934,22 +1054,47 @@ function priorReportPathOf(resolved) {
 	return typeof configured === "string" ? configured : DEFAULT_SURVIVORS_PRIOR_REPORT;
 }
 /**
-* A report is usable only when it parses and carries a `files` dictionary; a
-* missing, unreadable or misshapen report is the `no-report` rejection.
+* Reads the prior report without validating it. Absence and malformation are different
+* outcomes and the caller must be able to tell them apart: an absent report is the
+* `no-report` rejection the decider states, while a present-but-malformed one is a decode
+* failure that stops the run. Text that is not JSON is reported as found, carrying the
+* text itself, so the codec refuses it and names what it got.
 */
-function isMutationTestResultShape(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	return "files" in value && typeof value.files === "object" && value.files !== null && !Array.isArray(value.files);
-}
 function readPriorReport(priorReportPath) {
+	let text;
 	try {
-		const raw = readFileSync(priorReportPath, "utf-8");
-		const parsed = JSON.parse(raw);
-		return isMutationTestResultShape(parsed) ? parsed : void 0;
+		text = readFileSync(priorReportPath, "utf-8");
 	} catch {
-		return;
+		return {
+			found: false,
+			raw: void 0
+		};
+	}
+	try {
+		return {
+			found: true,
+			raw: JSON.parse(text)
+		};
+	} catch {
+		return {
+			found: true,
+			raw: text
+		};
 	}
 }
+/**
+* The relative file names a report claims, read structurally rather than through the
+* codec because the current sources must be hashed before the report is decoded — the
+* read phase does the disk I/O, and the keys are what tell it which files to read. An
+* unrecognisable report yields no keys and is refused a phase later by the codec.
+*/
+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);
+}
 function readSourceFile(file) {
 	try {
 		return readFileSync(file, "utf-8");
@@ -958,15 +1103,13 @@ function readSourceFile(file) {
 	}
 }
 /**
-* The per-file content hashes of the current sources, keyed by the relative
-* file names the prior report uses — the current side of the admission
-* comparison (`admitSurvivorsRun` hashes the prior side from the sources the
-* report embeds).
+* The per-file content hashes of the current sources, keyed by the relative file names
+* the prior report uses — the current side of the admission comparison. The prior side is
+* hashed from the sources the report embeds, in the decode phase.
 */
-function sourceContentHashesOf(priorReport) {
+function currentSourceHashesFor(files) {
 	const hashes = {};
-	if (priorReport === void 0) return hashes;
-	for (const file of Object.keys(priorReport.files)) hashes[file] = sourceContentHash(readSourceFile(file), hashContent);
+	for (const file of files) hashes[file] = sourceContentHash(readSourceFile(file), hashContent);
 	return hashes;
 }
 /**
@@ -1145,10 +1288,16 @@ function carriesConfigError(cause) {
 /**
 * Classifies a failed run for the finalizer: usage/parse failures
 * (`CliError` — except a bare help request, which exits 0), rejected
-* survivors runs (`SurvivorsRejection`) and a rejected config (`ConfigError`)
-* all exit 2, all other failures exit 1 (the framework's default). A
-* successful run exits 0; the verdict gates (U5) then resolve the final
-* classed code.
+* survivors runs (`SurvivorsRejection`), an unreadable prior report
+* (`S.SchemaError`) and a rejected config (`ConfigError`) all exit 2, all
+* other failures exit 1 (the framework's default). A successful run exits 0;
+* the verdict gates (U5) then resolve the final classed code.
+*
+* The report parse failure shares the survivors class deliberately. It is not a
+* verdict — the decider never sees the report — but the operator's answer is the
+* same class of answer as a rejection: the input you named cannot be used. Letting
+* it fall through to 1 would make an unusable `--survivors` input indistinguishable
+* from a crash.
 */
 function resolveCliExitCode(exit) {
 	if (Exit.isSuccess(exit)) return 0;
@@ -1159,6 +1308,7 @@ function resolveCliExitCode(exit) {
 		if (S.is(CliError.ShowHelp)(value)) return value.errors.length > 0 ? 2 : 0;
 		if (CliError.isCliError(value)) return 2;
 		if (S.is(SurvivorsRejection)(value)) return SURVIVORS_REJECT_EXIT_CLASS;
+		if (value instanceof S.SchemaError) return SURVIVORS_REJECT_EXIT_CLASS;
 	}
 	if (carriesConfigError(exit.cause)) return ExitClass.ConfigError;
 	return 1;
@@ -1254,10 +1404,11 @@ const optional = (option) => Flag.optional(option);
 /**
 * Commander left an omitted flag out of the parsed options; `deepMerge` treats
 * `undefined` as absent but an explicit `false` would override a config-file
-* `true`. The framework's boolean defaults to `false` when absent, so map that
-* back to `undefined` (KTD4).
+* `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) => value ? true : void 0;
+const absentWhenFalse = (value) => Option.isSome(value) && value.value ? true : void 0;
 const LOG_LEVELS = [
 	"fatal",
 	"error",
@@ -1285,15 +1436,15 @@ function setLogLevel(target, key, value) {
 }
 const runOptions = {
 	ignorePatterns: Flag.string("ignorePatterns").pipe(Flag.withDescription("A comma separated list of patterns used for specifying which files need to be ignored. This should only be used in cases where you experience a slow Stryker startup, because too many (or too large) files are copied to the sandbox that are not needed to run the tests. For example, image or movie directories. Note: This option will have NO effect when using the `--inPlace` option. The directories `node_modules`, `.git` and some others are always ignored. Example: `--ignorePatterns dist`. These patterns are ALWAYS ignored: [`node_modules`, `.git`, `/reports`, `*.tsbuildinfo`, `/stryker.log`, `.stryker-tmp`]. Because Stryker always ignores these, you should rarely have to adjust the `ignorePatterns` setting at all. This is useful to speed up Stryker by reducing the size of the sandbox directory which has a positive effect on performance."), Flag.map(splitOnComma), optional),
-	ignoreStatic: Flag.map(Flag.boolean("ignoreStatic"), absentWhenFalse).pipe(Flag.withDescription("Ignore static mutants. Static mutants are mutants which are only executed during the loading of a file.")),
-	incremental: Flag.map(Flag.boolean("incremental"), absentWhenFalse).pipe(Flag.withDescription("Enable 'incremental mode'. Stryker will store results in a file and use that file to speed up the next --incremental run")),
-	allowEmpty: Flag.map(Flag.boolean("allowEmpty"), absentWhenFalse).pipe(Flag.withDescription("Allows stryker to exit without any errors in cases where no tests are found")),
+	ignoreStatic: Flag.map(optional(Flag.boolean("ignoreStatic")), absentWhenFalse).pipe(Flag.withDescription("Ignore static mutants. Static mutants are mutants which are only executed during the loading of a file.")),
+	incremental: Flag.map(optional(Flag.boolean("incremental")), absentWhenFalse).pipe(Flag.withDescription("Enable 'incremental mode'. Stryker will store results in a file and use that file to speed up the next --incremental run")),
+	allowEmpty: Flag.map(optional(Flag.boolean("allowEmpty")), absentWhenFalse).pipe(Flag.withDescription("Allows stryker to exit without any errors in cases where no tests are found")),
 	incrementalFile: Flag.string("incrementalFile").pipe(Flag.withDescription("Specify the file to use for incremental mode."), optional),
-	force: Flag.map(Flag.boolean("force"), absentWhenFalse).pipe(Flag.withDescription("Run all mutants, even if --incremental is provided and an incremental file exists. Can be used to force a rebuild of the incremental file.")),
+	force: Flag.map(optional(Flag.boolean("force")), absentWhenFalse).pipe(Flag.withDescription("Run all mutants, even if --incremental is provided and an incremental file exists. Can be used to force a rebuild of the incremental file.")),
 	mutate: Flag.string("mutate").pipe(Flag.withAlias("m"), Flag.withDescription("With `mutate` you configure the subset of files or just one specific file to be mutated. These should be your _production code files_, and definitely not your test files. (Whereas with `ignorePatterns` you prevent non-relevant files from being copied to the sandbox directory in the first place)\nThe default will try to guess your production code files based on sane defaults. It reads like this:\n- Include all js-like files inside the `src` or `lib` dir\n- Except files inside `__tests__` directories and file names ending with `test` or `spec`.\nIf the defaults are not sufficient for you, for example in a angular project you might want to **exclude** not only the `*.spec.ts` files but other files too, just like the default already does.\nIt is possible to override the defaults by: - supplying one or more [glob patterns](https://github.com/isaacs/minimatch) to include (e.g. `src/**/*.js`) - or one or more comma separated glob patterns preceded with `!` to exclude (e.g. `!src/**/*.spec.js`) - or both (e.g. `src/**/*.js,!src/**/*.spec.js`).\nNote: Stryker will use [minimatch](https://github.com/isaacs/minimatch) for parsing these patterns, see minimatch for the exact syntax."), Flag.map(splitOnComma), optional),
 	testFiles: Flag.string("testFiles").pipe(Flag.withAlias("t"), Flag.withDescription("With `testFiles` you can limit which test files are executed during mutation testing. When specified, only tests from these files will be run. This allows you to verify that a module's dedicated unit tests can kill all its mutants independently."), Flag.map(splitOnComma), optional),
 	buildCommand: Flag.string("buildCommand").pipe(Flag.withAlias("b"), Flag.withDescription("Configure a build command to run after mutating the code, but before mutants are tested. This is generally used to transpile your code before testing. Only configure this if your test runner doesn't take care of this already and you're not using just-in-time transpiler like `babel/register` or `ts-node`."), optional),
-	dryRunOnly: Flag.map(Flag.boolean("dryRunOnly"), absentWhenFalse).pipe(Flag.withDescription("Execute the initial test run only, without doing actual mutation testing. Doing a dry run only can be used to test that StrykerJS can run your test setup, for example, in CI pipelines.")),
+	dryRunOnly: Flag.map(optional(Flag.boolean("dryRunOnly")), absentWhenFalse).pipe(Flag.withDescription("Execute the initial test run only, without doing actual mutation testing. Doing a dry run only can be used to test that StrykerJS can run your test setup, for example, in CI pipelines.")),
 	checkers: Flag.string("checkers").pipe(Flag.withDescription("A comma separated list of checkers to use, for example --checkers typescript"), Flag.map(splitOnComma), optional),
 	checkerNodeArgs: Flag.string("checkerNodeArgs").pipe(Flag.withDescription("A list of node args to be passed to checker child processes. Split on spaces (commander characterization): `--checkerNodeArgs \"--inspect-brk --trace-warnings\"`."), Flag.map(splitOnSpace), optional),
 	coverageAnalysis: Flag.choice("coverageAnalysis", [
@@ -1311,21 +1462,21 @@ const runOptions = {
 	dryRunTimeoutMinutes: Flag.float("dryRunTimeoutMinutes").pipe(Flag.withDescription("Configure an absolute timeout for the initial test run. (It can take a while.)"), optional),
 	maxConcurrentTestRunners: Flag.integer("maxConcurrentTestRunners").pipe(Flag.withDescription("Set the number of max concurrent test runner to spawn (default: cpuCount)"), optional),
 	concurrency: Flag.string("concurrency").pipe(Flag.withAlias("c"), Flag.withDescription("Set the concurrency of workers. Stryker will always run checkers and test runners in parallel by creating worker processes (default: cpuCount - 1)"), Flag.map(parseConcurrency), optional),
-	disableBail: Flag.map(Flag.boolean("disableBail"), absentWhenFalse).pipe(Flag.withDescription("Force the test runner to keep running tests, even when a mutant is already killed.")),
+	disableBail: Flag.map(optional(Flag.boolean("disableBail")), absentWhenFalse).pipe(Flag.withDescription("Force the test runner to keep running tests, even when a mutant is already killed.")),
 	maxTestRunnerReuse: Flag.integer("maxTestRunnerReuse").pipe(Flag.withDescription("Restart each test runner worker process after `n` runs. Not recommended unless you are experiencing memory leaks that you are unable to resolve. Configuring `0` here means infinite reuse."), optional),
 	logLevel: Flag.choice("logLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the console. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${defaultOptions.logLevel}"`), optional),
 	fileLogLevel: Flag.choice("fileLogLevel", LOG_LEVELS).pipe(Flag.withDescription(`Set the log level for the "stryker.log" file. Possible values: fatal, error, warn, info, debug, trace and off. Default is "${defaultOptions.fileLogLevel}"`), optional),
-	inPlace: Flag.map(Flag.boolean("inPlace"), absentWhenFalse).pipe(Flag.withDescription("Determines whether or not Stryker should mutate your files in place. Note: mutating your files in place is generally not needed for mutation testing, unless you have a dependency in your project that is really dependent on the file locations (like \"app-root-path\" for example).\nWhen `true`, Stryker will override your files, but it will keep a copy of the originals in the temp directory (using `tempDirName`) and it will place the originals back after it is done. Also with `true` the `ignorePatterns` has no effect any more.\nWhen `false` (default) Stryker will work in the copy of your code inside the temp directory.")),
+	inPlace: Flag.map(optional(Flag.boolean("inPlace")), absentWhenFalse).pipe(Flag.withDescription("Determines whether or not Stryker should mutate your files in place. Note: mutating your files in place is generally not needed for mutation testing, unless you have a dependency in your project that is really dependent on the file locations (like \"app-root-path\" for example).\nWhen `true`, Stryker will override your files, but it will keep a copy of the originals in the temp directory (using `tempDirName`) and it will place the originals back after it is done. Also with `true` the `ignorePatterns` has no effect any more.\nWhen `false` (default) Stryker will work in the copy of your code inside the temp directory.")),
 	tempDirName: Flag.string("tempDirName").pipe(Flag.withDescription("Set the name of the directory that is used by Stryker as a working directory. This directory will be cleaned after a successful run"), optional),
 	cleanTempDir: Flag.string("cleanTempDir").pipe(Flag.withDescription(`Choose whether or not to clean the temp dir (which is "${defaultOptions.tempDirName}" inside the current working directory by default) after a run.\n- false: Never delete the temp dir;\n- true: Delete the tmp dir after a successful run;\n- always: Always delete the temp dir, regardless of whether the run was successful.`), Flag.map(parseCleanDirOption), optional),
-	survivors: Flag.map(Flag.boolean("survivors"), absentWhenFalse).pipe(Flag.withDescription("Re-run only the mutants that survived a previous run. Admits against the previous run's mutation report (the `survivorsPriorReport` config option, default `reports/mutation-report.json`) and re-tests exactly the survivor set. Exits 2 with a remediation naming a full run when the report is missing, drifted, or the configuration changed; exits 0 with a null score when the report has no survivors."))
+	survivors: Flag.map(optional(Flag.boolean("survivors")), absentWhenFalse).pipe(Flag.withDescription("Re-run only the mutants that survived a previous run. Admits against the previous run's mutation report (the `survivorsPriorReport` config option, default `reports/mutation-report.json`) and re-tests exactly the survivor set. Exits 2 with a remediation naming a full run when the report is missing, drifted, or the configuration changed; exits 0 with a null score when the report has no survivors."))
 };
 const runArgs = { configFile: Argument.optional(Argument.string("configFile")) };
 const runConfig = {
 	...runOptions,
 	...runArgs
 };
-const rootConfig = { llms: Flag.map(Flag.boolean("llms"), absentWhenFalse).pipe(Flag.withDescription("Print the agent-facing command manifest as one JSON object on stdout: every option, alias, kind, default, allowed value set and description, plus the subcommands and positional arguments, walked from the command descriptors.")) };
+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.")) };
 function unwrap(value) {
 	if (Option.isOption(value)) return Option.match(value, {
 		onNone: () => void 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-cli",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -14,15 +14,15 @@
     "dist"
   ],
   "dependencies": {
-    "@effect/platform-node": "^4.0.0-rc.108",
-    "@effect/platform-node-shared": "^4.0.0-rc.108",
-    "@stryker-mutator/util": "^9.6.1",
-    "effect": "4.0.0-rc.108",
+    "@effect/platform-node": "^4.0.0-rc.111",
+    "@effect/platform-node-shared": "^4.0.0-rc.111",
+    "effect": "4.0.0-rc.111",
     "semver": "^7.7.0",
-    "@systemfsoftware/stryker-js-mutation-report": "^1.2.7",
-    "@systemfsoftware/effect-cell-types": "^3.0.0",
-    "@systemfsoftware/stryker-js-mutation-run": "^3.0.0",
-    "@systemfsoftware/stryker-js-plugin-api": "^2.0.0"
+    "@systemfsoftware/stryker-js-plugin-api": "^2.1.0",
+    "@systemfsoftware/stryker-js-mutation-run": "^4.0.0",
+    "@systemfsoftware/stryker-js-mutation-report": "^1.2.8",
+    "@systemfsoftware/stryker-js-util": "^0.1.0",
+    "@systemfsoftware/effect-cell-types": "^4.0.0"
   },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
@@ -35,15 +35,15 @@
     "tsdown": "^0.22.14",
     "vite-tsconfig-paths": "^6.1.1",
     "vitest": "^4.1.10",
-    "@systemfsoftware/effect-gherkin-spec": "^2.0.0",
-    "@systemfsoftware/effect-schema-law": "^0.8.0",
-    "@systemfsoftware/oxlint-plugin-cell-vocabulary": "^1.2.0",
-    "@systemfsoftware/effect-schema-vite": "^1.5.3",
+    "@systemfsoftware/effect-gherkin-spec": "^2.0.1",
+    "@systemfsoftware/effect-schema-law": "^0.9.0",
     "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/effect-schema-vite": "^1.5.4",
     "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/oxlint-plugin-effect-entrypoint": "^1.0.4",
+    "@systemfsoftware/oxlint-plugin-effect-entrypoint": "^1.0.5",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/oxlint-plugin-test-placement": "^3.0.0"
+    "@systemfsoftware/oxlint-plugin-test-placement": "^3.1.0",
+    "@systemfsoftware/oxlint-plugin-cell-vocabulary": "^1.2.1"
   },
   "engines": {
     "node": ">=20.0.0"