@systemfsoftware/stryker-js 12.1.0 → 13.0.0

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # @systemfsoftware/stryker-js
 
+## 13.0.0
+
+### Major Changes
+
+- A child process exit code is the POSIX status domain now: any value accepted as a `ChildExitCode` is an integer in `0..255`, and a value outside that range is refused. The out-of-memory exit codes are a named, exported domain instead of a private list, so classifying a worker exit depends on a declared value rather than a hidden one.
+
+- The engine's file matching, reporter names, CLI command list, ANSI colours, report stream file name and planned-mutant failures are each declared once. `FileMatcher` keeps only its pattern and hidden-file flag: it no longer carries a `matches` method.
+
+  - The removed `RelativeNormalizedFileName` is replaced by the engine's own normalization, and a report's stream file name is the literal the engine writes.
+  - `AnsiColor` is the type of the colour codes rather than a schema, and `CliCommandSchema` plus the reporter-name schemas name the command list and the reporter names.
+  - A mutant whose computed timeout is not a finite number now fails planning with the `MutantTimeoutNotFinite` failure naming that mutant.
+
+- Exit codes are one value: `Plugin.ExitCode`, an integer between 0 and 255. The machine stream's failure event, the command's run output, and the run conclusion all carry it, and a run conclusion's outcome is the closed set of run-outcome tags rather than free text.
+
+  `Plugin.ExitCodeFromClass` stays the single exit-class to baseline-code mapping; read a code through it instead of writing the number where an exit class has to become an exit code.
+
+- Mutant ids are decimal index strings. Every schema that carried a mutant id as a plain string now decodes `Mutant.MutantId` and refuses anything else: the mutation report and its mutant results, reporter events (`mutationTestingPlanReady` plans, `mutantTested`), the machine run stream (`mutant` and `verdict`), the survivors prior report, and the mutant coverage keys produced by test runners.
+
+  Mutant ids are minted only as the mutant's canonical non-negative decimal index (`Mutant.MutantId`), including in the instrumenter's planned mutants, placement sites, and checker answers. Consume the new `Mutant.MutantId` schema instead of assuming an arbitrary non-empty string; ids such as `constructor` or `__proto__` no longer decode.
+
+- A mutant's status is declared once, as the eight-value `Mutant.MutantStatus`, plus the named subsets a run partitions on: `Mutant.SurvivorStatus`, `Mutant.RememberedStatus`, `Mutant.EphemeralStatus`, and `Mutant.ActionableStatus`. Import the subset your decision matches instead of re-listing the statuses you accept.
+
+  Mutants are tagged structs now. A status reason decodes only together with a status, and the remembered-mutant and ignored-mutant rows carry the same narrowed status as the subset they were selected by.
+
+- The CLI no longer checks the Node version at startup or prints an `UnsupportedNodeVersion` message. `engines.node` (`>=24.13.1`) is the only statement of support: on an older Node the CLI crashes on the first Node 24 API it calls.
+
+- Human or machine output is declared once, as `OutputMode`, and the reason for that choice once, as `ModeSignal`. The run stream's start and verdict events, the resolved configuration environment, and the machine framer all decode those two schemas.
+
+  A caller that spelled a mode as a plain string union imports the schema's type instead; the duplicate literal lists are gone.
+
+- A plugin load failure is one tagged union. The machine stream's failure event now carries that union — the missing peer, the unsupported peer version, the unrecognized peer, the invalid contribution, or the import that failed — instead of a bare tag string, and a framework refusal's reason is the shared peer-failure subset of the same vocabulary.
+
+  A consumer that compared the failure reason to a string reads the union's tag or its fields instead.
+
+- A report-relative file name is one normalized value again: the canonical file-name brand whose decoder folds backslashes to forward slashes. The separate report file-name brands are gone, and the mutation report and mutation part names are schemas a consumer reads rather than strings it repeats.
+
+- The machine stream's tested-mutant event is one declaration now. `RunEvent.RunMutantTested` is a codec whose type is `Reporter.MutantTested` and whose encoded form is the stream's `{"_tag":"mutant"}` line, so the stream carries the domain event and the boundary renames its tag and fields. The emitted stdout bytes and their order are unchanged.
+
+  Two published names moved with it: `RunEvent.RunMutantTested` no longer constructs (`RunMutantTested.make` is gone; build a `Reporter.MutantTested` instead), and `RunEvent.MetricsResultFromReport.fromFiles` is replaced by the function `RunEvent.metricsResultFromFiles`.
+
+- Source locations are 1-based and validated end to end. `Mutant.Location`, `Mutant.Position`, `Mutant.Span`, `Mutant.OpenEndLocation`, `Mutant.ScriptOrigin`, and `Mutant.LineStarts` replace the former `LocationSchema`, `PositionSchema`, and `OpenEndLocationSchema`; a location whose end precedes its start, or a line or column below 1, no longer decodes.
+
+  - A mutant location always speaks the report contract, so a producer that minted 0-based coordinates or a bare number must switch to the new schemas.
+  - An embedded script's origin is a `ScriptOrigin` (1-based line plus a column shift), not a position.
+  - Incremental state from releases that stored the earlier column base is no longer matched: those mutants are re-tested, not reused, while the run rewrites the state.
+
+- Test identifiers are one value: `TestRunner.TestId`, a non-empty branded string carrying the runner's `file#test name` form. Test runner results, report test definitions, a mutant's killers and coverers, per-test hit records, and the test-contribution evaluation all speak that one type instead of bare strings.
+
+  Mint one with `TestRunner.TestId.make(...)` where a runner derives a test id; the machine stream and mutation report schemas brand the ids they decode.
+
+- Mutation score thresholds are declared once, as `Report.ThresholdsSchema`: `high`, `low`, and a `break` that is null when no breaking threshold is configured. The option file and the mutation report decode the same schema, and a pair whose `low` is above its `high` is refused with "a mutation score threshold pair has low at or below high".
+
+  The mutation report's thresholds now include `break`, so a consumer reads the breaking threshold from the report instead of recovering it from the embedded reporter configuration.
+
+### Patch Changes
+
+- The TypeScript checker describes a tsconfig document through the schema that declares the keys it interprets, so an override round-trips the document it was given, and the mutant it cannot describe to a checker carries the canonical file-name brand. The plugin contract, configurations, reports, and exit codes are unchanged.
+
+- Stages now run as cells over workflows, multi-item work runs as Effect streams, pools and worker transport use scoped Effect resources, and named operations are traced with Effect.fn. The Angular ignorer now declares @systemfsoftware/stryker-ignorer-kit as a runtime dependency.
+
+- A mutant whose test run exceeds the wall-clock timeout is now reported as `Timeout` (reason `wall-clock-timeout`) and the run continues with the remaining mutants. The hung test-runner worker is killed and replaced instead of aborting the whole run with exit code 4.
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js-vitest-runner@8.0.0
+
+## 12.1.1
+
+### Patch Changes
+
+- The `stryker.cli.run` trace span now records the failure text in its `stryker.run.error` attribute for every failed run. It was empty unless the run was interrupted, so a failed dry run, a failing checker, or a rejected argument left no reason in the exported trace.
+
 ## 12.1.0
 
 ### Minor Changes

