@systemfsoftware/stryker-js 10.2.0 → 11.0.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @systemfsoftware/stryker-js
 
+## 11.0.0
+
+### Patch Changes
+
+- A mutation run no longer stalls forever when a checker or test-runner worker stops answering its connection. Previously a request that was in flight when the worker's connection dropped kept waiting on the dead connection, freezing progress until the CI timeout killed the run. Such a request now fails with a typed connection error when its connection drops, and the worker is restarted per the existing crash policy. Only requests already sent on the dropped connection fail: the client still reconnects on its own, and requests made while it reconnects, including the first request to a worker that is still booting, wait for the connection instead of failing.
+
 ## 10.2.0
 
 ### Minor Changes

package/README.md

@@ -2,7 +2,7 @@
 
 The modern mutation testing framework for JavaScript and TypeScript.
 A ground-up, breaking-change fork of `@stryker-mutator/core` built with Effect 4:
-provides the `stryker` executable, in-memory V8 and isolated Vitest runners,
+provides the `stryker` executable, in-process `vm` and isolated Vitest runners,
 and the typed `./config` authoring surface.
 
 ## Install
@@ -24,14 +24,14 @@ pnpm add -D @systemfsoftware/stryker-js \
 Create `stryker.config.ts` in your project root:
 
 ```ts
-import { defineConfig } from '@systemfsoftware/stryker-js/config'
+import { StrykerConfig } from '@systemfsoftware/stryker-js/config'
 
-export default defineConfig({
+export default StrykerConfig.define({
   testRunner: 'vitest',
   checkers: ['typescript'],
   plugins: [
-    import.meta.resolve('@systemfsoftware/stryker-js-vitest-runner'),
-    import.meta.resolve('@systemfsoftware/stryker-js-typescript-checker'),
+    '@systemfsoftware/stryker-js-vitest-runner',
+    '@systemfsoftware/stryker-js-typescript-checker',
   ],
   mutate: [
     'src/**/*.ts',
@@ -54,14 +54,19 @@ pnpm exec stryker run
 
 ## Zero-Plugin Built-in Runners
 
+The `vm` runner is the default: with no `testRunner` and no `testFiles`
+configured, it discovers `*.test` / `*.spec` files itself and runs them. It loads
+your suites through your project's `vitest`, so `vitest` must be installed.
+Set `testFiles` explicitly, or pick one of the runners below, to take control.
+
 ### 1. Shell Command Runner (`testRunner: 'command'`)
 
 Execute any test suite without extra plugins:
 
 ```ts
-import { defineConfig } from '@systemfsoftware/stryker-js/config'
+import { StrykerConfig } from '@systemfsoftware/stryker-js/config'
 
