@systemfsoftware/stryker-js 13.1.0 → 15.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js",
-  "version": "13.1.0",
+  "version": "15.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -23,20 +23,20 @@
     "node": ">=24.13.1"
   },
   "dependencies": {
-    "@effect/opentelemetry": "4.0.0-rc.117",
-    "@effect/platform-node": "4.0.0-rc.117",
-    "@effect/platform-node-shared": "4.0.0-rc.117",
+    "@effect/opentelemetry": "^4.0.0",
+    "@effect/platform-node": "^4.0.0",
+    "@effect/platform-node-shared": "^4.0.0",
     "@noble/hashes": "^2",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.222.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
     "@opentelemetry/sdk-metrics": "^2.11.0",
     "@opentelemetry/sdk-trace-base": "^2.2.0",
-    "@systemfsoftware/effect-cell-types": "^11.0.0",
-    "@systemfsoftware/stryker-js-vm-runner": "npm:@systemfsoftware/stryker-js-vitest-runner@^8.0.1"
+    "@systemfsoftware/effect-cell-types": "^12.0.0",
+    "@systemfsoftware/stryker-js-vm-runner": "npm:@systemfsoftware/stryker-js-vitest-runner@^8.0.3"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.117"
+    "effect": "^4.0.0"
   },
   "devDependencies": {
     "@effect/tsgo": "^0.45.0",
@@ -44,18 +44,17 @@
     "@oxc-parser/binding-wasm32-wasi": "^0.150.0",
     "@std/jsonc": "npm:@jsr/std__jsonc@^1",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/differential-spec": "^0.6.0",
-    "@systemfsoftware/effect-gherkin-spec": "^6.0.0",
-    "@systemfsoftware/effect-schema-law": "^4.0.0",
-    "@systemfsoftware/effect-schema-vite": "^2.2.6",
-    "@systemfsoftware/oxlint-config-recommended": "^3.2.0",
+    "@systemfsoftware/differential-spec": "^1.0.0",
+    "@systemfsoftware/effect-gherkin-spec": "^7.0.0",
+    "@systemfsoftware/effect-schema-law": "^5.0.0",
+    "@systemfsoftware/oxlint-config-recommended": "^4.0.0",
     "@systemfsoftware/stryker-ignorer-effect-schema-declarations": "latest",
     "@systemfsoftware/stryker-ignorer-in-source-vitest-block": "latest",
     "@systemfsoftware/stryker-js": "latest",
     "@systemfsoftware/stryker-js-typescript-checker": "latest",
     "@systemfsoftware/stryker-js-vitest-runner": "latest",
     "@systemfsoftware/tsconfig": "^2.0.1",
-    "@systemfsoftware/vitest": "^0.2.0",
+    "@systemfsoftware/vitest": "^1.0.0",
     "@types/node": "^24",
     "@vitest/browser-playwright": "^5",
     "@vitest/coverage-v8": "^5",
@@ -73,11 +72,12 @@
     "vitest": "^5",
     "@systemfsoftware/stryker-framework-interface": "^0.0.0",
     "@systemfsoftware/stryker-ignorer-interface": "^0.1.1",
-    "@systemfsoftware/stryker-js-html-reporter": "^5.0.4",
     "@systemfsoftware/stryker-config": "^0.1.0",
-    "@systemfsoftware/stryker-js-instrumenter": "^10.0.1",
-    "@systemfsoftware/stryker-js-plugin-interface": "^10.0.1",
-    "@systemfsoftware/stryker-js-plugin-runtime": "^6.0.4",
+    "@systemfsoftware/stryker-js-cli-contract": "^0.2.0",
+    "@systemfsoftware/stryker-js-instrumenter": "^12.0.0",
+    "@systemfsoftware/stryker-js-html-reporter": "^6.0.0",
+    "@systemfsoftware/stryker-js-plugin-interface": "^12.0.0",
+    "@systemfsoftware/stryker-js-plugin-runtime": "^7.0.0",
     "@systemfsoftware/tsdown-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0"
   },

package/dist/Run.schema-BwLLAYqu.d.mts