package/dist/Run.schema-Bj7b_FMA.mjs

@@ -0,0 +1,269 @@
+import { a as Reporter_exports, d as Mutant_exports, i as Report_exports, r as Plugin_exports } from "./dist-BscHZmXN.mjs";
+import * as Match from "effect/Match";
+import * as S from "effect/Schema";
+import { Schema, SchemaGetter } from "effect";
+//#region src/output-mode.schema.ts
+const OutputMode = S.Literals(["human", "machine"]);
+const ModeSignal = S.Literals([
+	"flag",
+	"env",
+	"tty",
+	"agent",
+	"tool"
+]);
+S.Struct({
+	mode: OutputMode,
+	signal: ModeSignal,
+	stdoutIsTTY: S.Boolean
+});
+//#endregion
+//#region src/PluginsError.schema.ts
+var PluginNotFoundError = class extends Schema.TaggedError()("PluginNotFoundError", { descriptor: Schema.String }) {
+	exitClass = "ConfigError";
+};
+const PluginLoadFailureReason = Schema.Union([
+	Schema.TaggedStruct("PeerMissing", { peer: Schema.String }),
+	Schema.TaggedStruct("PeerVersionUnsupported", {
+		peer: Schema.String,
+		detail: Schema.String
+	}),
+	Schema.TaggedStruct("PeerUnrecognized", { peer: Schema.String }),
+	Schema.TaggedStruct("InvalidContribution", { detail: Schema.String }),
+	Schema.TaggedStruct("ImportFailed", { cause: Schema.Unknown })
+]);
+const PeerFailureTag = Schema.Literals([
+	"PeerMissing",
+	"PeerVersionUnsupported",
+	"PeerUnrecognized"
+]);
+const FAILURE_EXIT_CLASS = {
+	PeerMissing: "ConfigError",
+	PeerVersionUnsupported: "ConfigError",
+	PeerUnrecognized: "ConfigError",
+	InvalidContribution: "ConfigError",
+	ImportFailed: "InternalError"
+};
+var PluginLoadRefusedError = class extends Schema.TaggedError()("PluginLoadRefusedError", {
+	descriptor: Schema.String,
+	reason: PluginLoadFailureReason
+}) {
+	get exitClass() {
+		return FAILURE_EXIT_CLASS[this.reason._tag];
+	}
+	get message() {
+		return `Failed to load plugin "${this.descriptor}" (${this.reason._tag})`;
+	}
+};
+//#endregion
+//#region src/reporting/stream-version.schema.ts
+const StreamSchemaVersion = S.Literal("1.1");
+//#endregion
+//#region src/run-event.schema.ts
+const RunPhase = S.Literals([
+	"prepare",
+	"instrument",
+	"dry-run",
+	"mutation-test"
+]);
+const RunId = S.String.pipe(S.check(S.isPattern(/^[0-9A-HJKMNP-TV-Z]{26}$/)), S.brand("RunId"));
+var RunStarted = class extends S.TaggedClass()("stream", {
+	schemaVersion: StreamSchemaVersion,
+	runId: RunId,
+	mode: OutputMode,
+	signal: ModeSignal
+}) {};
+var PhaseEntered = class extends S.TaggedClass()("phase", {
+	phase: RunPhase,
+	elapsedMs: Report_exports.NonNegativeFinite
+}) {};
+var PlanKnown = class extends S.TaggedClass()("plan", { total: Report_exports.NonNegativeInt }) {};
+const RunMutantTested = S.TaggedStruct("mutant", {
+	id: S.String,
+	status: Mutant_exports.MutantStatusSchema,
+	file: S.String,
+	location: Mutant_exports.Location,
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	completed: Report_exports.NonNegativeInt,
+	total: Report_exports.NonNegativeInt
+}).pipe(S.decodeTo(Reporter_exports.MutantTested, {
+	decode: SchemaGetter.transform((line) => ({
+		_tag: "mutantTested",
+		id: line.id,
+		status: line.status,
+		fileName: line.file,
+		location: line.location,
+		mutatorName: line.mutator,
+		replacement: line.replacement,
+		completed: line.completed,
+		total: line.total
+	})),
+	encode: SchemaGetter.transform((tested) => ({
+		_tag: "mutant",
+		id: tested.id,
+		status: tested.status,
+		file: tested.fileName,
+		location: tested.location,
+		mutator: tested.mutatorName,
+		replacement: tested.replacement,
+		completed: tested.completed,
+		total: tested.total
+	}))
+}));
+var Heartbeat = class extends S.TaggedClass()("tick", {
+	elapsedMs: Report_exports.NonNegativeFinite,
+	completed: Report_exports.NonNegativeInt,
+	total: S.NullOr(Report_exports.NonNegativeInt)
+}) {};
+const VerdictMutant = S.Struct({
+	id: Mutant_exports.MutantId,
+	file: S.String,
+	location: Mutant_exports.Location,
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	status: Mutant_exports.MutantStatusSchema
+});
+var VerdictReached = class extends S.TaggedClass()("verdict", {
+	schemaVersion: StreamSchemaVersion,
+	runId: RunId,
+	mode: OutputMode,
+	signal: ModeSignal,
+	score: S.NullOr(Report_exports.Percentage),
+	thresholds: Report_exports.ThresholdsSchema,
+	reportFile: S.NullOr(S.String),
+	counts: Report_exports.Metrics,
+	mutants: S.Array(VerdictMutant)
+}) {};
+const FrameworkContributionRow = S.Struct({
+	name: S.String,
+	formatId: S.String,
+	extensions: S.Array(S.String)
+});
+const FrameworkModuleRow = S.Struct({
+	moduleName: S.String,
+	contributions: S.Array(FrameworkContributionRow)
+});
+const FormatClaimShadowingRow = S.Struct({
+	extension: S.String,
+	winner: S.String,
+	loser: S.String
+});
+var PluginsReported = class extends S.TaggedClass()("plugins", {
+	modules: S.Array(FrameworkModuleRow),
+	shadowings: S.Array(FormatClaimShadowingRow)
+}) {};
+const FormatRegistryRow = S.Struct({
+	extension: S.String,
+	formatId: S.String,
+	ownerModule: S.String,
+	language: S.String
+});
+var FormatRegistryResolved = class extends S.TaggedClass()("formats", { rows: S.Array(FormatRegistryRow) }) {};
+const SkippedFileRow = S.Struct({
+	file: S.String,
+	extension: S.String,
+	reason: S.String
+});
+var SkippedReported = class extends S.TaggedClass()("skipped", { files: S.Array(SkippedFileRow) }) {};
+var RunFailed = class extends S.TaggedClass()("error", {
+	schemaVersion: StreamSchemaVersion,
+	code: Plugin_exports.ExitCode,
+	error: S.String,
+	remediation: S.String,
+	reason: S.NullOr(PluginLoadFailureReason)
+}) {};
+var HelpRendered = class extends S.TaggedClass()("help", {
+	schemaVersion: StreamSchemaVersion,
+	code: S.Literals([0]),
+	help: S.String
+}) {};
+const RunEvent = Object.assign(S.Union([
+	RunStarted,
+	PhaseEntered,
+	PlanKnown,
+	RunMutantTested,
+	Heartbeat,
+	PluginsReported,
+	FormatRegistryResolved,
+	SkippedReported,
+	VerdictReached,
+	RunFailed,
+	HelpRendered
+]), { QUEUE_BOUND: 256 });
+S.TaggedClass()("RunCommand", {
+	cliOptionsJson: S.String,
+	targetMutatePatterns: S.Array(S.String)
+});
+S.TaggedClass()("RunOutput", {
+	verdictJson: S.String,
+	exitCode: Plugin_exports.ExitCode
+});
+var RunDecodeError = class extends S.TaggedError()("RunDecodeError", { message: S.String }) {};
+var RunReadError = class extends S.TaggedError()("RunReadError", { message: S.String }) {};
+S.TaggedError()("RunWriteError", { message: S.String });
+var PlanMutationRunCommand = class extends S.TaggedClass()("PlanMutationRunCommand", {
+	configMutatePatterns: S.Array(S.String),
+	configMutatorNames: S.Array(S.String),
+	targetMutatePatterns: S.Array(S.String),
+	availableMutators: S.Array(S.String)
+}) {};
+var MutationRunPlan = class extends S.TaggedClass()("MutationRunPlan", {
+	mutatePatterns: S.Array(S.String),
+	mutatorNames: S.Array(S.String)
+}) {};
+//#endregion
+//#region src/Run.schema.ts
+const TypeId = "~stryker/mutation-run/StageError";
+var StageError = class extends S.TaggedError(TypeId)("StageError", {
+	stage: S.Literals([
+		"prepare",
+		"instrument",
+		"dryRun",
+		"dryRunNoTests",
+		"mutationTest"
+	]),
+	reason: S.String,
+	cause: S.optional(S.Defect()),
+	command: S.optional(S.String)
+}) {
+	[TypeId] = TypeId;
+	get exitClass() {
+		return STAGE_PRESENTATION[this.stage].exitClass;
+	}
+	get message() {
+		const failure = `${STAGE_PRESENTATION[this.stage].label} failed: ${this.reason}`;
+		return Match.value(this.command).pipe(Match.when(Match.nonEmptyString, (present) => `${failure} (command: ${present})`), Match.orElse(() => failure));
+	}
+};
+const STAGE_PRESENTATION = {
+	prepare: {
+		label: "Prepare",
+		exitClass: "ConfigError"
+	},
+	instrument: {
+		label: "Instrument",
+		exitClass: "RuntimeError"
+	},
+	dryRun: {
+		label: "Dry run",
+		exitClass: "RuntimeError"
+	},
+	dryRunNoTests: {
+		label: "Dry run",
+		exitClass: "ConfigError"
+	},
+	mutationTest: {
+		label: "Mutation testing",
+		exitClass: "RuntimeError"
+	}
+};
+var PrepareError = class extends S.TaggedError()("PrepareError", {
+	stage: S.Literal("prepare"),
+	reason: S.String
+}) {
+	get message() {
+		return this.reason;
+	}
+};
+//#endregion
+export { PluginLoadRefusedError as A, SkippedFileRow as C, StreamSchemaVersion as D, VerdictReached as E, ModeSignal as M, OutputMode as N, PeerFailureTag as O, RunStarted as S, VerdictMutant as T, RunFailed as _, FormatRegistryRow as a, RunPhase as b, Heartbeat as c, PhaseEntered as d, PlanKnown as f, RunEvent as g, RunDecodeError as h, FormatRegistryResolved as i, PluginNotFoundError as j, PluginLoadFailureReason as k, HelpRendered as l, PluginsReported as m, StageError as n, FrameworkContributionRow as o, PlanMutationRunCommand as p, FormatClaimShadowingRow as r, FrameworkModuleRow as s, PrepareError as t, MutationRunPlan as u, RunId as v, SkippedReported as w, RunReadError as x, RunMutantTested as y };