-export default defineConfig({
+export default StrykerConfig.define({
   testRunner: 'command',
   commandRunner: {
     command: 'npm test',
@@ -70,14 +75,14 @@ export default defineConfig({
 })
 ```
 
-### 2. In-Memory V8 VM Runner (`testRunner: 'vm'`)
+### 2. In-Process `vm` Runner (`testRunner: 'vm'`)
 
-Run pure unit tests directly inside Node's native V8 VM with zero process spawning overhead:
+Runs Vitest suites in-process, in one worker thread per test runner, loading each test file as native ESM through Node's module hooks. No child process and no bundler step. Each file gets its own module state by default; your `vitest.config.*` (environment, setup files, globals, projects) is picked up through your project's `vitest` install. Vitest browser-mode suites are refused with an error naming `testRunner: 'vitest'`; pick the `vitest` runner for those.
 
 ```ts
-import { defineConfig } from '@systemfsoftware/stryker-js/config'
+import { StrykerConfig } from '@systemfsoftware/stryker-js/config'
 
-export default defineConfig({
+export default StrykerConfig.define({
   testRunner: 'vm',
   testFiles: ['test/**/*.test.ts'],
   mutate: ['src/**/*.ts', '!src/**/*.test.ts'],
@@ -86,34 +91,34 @@ export default defineConfig({
 
 ## Configuration API (`@systemfsoftware/stryker-js/config`)
 
-The `./config` subpath exports lightweight, inert TypeScript configuration helpers:
+The `./config` subpath exports the typed configuration authoring surface:
 
 ```ts
-import { defineConfig, mergeConfig } from '@systemfsoftware/stryker-js/config'
+import { StrykerConfig } from '@systemfsoftware/stryker-js/config'
 ```
 
-### `defineConfig(options | configFactory)`
+### `StrykerConfig.define(options | configFactory)`
 
 Identity function providing strict autocompletion and type checking without runtime dependencies. Can take a configuration object or a factory receiving `ConfigEnv`:
 
 ```ts
-export default defineConfig(({ isCi, command }) => ({
+export default StrykerConfig.define(({ isCi, command }) => ({
   testRunner: 'vitest',
-  plugins: [import.meta.resolve('@systemfsoftware/stryker-js-vitest-runner')],
+  plugins: ['@systemfsoftware/stryker-js-vitest-runner'],
   mutate: ['src/**/*.ts', '!src/**/*.test.ts'],
   concurrency: isCi ? 2 : 4,
 }))
 ```
 
-### `mergeConfig(base, overrides)`
+### `StrykerConfig.merge(base, overrides)`
 
 Deeply merges configuration presets. Keys in records merge recursively; scalar values and arrays in `overrides` completely replace base values:
 
 ```ts
-import { mergeConfig } from '@systemfsoftware/stryker-js/config'
+import { StrykerConfig } from '@systemfsoftware/stryker-js/config'
 import baseConfig from './stryker.base.config.ts'
 
-export default mergeConfig(baseConfig, {
+export default StrykerConfig.merge(baseConfig, {
   concurrency: 8,
   mutate: ['packages/core/src/**/*.ts'],
 })
@@ -147,12 +152,15 @@ pnpm exec stryker merge-reports --output reports/mutation/mutation.json "reports
 
 ```ts
 import { NodeRuntime } from '@effect/platform-node'
-import { strykerCell } from '@systemfsoftware/stryker-js'
-
-NodeRuntime.runMain(strykerCell({
-  mutate: ['src/**/*.ts'],
-  testRunner: 'command',
-}))
+import { Engine } from '@systemfsoftware/stryker-js'
+import * as Effect from 'effect/Effect'
+
+NodeRuntime.runMain(
+  Engine.strykerCell({
+    mutate: ['src/**/*.ts'],
+    testRunner: 'command',
+  }).pipe(Effect.provide(Engine.nodePlatformLayer)),
+)
 ```
 
 ### Vanilla Promise Interface (`./promises`)
@@ -175,7 +183,7 @@ console.log(`Mutation score: ${verdict.score}%`)
 | Subpath      | Description                                                        |
 | ------------ | ------------------------------------------------------------------ |
 | `.`          | Main entry point: `strykerCell`, runtime layers, and error schemas |
-| `./config`   | `defineConfig`, `mergeConfig`, and `StrykerConfig` typing          |
+| `./config`   | `StrykerConfig` authoring surface (`define`, `merge`)              |
 | `./promises` | `run()` wrapper returning standard JavaScript promises             |
 
 ## License

package/dist/Run.schema-B_qdjbe9.mjs

@@ -0,0 +1,226 @@
+import { d as Mutant_exports, i as Report_exports } from "./dist-ClUhPgb6.mjs";
+import * as Match from "effect/Match";
+import * as S from "effect/Schema";
+import { SchemaGetter, SchemaTransformation } from "effect";
+//#region src/run-event.schema.ts
+const RunPhase = S.Literals([
+	"prepare",
+	"instrument",
+	"dry-run",
+	"mutation-test"
+]);
+const OutputMode = S.Literals(["human", "machine"]);
+const ModeSignal = S.Literals([
+	"flag",
+	"env",
+	"tty",
+	"agent",
+	"tool"
+]);
+var RunStarted = class extends S.TaggedClass()("stream", {
+	schemaVersion: S.String,
+	runId: S.String,
+	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 }) {};
+var RunMutantTested = class extends S.TaggedClass()("mutant", {
+	id: S.String,
+	status: Mutant_exports.MutantStatusSchema,
+	file: S.String,
+	location: Mutant_exports.LocationSchema,
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	completed: Report_exports.NonNegativeInt,
+	total: Report_exports.NonNegativeInt
+}) {};
+var Heartbeat = class extends S.TaggedClass()("tick", {
+	elapsedMs: Report_exports.NonNegativeFinite,
+	completed: Report_exports.NonNegativeInt,
+	total: S.NullOr(Report_exports.NonNegativeInt)
+}) {};
+const VerdictThresholdsValuesSchema = S.Struct({
+	high: Report_exports.Percentage,
+	low: Report_exports.Percentage,
+	break: S.NullOr(Report_exports.Percentage)
+});
+const isVerdictThresholds = (value) => S.is(VerdictThresholdsValuesSchema)(value) && value.low <= value.high;
+/**
+* The pair is *built* ordered — a drawn pair is sorted — rather than drawn at
+* random and discarded until it happens to be ordered. The invariant lives on
+* the declaration because a filter over the pair cannot express `low <= high`
+* in the generation-constraint vocabulary, and only a declaration carries a
+* `toCodecArbitrary` derivation. The struct stays the wire side, so decoding
+* keeps its field paths.
+*/
+const OrderedVerdictThresholds = S.declare(isVerdictThresholds, {
+	message: "expected thresholds where low <= high",
+	toCodecArbitrary: () => S.link()(VerdictThresholdsValuesSchema, {
+		decode: SchemaGetter.transform(({ break: breaking, high, low }) => ({
+			break: breaking,
+			high: Math.max(high, low),
+			low: Math.min(high, low)
+		})),
+		encode: SchemaGetter.transform((thresholds) => thresholds)
+	})
+});
+const VerdictThresholds = VerdictThresholdsValuesSchema.pipe(S.decodeTo(OrderedVerdictThresholds, SchemaTransformation.passthrough()));
+const VerdictMutant = S.Struct({
+	id: S.String,
+	file: S.String,
+	location: Mutant_exports.LocationSchema,
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	status: Mutant_exports.MutantStatusSchema
+});
+var VerdictReached = class extends S.TaggedClass()("verdict", {
+	schemaVersion: S.String,
+	runId: S.String,
+	mode: OutputMode,
+	signal: ModeSignal,
+	score: S.NullOr(Report_exports.Percentage),
+	thresholds: VerdictThresholds,
+	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) }) {};
+const PluginFailureReason = S.Literals([
+	"PeerMissing",
+	"PeerVersionUnsupported",
+	"PeerUnrecognized",
+	"InvalidContribution",
+	"ImportFailed"
+]);
+var RunFailed = class extends S.TaggedClass()("error", {
+	schemaVersion: S.String,
+	code: S.Finite,
+	error: S.String,
+	remediation: S.String,
+	reason: S.NullOr(PluginFailureReason)
+}) {};
+var HelpRendered = class extends S.TaggedClass()("help", {
+	schemaVersion: S.String,
+	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: S.Finite
+});
+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
+}) {};
+//#endregion
+export { RunReadError as C, VerdictReached as D, SkippedReported as E, RunPhase as S, SkippedFileRow 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, 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 };

package/dist/{Run.schema-B-Pi3bCB.d.mts → Run.schema-CUpTIyrj.d.mts}

@@ -1,6 +1,6 @@
-import { C as Metrics, _ as ExitClass } from "./index-tt2EziOT.mjs";
+import { i as mod_d_exports$4, r as mod_d_exports$3 } from "./index-CMCCQdTd.mjs";
 import * as S from "effect/Schema";
-//#region src/RunEvent.schema.d.ts
+//#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"]>;
@@ -29,12 +29,12 @@ declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mut
   readonly file: S.String;
   readonly location: S.Struct<{
     readonly start: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
     readonly end: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
   }>;
   readonly mutator: S.String;
@@ -60,12 +60,12 @@ declare const VerdictMutant: S.Struct<{
   readonly file: S.String;
   readonly location: S.Struct<{
     readonly start: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
     readonly end: S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
+      readonly line: S.Int;
+      readonly column: S.Int;
     }>;
   }>;
   readonly mutator: S.String;
@@ -73,7 +73,7 @@ declare const VerdictMutant: S.Struct<{
   readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
 }>;
 type VerdictMutant = typeof VerdictMutant.Type;
-type VerdictCounts = Metrics;
+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;
@@ -94,18 +94,18 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
     readonly break: S.NullOr<S.Finite>;
   }>, never, never>;
   readonly reportFile: S.NullOr<S.String>;
-  readonly counts: typeof Metrics;
+  readonly counts: typeof mod_d_exports$4.Metrics;
   readonly mutants: S.$Array<S.Struct<{
     readonly id: S.String;
     readonly file: S.String;
     readonly location: S.Struct<{
       readonly start: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
+        readonly line: S.Int;
+        readonly column: S.Int;
       }>;
       readonly end: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
+        readonly line: S.Int;
+        readonly column: S.Int;
       }>;
     }>;
     readonly mutator: S.String;
@@ -114,11 +114,81 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
   }>>;
 }>, {}>;
 declare class VerdictReached extends VerdictReached_base {}
+declare const FrameworkContributionRow: S.Struct<{
+  readonly name: S.String;
+  readonly formatId: S.String;
+  readonly extensions: S.$Array<S.String>;
+}>;
+type FrameworkContributionRow = typeof FrameworkContributionRow.Type;
+declare const FrameworkModuleRow: S.Struct<{
+  readonly moduleName: S.String;
+  readonly contributions: S.$Array<S.Struct<{
+    readonly name: S.String;
+    readonly formatId: S.String;
+    readonly extensions: S.$Array<S.String>;
+  }>>;
+}>;
+type FrameworkModuleRow = typeof FrameworkModuleRow.Type;
+declare const FormatClaimShadowingRow: S.Struct<{
+  readonly extension: S.String;
+  readonly winner: S.String;
+  readonly loser: S.String;
+}>;
+type FormatClaimShadowingRow = typeof FormatClaimShadowingRow.Type;
+declare const PluginsReported_base: S.Class<PluginsReported, S.TaggedStruct<"plugins", {
+  readonly modules: S.$Array<S.Struct<{
+    readonly moduleName: S.String;
+    readonly contributions: S.$Array<S.Struct<{
+      readonly name: S.String;
+      readonly formatId: S.String;
+      readonly extensions: S.$Array<S.String>;
+    }>>;
+  }>>;
+  readonly shadowings: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly winner: S.String;
+    readonly loser: S.String;
+  }>>;
+}>, {}>;
+declare class PluginsReported extends PluginsReported_base {}
+declare const FormatRegistryRow: S.Struct<{
+  readonly extension: S.String;
+  readonly formatId: S.String;
+  readonly ownerModule: S.String;
+  readonly language: S.String;
+}>;
+type FormatRegistryRow = typeof FormatRegistryRow.Type;
+declare const FormatRegistryResolved_base: S.Class<FormatRegistryResolved, S.TaggedStruct<"formats", {
+  readonly rows: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly formatId: S.String;
+    readonly ownerModule: S.String;
+    readonly language: S.String;
+  }>>;
+}>, {}>;
+declare class FormatRegistryResolved extends FormatRegistryResolved_base {}
+declare const SkippedFileRow: S.Struct<{
+  readonly file: S.String;
+  readonly extension: S.String;
+  readonly reason: S.String;
+}>;
+type SkippedFileRow = typeof SkippedFileRow.Type;
+declare const SkippedReported_base: S.Class<SkippedReported, S.TaggedStruct<"skipped", {
+  readonly files: S.$Array<S.Struct<{
+    readonly file: S.String;
+    readonly extension: S.String;
+    readonly reason: S.String;
+  }>>;
+}>, {}>;
+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 error: S.String;
   readonly remediation: S.String;
+  readonly reason: S.NullOr<S.Literals<readonly ["PeerMissing", "PeerVersionUnsupported", "PeerUnrecognized", "InvalidContribution", "ImportFailed"]>>;
 }>, {}>;
 declare class RunFailed extends RunFailed_base {}
 declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
@@ -127,7 +197,9 @@ declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
   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 VerdictReached, typeof RunFailed, typeof HelpRendered]>;
+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]> & {
+  QUEUE_BOUND: number;
+};
 type RunEvent = typeof RunEvent.Type;
 type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
 declare const RunDecodeError_base: S.Class<RunDecodeError, S.TaggedStruct<"RunDecodeError", {
@@ -161,7 +233,7 @@ declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError",
 }>, import("effect/Cause").YieldableError>;
 declare class StageError extends StageError_base {
   readonly [TypeId]: "~stryker/mutation-run/StageError";
-  get exitClass(): ExitClass;
+  get exitClass(): mod_d_exports$3.ExitClass;
   get message(): string;
 }
 declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareError", {
@@ -170,4 +242,4 @@ declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareEr
 }>, import("effect/Cause").YieldableError>;
 declare class PrepareError extends PrepareError_base {}
 //#endregion
-export { VerdictThresholds as S, RunStarted as _, ModeSignal as a, VerdictMutant as b, PhaseEntered as c, RunDecodeError as d, RunEvent as f, RunReadError as g, RunPhase as h, HelpRendered as i, PlanKnown as l, RunMutantTested as m, StageError as n, MutationRunPlan as o, RunFailed as p, Heartbeat as r, OutputMode as s, PrepareError as t, PlanMutationRunCommand as u, RunTerminalEvent as v, VerdictReached as x, VerdictCounts as y };
+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 };