@@ -1,325 +0,0 @@
-import { a as mod_d_exports$5, i as mod_d_exports$4, r as mod_d_exports$3 } from "./index-Ptvmn934.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 RunId: S.brand<S.String, "RunId">;
-type RunId = typeof RunId.Type;
-declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
-  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"]>;
-}>, {}>;
-declare class RunStarted extends RunStarted_base {}
-declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
-  readonly phase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
-  readonly elapsedMs: S.Finite;
-}>, {}>;
-declare class PhaseEntered extends PhaseEntered_base {}
-declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
-  readonly total: S.Int;
-}>, {}>;
-declare class PlanKnown extends PlanKnown_base {}
-/**
- * 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.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 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 VerdictMutant: S.Struct<{
-  readonly id: S.brand<S.String, "MutantId">;
-  readonly file: S.String;
-  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 status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-}>;
-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.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.declare<{
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
-  }, {
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
-  }>;
-  readonly reportFile: S.NullOr<S.String>;
-  readonly counts: typeof mod_d_exports$4.Metrics;
-  readonly mutants: S.$Array<S.Struct<{
-    readonly id: S.brand<S.String, "MutantId">;
-    readonly file: S.String;
-    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 status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-  }>>;
-}>, {}>;
-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 RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
-  readonly schemaVersion: S.Literal<"1.1">;
-  readonly code: S.Int;
-  readonly error: S.String;
-  readonly remediation: S.String;
-  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.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, 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;
-type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
-declare const RunDecodeError_base: S.Class<RunDecodeError, S.TaggedStruct<"RunDecodeError", {
-  readonly message: S.String;
-}>, import("effect/Cause").YieldableError>;
-declare class RunDecodeError extends RunDecodeError_base {}
-declare const RunReadError_base: S.Class<RunReadError, S.TaggedStruct<"RunReadError", {
-  readonly message: S.String;
-}>, import("effect/Cause").YieldableError>;
-declare class RunReadError extends RunReadError_base {}
-declare const PlanMutationRunCommand_base: S.Class<PlanMutationRunCommand, S.TaggedStruct<"PlanMutationRunCommand", {
-  readonly configMutatePatterns: S.$Array<S.String>;
-  readonly configMutatorNames: S.$Array<S.String>;
-  readonly targetMutatePatterns: S.$Array<S.String>;
-  readonly availableMutators: S.$Array<S.String>;
-}>, {}>;
-declare class PlanMutationRunCommand extends PlanMutationRunCommand_base {}
-declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"MutationRunPlan", {
-  readonly mutatePatterns: S.$Array<S.String>;
-  readonly mutatorNames: S.$Array<S.String>;
-}>, {}>;
-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", {
-  readonly stage: S.Literals<readonly ["prepare", "instrument", "dryRun", "dryRunNoTests", "mutationTest"]>;
-  readonly reason: S.String;
-  readonly cause: S.optional<S.Defect>;
-  readonly command: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
-declare class StageError extends StageError_base {
-  readonly [TypeId]: "~stryker/mutation-run/StageError";
-  get exitClass(): mod_d_exports$3.ExitClass;
-  get message(): string;
-}
-declare const PrepareError_base: S.Class<PrepareError, S.TaggedStruct<"PrepareError", {
-  readonly stage: S.Literal<"prepare">;
-  readonly reason: S.String;
-}>, import("effect/Cause").YieldableError>;
-declare class PrepareError extends PrepareError_base {
-  get message(): string;
-}
-//#endregion
-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 };

package/dist/Run.schema-Cv2_Kup0.mjs

@@ -1,272 +0,0 @@
-import { a as Reporter_exports, d as Mutant_exports, i as Report_exports, r as Plugin_exports } from "./dist-CQ7r4AaH.mjs";
-import * as Match$1 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";
-	get message() {
-		return `Plugin "${this.descriptor}" was not found`;
-	}
-};
-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$1.value(this.command).pipe(Match$1.when(Match$1.nonEmptyString, (present) => `${failure} (command: ${present})`), Match$1.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 };