package/dist/{Run.schema-BnUKGQjA.d.mts → Run.schema-BlvpjFjJ.d.mts}

@@ -1,15 +1,14 @@
-import { i as mod_d_exports$4, r as mod_d_exports$3 } from "./index-CKd1sAni.mjs";
+import { a as mod_d_exports$5, i as mod_d_exports$4, r as mod_d_exports$3 } from "./index-C09A80iv.mjs";
 import * as S from "effect/Schema";
+import { Schema } from "effect";
 //#region src/run-event.schema.d.ts
 declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
 type RunPhase = typeof RunPhase.Type;
-declare const OutputMode: S.Literals<readonly ["human", "machine"]>;
-type OutputMode = typeof OutputMode.Type;
-declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
-type ModeSignal = typeof ModeSignal.Type;
+declare const RunId: S.brand<S.String, "RunId">;
+type RunId = typeof RunId.Type;
 declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
-  readonly schemaVersion: S.String;
-  readonly runId: S.String;
+  readonly schemaVersion: S.Literal<"1.1">;
+  readonly runId: S.brand<S.String, "RunId">;
   readonly mode: S.Literals<readonly ["human", "machine"]>;
   readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
 }>, {}>;
@@ -23,50 +22,69 @@ declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
   readonly total: S.Int;
 }>, {}>;
 declare class PlanKnown extends PlanKnown_base {}
-declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
+/**
+ * The machine-stream line a tested mutant is published as. Its wire shape is a
+ * published contract: the `mutant` tag and the `file`/`mutator` keys must not
+ * change. The domain event it carries is `Reporter.MutantTested`, so the line is
+ * a codec at the boundary rather than a second declaration of the same event.
+ */
+interface RunMutantTested extends mod_d_exports$5.MutantTested {}
+declare const MutantTestedWireSchema: S.TaggedStruct<"mutant", {
   readonly id: S.String;
   readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
   readonly file: S.String;
-  readonly location: S.Struct<{
-    readonly start: S.Struct<{
-      readonly line: S.Int;
-      readonly column: S.Int;
-    }>;
-    readonly end: S.Struct<{
-      readonly line: S.Int;
-      readonly column: S.Int;
-    }>;
+  readonly location: S.declare<{
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  }, {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
   }>;
   readonly mutator: S.String;
   readonly replacement: S.NullOr<S.String>;
   readonly completed: S.Int;
   readonly total: S.Int;
-}>, {}>;
-declare class RunMutantTested extends RunMutantTested_base {}
+}>;
+declare const RunMutantTested: S.Codec<RunMutantTested, S.Schema.Type<typeof MutantTestedWireSchema>>;
 declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
   readonly elapsedMs: S.Finite;
   readonly completed: S.Int;
   readonly total: S.NullOr<S.Int>;
 }>, {}>;
 declare class Heartbeat extends Heartbeat_base {}
-declare const VerdictThresholdsValuesSchema: S.Struct<{
-  readonly high: S.Finite;
-  readonly low: S.Finite;
-  readonly break: S.NullOr<S.Finite>;
-}>;
-type VerdictThresholds = typeof VerdictThresholdsValuesSchema.Type;
 declare const VerdictMutant: S.Struct<{
-  readonly id: S.String;
+  readonly id: S.brand<S.String, "MutantId">;
   readonly file: S.String;
-  readonly location: S.Struct<{
-    readonly start: S.Struct<{
-      readonly line: S.Int;
-      readonly column: S.Int;
-    }>;
-    readonly end: S.Struct<{
-      readonly line: S.Int;
-      readonly column: S.Int;
-    }>;
+  readonly location: S.declare<{
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  }, {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
   }>;
   readonly mutator: S.String;
   readonly replacement: S.NullOr<S.String>;
@@ -75,12 +93,12 @@ declare const VerdictMutant: S.Struct<{
 type VerdictMutant = typeof VerdictMutant.Type;
 type VerdictCounts = mod_d_exports$4.Metrics;
 declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
-  readonly schemaVersion: S.String;
-  readonly runId: S.String;
+  readonly schemaVersion: S.Literal<"1.1">;
+  readonly runId: S.brand<S.String, "RunId">;
   readonly mode: S.Literals<readonly ["human", "machine"]>;
   readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
   readonly score: S.NullOr<S.Finite>;
-  readonly thresholds: S.decodeTo<S.declare<{
+  readonly thresholds: S.declare<{
     readonly high: number;
     readonly low: number;
     readonly break: number | null;
@@ -88,25 +106,30 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
     readonly high: number;
     readonly low: number;
     readonly break: number | null;
-  }>, S.Struct<{
-    readonly high: S.Finite;
-    readonly low: S.Finite;
-    readonly break: S.NullOr<S.Finite>;
-  }>, never, never>;
+  }>;
   readonly reportFile: S.NullOr<S.String>;
   readonly counts: typeof mod_d_exports$4.Metrics;
   readonly mutants: S.$Array<S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.String, "MutantId">;
     readonly file: S.String;
-    readonly location: S.Struct<{
-      readonly start: S.Struct<{
-        readonly line: S.Int;
-        readonly column: S.Int;
-      }>;
-      readonly end: S.Struct<{
-        readonly line: S.Int;
-        readonly column: S.Int;
-      }>;
+    readonly location: S.declare<{
+      readonly start: {
+        readonly line: number;
+        readonly column: number;
+      };
+      readonly end: {
+        readonly line: number;
+        readonly column: number;
+      };
+    }, {
+      readonly start: {
+        readonly line: number;
+        readonly column: number;
+      };
+      readonly end: {
+        readonly line: number;
+        readonly column: number;
+      };
     }>;
     readonly mutator: S.String;
     readonly replacement: S.NullOr<S.String>;
@@ -181,23 +204,51 @@ declare const SkippedReported_base: S.Class<SkippedReported, S.TaggedStruct<"ski
   }>>;
 }>, {}>;
 declare class SkippedReported extends SkippedReported_base {}
-declare const PluginFailureReason: S.Literals<readonly ["PeerMissing", "PeerVersionUnsupported", "PeerUnrecognized", "InvalidContribution", "ImportFailed"]>;
-type PluginFailureReason = typeof PluginFailureReason.Type;
 declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
-  readonly schemaVersion: S.String;
-  readonly code: S.Finite;
+  readonly schemaVersion: S.Literal<"1.1">;
+  readonly code: S.Int;
   readonly error: S.String;
   readonly remediation: S.String;
-  readonly reason: S.NullOr<S.Literals<readonly ["PeerMissing", "PeerVersionUnsupported", "PeerUnrecognized", "InvalidContribution", "ImportFailed"]>>;
+  readonly reason: S.NullOr<S.Union<readonly [S.TaggedStruct<"PeerMissing", {
+    readonly peer: S.String;
+  }>, S.TaggedStruct<"PeerVersionUnsupported", {
+    readonly peer: S.String;
+    readonly detail: S.String;
+  }>, S.TaggedStruct<"PeerUnrecognized", {
+    readonly peer: S.String;
+  }>, S.TaggedStruct<"InvalidContribution", {
+    readonly detail: S.String;
+  }>, S.TaggedStruct<"ImportFailed", {
+    readonly cause: S.Unknown;
+  }>]>>;
 }>, {}>;
 declare class RunFailed extends RunFailed_base {}
 declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
-  readonly schemaVersion: S.String;
+  readonly schemaVersion: S.Literal<"1.1">;
   readonly code: S.Literals<readonly [0]>;
   readonly help: S.String;
 }>, {}>;
 declare class HelpRendered extends HelpRendered_base {}
-declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTested, {
+  readonly _tag: "mutant";
+  readonly id: string;
+  readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
+  readonly file: string;
+  readonly location: {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  };
+  readonly mutator: string;
+  readonly replacement: string | null;
+  readonly completed: number;
+  readonly total: number;
+}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
   QUEUE_BOUND: number;
 };
 type RunEvent = typeof RunEvent.Type;
@@ -223,6 +274,33 @@ declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"Mut
 }>, {}>;
 declare class MutationRunPlan extends MutationRunPlan_base {}
 //#endregion
+//#region src/output-mode.schema.d.ts
+declare const OutputMode: S.Literals<readonly ["human", "machine"]>;
+type OutputMode = typeof OutputMode.Type;
+declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+type ModeSignal = typeof ModeSignal.Type;
+declare const ResolvedMode: S.Struct<{
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+  readonly stdoutIsTTY: S.Boolean;
+}>;
+type ResolvedMode = typeof ResolvedMode.Type;
+//#endregion
+//#region src/PluginsError.schema.d.ts
+declare const PluginLoadFailureReason: Schema.Union<readonly [Schema.TaggedStruct<"PeerMissing", {
+  readonly peer: Schema.String;
+}>, Schema.TaggedStruct<"PeerVersionUnsupported", {
+  readonly peer: Schema.String;
+  readonly detail: Schema.String;
+}>, Schema.TaggedStruct<"PeerUnrecognized", {
+  readonly peer: Schema.String;
+}>, Schema.TaggedStruct<"InvalidContribution", {
+  readonly detail: Schema.String;
+}>, Schema.TaggedStruct<"ImportFailed", {
+  readonly cause: Schema.Unknown;
+}>]>;
+type PluginLoadFailureReason = typeof PluginLoadFailureReason.Type;
+//#endregion
 //#region src/Run.schema.d.ts
 declare const TypeId: '~stryker/mutation-run/StageError';
 declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError", {
@@ -244,4 +322,4 @@ declare class PrepareError extends PrepareError_base {
   get message(): string;
 }
 //#endregion
-export { VerdictReached as A, RunReadError as C, SkippedReported as D, SkippedFileRow as E, VerdictCounts as O, RunPhase as S, RunTerminalEvent as T, PluginsReported as _, FormatRegistryRow as a, RunFailed as b, Heartbeat as c, MutationRunPlan as d, OutputMode as f, PluginFailureReason as g, PlanMutationRunCommand as h, FormatRegistryResolved as i, VerdictThresholds as j, VerdictMutant as k, HelpRendered as l, PlanKnown as m, StageError as n, FrameworkContributionRow as o, PhaseEntered as p, FormatClaimShadowingRow as r, FrameworkModuleRow as s, PrepareError as t, ModeSignal as u, RunDecodeError as v, RunStarted as w, RunMutantTested as x, RunEvent as y };
+export { VerdictCounts as A, RunMutantTested as C, RunTerminalEvent as D, RunStarted as E, VerdictReached as M, SkippedFileRow as O, RunId as S, RunReadError as T, PlanMutationRunCommand as _, OutputMode as a, RunEvent as b, FormatRegistryResolved as c, FrameworkModuleRow as d, Heartbeat as f, PlanKnown as g, PhaseEntered as h, ModeSignal as i, VerdictMutant as j, SkippedReported as k, FormatRegistryRow as l, MutationRunPlan as m, StageError as n, ResolvedMode as o, HelpRendered as p, PluginLoadFailureReason as r, FormatClaimShadowingRow as s, PrepareError as t, FrameworkContributionRow as u, PluginsReported as v, RunPhase as w, RunFailed as x, RunDecodeError as y };