@systemfsoftware/stryker-js-plugin-interface 7.0.0 → 7.1.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @systemfsoftware/stryker-js-plugin-interface
 
+## 7.1.1
+
+### Patch Changes
+
+- Effect moves to `4.0.0-rc.116` (with `@effect/platform-node`, `@effect/platform-node-shared`, `@effect/vitest` and `@effect/opentelemetry` on the same release), the `@systemfsoftware/*` toolchain pins move to their current releases, and `vitest` 5 with `oxc-parser` 0.150 come along. Both worker bundles (`stryker-js-typescript-checker`, `stryker-js-vitest-runner`) now inline their whole runtime rather than resolving `effect`, `@effect/*` and the sibling packages from the host's tree, so a worker runs on its own copy of the effect that built it; the project's `typescript` and `vitest` remain the only imports beside Node builtins. The filter-level `arbitrary.candidate` generators that the thresholds schemas carried are gone: v4 no longer reads them, so thresholds still reject a `low` above `high` and the property tests generate the pair from the schema again. Log calls inside `Effect.catch*` handlers moved to `Effect.tapError`/`Effect.tapCause` at the same level and message. `@systemfsoftware/stryker-ignorer-interface` re-exports the 0.150 AST, where `FormalParameterRest.decorators` is now `Array<Decorator>`.
+
+## 7.1.0
+
+### Minor Changes
+
+- A checker that fails now fails mutation testing with that checker's cause, instead of crashing with an empty error. The TypeScript checker type-checks each mutant, so compile errors appear in the report. Verdict counts are non-negative integers; `Metrics` is a class you can build from mutant statuses; a threshold `low` may not exceed `high`.
+
 ## 7.0.0
 
 ### Major Changes

package/dist/index.d.mts

@@ -192,6 +192,8 @@ export declare type Dependencies = typeof DependenciesSchema.Type;
 
 export declare const DependenciesSchema: S.$Record<S.String, S.String>;
 
+export declare const DetectedStatus: S.Union<readonly [S.Literal<"Killed">, S.Literal<"Timeout">]>;
+
 export declare class DryRunCompleted extends DryRunCompleted_base {}
 
 declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dryRunCompleted", {
@@ -202,7 +204,7 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
     readonly capabilities: S.Struct<{
         readonly reloadEnvironment: S.Boolean;
     }>;
-    readonly testCount: S.Finite;
+    readonly testCount: S.Int;
     readonly tests: S.$Array<S.Union<readonly [S.Struct<{
         readonly id: S.String;
         readonly name: S.String;
@@ -370,7 +372,7 @@ export declare const FileResultDictionarySchema: S.$Record<S.String, S.Struct<{
         readonly static: S.optional<S.Boolean>;
         readonly coveredBy: S.optional<S.$Array<S.String>>;
         readonly killedBy: S.optional<S.$Array<S.String>>;
-        readonly testsCompleted: S.optional<S.Finite>;
+        readonly testsCompleted: S.optional<S.Int>;
         readonly duration: S.optional<S.Finite>;
     }>>;
 }>>;
@@ -398,7 +400,7 @@ export declare const FileResultSchema: S.Struct<{
         readonly static: S.optional<S.Boolean>;
         readonly coveredBy: S.optional<S.$Array<S.String>>;
         readonly killedBy: S.optional<S.$Array<S.String>>;
-        readonly testsCompleted: S.optional<S.Finite>;
+        readonly testsCompleted: S.optional<S.Int>;
         readonly duration: S.optional<S.Finite>;
     }>>;
 }>;
@@ -417,6 +419,8 @@ export declare const FrameworkInformationSchema: S.Struct<{
     readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
 }>;
 
+export declare const InvalidStatus: S.Union<readonly [S.Literal<"CompileError">, S.Literal<"RuntimeError">]>;
+
 export declare const isCustomTestRunner: (value: TestRunnerConfig) => value is TestRunnerCustomConfig;
 
 export declare interface KilledMutantRunResult {
@@ -443,7 +447,30 @@ declare type LogLevel = typeof LogLevel.Type;
 export { LogLevel }
 export { LogLevel as LogLevelType }
 
-export declare type Metrics = typeof MetricsSchema.Type;
+export declare class Metrics extends Metrics_base {
+    get totalDetected(): number;
+    get totalUndetected(): number;
+    get totalCovered(): number;
+    get totalValid(): number;
+    get totalInvalid(): number;
+    get totalMutants(): number;
+    get mutationScore(): number;
+    get mutationScoreBasedOnCoveredCode(): number;
+    static fromMutants(mutants: readonly {
+        readonly status: string;
+    }[]): Metrics;
+}
+
+declare const Metrics_base: S.Class<Metrics, S.Struct<{
+    readonly pending: S.Int;
+    readonly killed: S.Int;
+    readonly timeout: S.Int;
+    readonly survived: S.Int;
+    readonly noCoverage: S.Int;
+    readonly runtimeErrors: S.Int;
+    readonly compileErrors: S.Int;
+    readonly ignored: S.Int;
+}>, {}>;
 
 export declare interface MetricsResult {
     readonly name: string;
@@ -451,47 +478,15 @@ export declare interface MetricsResult {
     readonly childResults: readonly MetricsResult[];
 }
 
-export declare const MetricsResultSchema: S.Struct<{
-    readonly name: S.String;
-    readonly metrics: S.Struct<{
-        readonly pending: S.Finite;
-        readonly killed: S.Finite;
-        readonly timeout: S.Finite;
-        readonly survived: S.Finite;
-        readonly noCoverage: S.Finite;
-        readonly runtimeErrors: S.Finite;
-        readonly compileErrors: S.Finite;
-        readonly ignored: S.Finite;
-        readonly totalDetected: S.Finite;
-        readonly totalUndetected: S.Finite;
-        readonly totalInvalid: S.Finite;
-        readonly totalValid: S.Finite;
-        readonly totalMutants: S.Finite;
-        readonly totalCovered: S.Finite;
-        readonly mutationScore: S.Finite;
-        readonly mutationScoreBasedOnCoveredCode: S.Finite;
-    }>;
-    readonly childResults: S.$Array<S.suspend<S.Codec<MetricsResult, MetricsResult, never, never>>>;
-}>;
+export declare interface MetricsResultEncoded {
+    readonly name: string;
+    readonly metrics: typeof Metrics.Encoded;
+    readonly childResults: readonly MetricsResultEncoded[];
+}
 
-export declare const MetricsSchema: S.Struct<{
-    readonly pending: S.Finite;
-    readonly killed: S.Finite;
-    readonly timeout: S.Finite;
-    readonly survived: S.Finite;
-    readonly noCoverage: S.Finite;
-    readonly runtimeErrors: S.Finite;
-    readonly compileErrors: S.Finite;
-    readonly ignored: S.Finite;
-    readonly totalDetected: S.Finite;
-    readonly totalUndetected: S.Finite;
-    readonly totalInvalid: S.Finite;
-    readonly totalValid: S.Finite;
-    readonly totalMutants: S.Finite;
-    readonly totalCovered: S.Finite;
-    readonly mutationScore: S.Finite;
-    readonly mutationScoreBasedOnCoveredCode: S.Finite;
-}>;
+export declare const MetricsResultSchema: S.Codec<MetricsResult, MetricsResultEncoded>;
+
+export declare const MetricsSchema: typeof Metrics;
 
 export { MutantActivation }
 
@@ -526,7 +521,7 @@ export declare const MutantResultSchema: S.Struct<{
     readonly static: S.optional<S.Boolean>;
     readonly coveredBy: S.optional<S.$Array<S.String>>;
     readonly killedBy: S.optional<S.$Array<S.String>>;
-    readonly testsCompleted: S.optional<S.Finite>;
+    readonly testsCompleted: S.optional<S.Int>;
     readonly duration: S.optional<S.Finite>;
 }>;
 
@@ -578,22 +573,30 @@ declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTes
     }>;
     readonly mutator: S.String;
     readonly replacement: S.NullOr<S.String>;
-    readonly completed: S.Finite;
-    readonly total: S.Finite;
+    readonly completed: S.Int;
+    readonly total: S.Int;
 }>, {}>;
 
 export declare type MutationScoreThresholds = typeof MutationScoreThresholdsSchema.Type;
 
-export declare const MutationScoreThresholdsSchema: S.Struct<{
+export declare const MutationScoreThresholdsSchema: S.decodeTo<S.declare<{
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+}, {
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+}>, S.Struct<{
     readonly high: S.withDecodingDefaultKey<S.Finite, never>;
     readonly low: S.withDecodingDefaultKey<S.Finite, never>;
     readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
-}>;
+}>, never, never>;
 
 export declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
 
 declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
-    readonly total: S.Finite;
+    readonly total: S.Int;
     readonly plans: S.$Array<S.Struct<{
         readonly mutantId: S.String;
         readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
@@ -630,14 +633,20 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
                 readonly static: S.optional<S.Boolean>;
                 readonly coveredBy: S.optional<S.$Array<S.String>>;
                 readonly killedBy: S.optional<S.$Array<S.String>>;
-                readonly testsCompleted: S.optional<S.Finite>;
+                readonly testsCompleted: S.optional<S.Int>;
                 readonly duration: S.optional<S.Finite>;
             }>>;
         }>>;
-        readonly thresholds: S.Struct<{
+        readonly thresholds: S.decodeTo<S.declare<{
+            readonly high: number;
+            readonly low: number;
+        }, {
+            readonly high: number;
+            readonly low: number;
+        }>, S.Struct<{
             readonly high: S.Finite;
             readonly low: S.Finite;
-        }>;
+        }>, never, never>;
         readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
         readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
             readonly source: S.optional<S.String>;
@@ -667,28 +676,7 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
             readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
         }>>;
     }>;
-    readonly metrics: S.Struct<{
-        readonly name: S.String;
-        readonly metrics: S.Struct<{
-            readonly pending: S.Finite;
-            readonly killed: S.Finite;
-            readonly timeout: S.Finite;
-            readonly survived: S.Finite;
-            readonly noCoverage: S.Finite;
-            readonly runtimeErrors: S.Finite;
-            readonly compileErrors: S.Finite;
-            readonly ignored: S.Finite;
-            readonly totalDetected: S.Finite;
-            readonly totalUndetected: S.Finite;
-            readonly totalInvalid: S.Finite;
-            readonly totalValid: S.Finite;
-            readonly totalMutants: S.Finite;
-            readonly totalCovered: S.Finite;
-            readonly mutationScore: S.Finite;
-            readonly mutationScoreBasedOnCoveredCode: S.Finite;
-        }>;
-        readonly childResults: S.$Array<S.suspend<S.Codec<MetricsResult, MetricsResult, never, never>>>;
-    }>;
+    readonly metrics: S.Codec<MetricsResult, MetricsResultEncoded, never, never>;
 }>, {}>;
 
 export declare type MutationTestResult = typeof MutationTestResultSchema.Type;
@@ -718,14 +706,20 @@ export declare const MutationTestResultSchema: S.Struct<{
             readonly static: S.optional<S.Boolean>;
             readonly coveredBy: S.optional<S.$Array<S.String>>;
             readonly killedBy: S.optional<S.$Array<S.String>>;
-            readonly testsCompleted: S.optional<S.Finite>;
+            readonly testsCompleted: S.optional<S.Int>;
             readonly duration: S.optional<S.Finite>;
         }>>;
     }>>;
-    readonly thresholds: S.Struct<{
+    readonly thresholds: S.decodeTo<S.declare<{
+        readonly high: number;
+        readonly low: number;
+    }, {
+        readonly high: number;
+        readonly low: number;
+    }>, S.Struct<{
         readonly high: S.Finite;
         readonly low: S.Finite;
-    }>;
+    }>, never, never>;
     readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
     readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
         readonly source: S.optional<S.String>;
@@ -756,6 +750,10 @@ export declare const MutationTestResultSchema: S.Struct<{
     }>>;
 }>;
 
+export declare const NonNegativeFinite: S.Finite;
+
+export declare const NonNegativeInt: S.Int;
+
 export declare type OnlyObject<T> = Exclude<T, Primitive>;
 
 export { OpenEndLocation }
@@ -780,6 +778,8 @@ export declare interface PassedCheckResult {
     readonly status: 'passed';
 }
 
+export declare const Percentage: S.Finite;
+
 export declare const PluginFileUrl: S.String;
 
 export { Position }
@@ -969,11 +969,19 @@ export declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
         readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
     }>]>, never>;
     readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
+    readonly thresholds: S.withDecodingDefaultKey<S.decodeTo<S.declare<{
+        readonly high: number;
+        readonly low: number;
+        readonly break: number | null;
+    }, {
+        readonly high: number;
+        readonly low: number;
+        readonly break: number | null;
+    }>, S.Struct<{
         readonly high: S.withDecodingDefaultKey<S.Finite, never>;
         readonly low: S.withDecodingDefaultKey<S.Finite, never>;
         readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
-    }>, never>;
+    }>, never, never>, never>;
     readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
     readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
     readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
@@ -1187,10 +1195,16 @@ export declare type TestStatus = typeof TestStatus.Type;
 
 export declare type Thresholds = typeof ThresholdsSchema.Type;
 
-export declare const ThresholdsSchema: S.Struct<{
+export declare const ThresholdsSchema: S.decodeTo<S.declare<{
+    readonly high: number;
+    readonly low: number;
+}, {
+    readonly high: number;
+    readonly low: number;
+}>, S.Struct<{
     readonly high: S.Finite;
     readonly low: S.Finite;
-}>;
+}>, never, never>;
 
 export declare interface TimeoutDryRunResult {
     readonly status: 'timeout';
@@ -1228,6 +1242,10 @@ export declare const TRACEPARENT_HEADER = "traceparent";
 
 export declare const TRACESTATE_HEADER = "tracestate";
 
+export declare const UndetectedStatus: S.Union<readonly [S.Literal<"Survived">, S.Literal<"NoCoverage">]>;
+
+export declare const UntestedStatus: S.Union<readonly [S.Literal<"Ignored">, S.Literal<"Pending">]>;
+
 export declare const WorkerEntryUrl: S.String;
 
 export declare type WorkerEntryUrl = typeof WorkerEntryUrl.Type;

package/dist/index.mjs

@@ -3,8 +3,8 @@ import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Rpc from "effect/unstable/rpc/Rpc";
 import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import { Effect, SchemaGetter, SchemaTransformation } from "effect";
 import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
-import { Effect } from "effect";
 import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 //#region src/Checker.schema.ts
@@ -71,27 +71,87 @@ const EXIT_CODE = {
 };
 //#endregion
 //#region src/Metrics.schema.ts
-const MetricsSchema = S.Struct({
-	pending: S.Finite,
-	killed: S.Finite,
-	timeout: S.Finite,
-	survived: S.Finite,
-	noCoverage: S.Finite,
-	runtimeErrors: S.Finite,
-	compileErrors: S.Finite,
-	ignored: S.Finite,
-	totalDetected: S.Finite,
-	totalUndetected: S.Finite,
-	totalInvalid: S.Finite,
-	totalValid: S.Finite,
-	totalMutants: S.Finite,
-	totalCovered: S.Finite,
-	mutationScore: S.Finite,
-	mutationScoreBasedOnCoveredCode: S.Finite
+const DetectedStatus = S.Union([S.Literal("Killed"), S.Literal("Timeout")]);
+const UndetectedStatus = S.Union([S.Literal("Survived"), S.Literal("NoCoverage")]);
+const InvalidStatus = S.Union([S.Literal("CompileError"), S.Literal("RuntimeError")]);
+const UntestedStatus = S.Union([S.Literal("Ignored"), S.Literal("Pending")]);
+const NonNegativeInt = S.Int.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
+const NonNegativeFinite = S.Finite.pipe(S.check(S.isGreaterThanOrEqualTo(0)));
+const Percentage = S.Finite.pipe(S.check(S.isBetween({
+	minimum: 0,
+	maximum: 100
+})));
+var Metrics = class Metrics extends S.Class("Metrics")({
+	pending: NonNegativeInt,
+	killed: NonNegativeInt,
+	timeout: NonNegativeInt,
+	survived: NonNegativeInt,
+	noCoverage: NonNegativeInt,
+	runtimeErrors: NonNegativeInt,
+	compileErrors: NonNegativeInt,
+	ignored: NonNegativeInt
+}) {
+	get totalDetected() {
+		return this.timeout + this.killed;
+	}
+	get totalUndetected() {
+		return this.survived + this.noCoverage;
+	}
+	get totalCovered() {
+		return this.totalDetected + this.survived;
+	}
+	get totalValid() {
+		return this.totalUndetected + this.totalDetected;
+	}
+	get totalInvalid() {
+		return this.runtimeErrors + this.compileErrors;
+	}
+	get totalMutants() {
+		return this.totalValid + this.totalInvalid + this.ignored + this.pending;
+	}
+	get mutationScore() {
+		if (this.totalValid === 0) return NaN;
+		return Math.min(100, Math.max(0, this.totalDetected / this.totalValid * 100));
+	}
+	get mutationScoreBasedOnCoveredCode() {
+		if (this.totalCovered === 0) return NaN;
+		return Math.min(100, Math.max(0, this.totalDetected / this.totalCovered * 100));
+	}
+	static fromMutants(mutants) {
+		const counts = emptyMetricCounts();
+		for (const mutant of mutants) incrementMetricStatus(counts, mutant.status);
+		return Metrics.make(counts);
+	}
+};
+const emptyMetricCounts = () => ({
+	pending: 0,
+	killed: 0,
+	timeout: 0,
+	survived: 0,
+	noCoverage: 0,
+	runtimeErrors: 0,
+	compileErrors: 0,
+	ignored: 0
 });
+const METRIC_STATUS_KEYS = {
+	Pending: "pending",
+	Killed: "killed",
+	Timeout: "timeout",
+	Survived: "survived",
+	NoCoverage: "noCoverage",
+	RuntimeError: "runtimeErrors",
+	CompileError: "compileErrors",
+	Ignored: "ignored"
+};
+const incrementMetricStatus = (counts, status) => {
+	const key = METRIC_STATUS_KEYS[status];
+	if (key === void 0) return;
+	counts[key] += 1;
+};
+const MetricsSchema = Metrics;
 const MetricsResultSchema = S.Struct({
 	name: S.String,
-	metrics: MetricsSchema,
+	metrics: Metrics,
 	childResults: S.Array(S.suspend(() => MetricsResultSchema))
 }).annotate({ identifier: "MetricsResult" });
 //#endregion
@@ -107,8 +167,8 @@ const MutantResultSchema = S.Struct({
 	static: S.optional(S.Boolean),
 	coveredBy: S.optional(S.Array(S.String)),
 	killedBy: S.optional(S.Array(S.String)),
-	testsCompleted: S.optional(S.Finite),
-	duration: S.optional(S.Finite)
+	testsCompleted: S.optional(NonNegativeInt),
+	duration: S.optional(NonNegativeFinite)
 });
 const FileResultSchema = S.Struct({
 	language: S.String,
@@ -126,10 +186,30 @@ const TestFileSchema = S.Struct({
 	tests: S.Array(TestDefinitionSchema)
 });
 const TestFileDefinitionDictionarySchema = S.Record(S.String, TestFileSchema);
-const ThresholdsSchema = S.Struct({
-	high: S.Finite,
-	low: S.Finite
+const ThresholdsValuesSchema = S.Struct({
+	high: Percentage,
+	low: Percentage
 });
+const isThresholds = (value) => S.is(ThresholdsValuesSchema)(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. `ThresholdsValuesSchema` stays the wire side, so
+* decoding keeps its field paths.
+*/
+const OrderedThresholds = S.declare(isThresholds, {
+	message: "expected thresholds where low <= high",
+	toCodecArbitrary: () => S.link()(ThresholdsValuesSchema, {
+		decode: SchemaGetter.transform(({ high, low }) => ({
+			high: Math.max(high, low),
+			low: Math.min(high, low)
+		})),
+		encode: SchemaGetter.transform((thresholds) => thresholds)
+	})
+});
+const ThresholdsSchema = ThresholdsValuesSchema.pipe(S.decodeTo(OrderedThresholds, SchemaTransformation.passthrough()));
 const BrandingInformationSchema = S.Struct({
 	homepageUrl: S.String,
 	imageUrl: S.optional(S.String)
@@ -261,24 +341,24 @@ const ReporterEventKind = S.Literals([
 	"mutationTestReportReady"
 ]);
 const RunTimingSchema = S.Struct({
-	net: S.Finite,
-	overhead: S.Finite
+	net: NonNegativeFinite,
+	overhead: NonNegativeFinite
 });
 const ReporterPlanKind = S.Literals(["EarlyResult", "Run"]);
 const ReporterPlanDescriptorSchema = S.Struct({
 	mutantId: S.String,
 	plan: ReporterPlanKind,
-	netTime: S.Finite,
+	netTime: NonNegativeFinite,
 	reloadEnvironment: S.Boolean
 });
 var DryRunCompleted = class extends S.TaggedClass()("dryRunCompleted", {
 	timing: RunTimingSchema,
 	capabilities: TestRunnerCapabilitiesSchema,
-	testCount: S.Finite,
+	testCount: NonNegativeInt,
 	tests: S.Array(TestResultSchema)
 }) {};
 var MutationTestingPlanReady = class extends S.TaggedClass()("mutationTestingPlanReady", {
-	total: S.Finite,
+	total: NonNegativeInt,
 	plans: S.Array(ReporterPlanDescriptorSchema)
 }) {};
 var MutantTested = class extends S.TaggedClass()("mutantTested", {
@@ -288,8 +368,8 @@ var MutantTested = class extends S.TaggedClass()("mutantTested", {
 	location: LocationSchema$1,
 	mutator: S.String,
 	replacement: S.NullOr(S.String),
-	completed: S.Finite,
-	total: S.Finite
+	completed: NonNegativeInt,
+	total: NonNegativeInt
 }) {};
 var MutationTestReportReady = class extends S.TaggedClass()("mutationTestReportReady", {
 	report: MutationTestResultSchema,
@@ -461,11 +541,6 @@ const PackageManager = S.Literals([
 	"yarn",
 	"pnpm"
 ]);
-/** 0–100 percentage used by the mutation-score thresholds. */
-const Percentage = S.Finite.pipe(S.check(S.isBetween({
-	minimum: 0,
-	maximum: 100
-})));
 const CommandRunnerOptionsSchema = openStruct({ command: defaulted(S.String, "npm test") });
 const ClearTextReporterOptions = openStruct({
 	allowColor: defaulted(S.Boolean, true),
@@ -479,11 +554,32 @@ const ClearTextReporterOptions = openStruct({
 });
 const HtmlReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.html") });
 const JsonReporterOptions = S.Struct({ fileName: defaulted(S.String, "reports/mutation/mutation.json") });
-const MutationScoreThresholdsSchema = S.Struct({
+const MutationScoreThresholdsValuesSchema = S.Struct({
 	high: defaulted(Percentage, 80),
 	low: defaulted(Percentage, 60),
 	break: defaulted(S.NullOr(Percentage), null)
 });
+const isMutationScoreThresholds = (value) => S.is(MutationScoreThresholdsValuesSchema)(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 member defaults and field paths.
+*/
+const OrderedMutationScoreThresholds = S.declare(isMutationScoreThresholds, {
+	message: "expected thresholds where low <= high",
+	toCodecArbitrary: () => S.link()(MutationScoreThresholdsValuesSchema, {
+		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 MutationScoreThresholdsSchema = MutationScoreThresholdsValuesSchema.pipe(S.decodeTo(OrderedMutationScoreThresholds, SchemaTransformation.passthrough()));
 const MutatorDescriptor = S.Struct({ excludedMutations: defaulted(S.Array(S.String), []) });
 const WarningOptions = openStruct({
 	unknownOptions: defaulted(S.Boolean, true),
@@ -708,4 +804,4 @@ const parseTraceparent = (value) => {
 };
 const TraceContextReference = Context.Reference("@systemfsoftware/stryker-js-plugin-interface/TraceContextReference", { defaultValue: () => Option.none() });
 //#endregion
-export { BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, BrandingInformationSchema, CheckResultSchema, CheckStatus, Checker, CheckerCheckResult, CheckerCustomConfigSchema, CheckerEntryConfigSchema, CheckerFailed, CheckerGroupResult, CheckerMutantWire, CheckerRequest, CheckerRpcs, CommandRunnerOptionsSchema, CoverageAnalysisMode, CoverageAnalysisSchema, DependenciesSchema, DryRunCompleted, DryRunOptionsSchema, DryRunResultSchema, DryRunStatus, EXIT_CODE, Evaluator, EvaluatorFailed, ExitClass, FileResultDictionarySchema, FileResultSchema, FrameworkInformationSchema, LocationSchema, LogLevel, MetricsResultSchema, MetricsSchema, MutantActivationSchema, MutantCoverageSchema, MutantResultSchema, MutantRunOptionsSchema, MutantRunResultSchema, MutantRunStatus, MutantStatusSchema, MutantTested, MutationScoreThresholdsSchema, MutationTestReportReady, MutationTestResultSchema, MutationTestingPlanReady, OpenEndLocationSchema, PackageManager, PluginFileUrl, PositionSchema, PropagatedTrace, RENDERED_OPTION_DEFAULTS, ReportType, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFailed, ReporterInitOptions, ReporterPlanDescriptorSchema, ReporterPlanKind, ReporterRpcs, RunTimingSchema, StrykerOptionsSchema, TRACEPARENT_HEADER, TRACESTATE_HEADER, TestDefinitionSchema, TestFileDefinitionDictionarySchema, TestFileSchema, TestResultSchema, TestRunner, TestRunnerCapabilitiesSchema, TestRunnerConfigSchema, TestRunnerCustomConfigSchema, TestRunnerDryRunRequest, TestRunnerFailed, TestRunnerMutantRunRequest, TestRunnerRpcs, TestStatus, ThresholdsSchema, TraceContextMiddleware, TraceContextReference, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawnSchema, formatTraceparent, isCustomTestRunner, parseTraceparent, propertyPath, strykerCoreSchema, strykerReportBugUrl, testFilesProvided, toMutantRunResult };
+export { BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, BrandingInformationSchema, CheckResultSchema, CheckStatus, Checker, CheckerCheckResult, CheckerCustomConfigSchema, CheckerEntryConfigSchema, CheckerFailed, CheckerGroupResult, CheckerMutantWire, CheckerRequest, CheckerRpcs, CommandRunnerOptionsSchema, CoverageAnalysisMode, CoverageAnalysisSchema, DependenciesSchema, DetectedStatus, DryRunCompleted, DryRunOptionsSchema, DryRunResultSchema, DryRunStatus, EXIT_CODE, Evaluator, EvaluatorFailed, ExitClass, FileResultDictionarySchema, FileResultSchema, FrameworkInformationSchema, InvalidStatus, LocationSchema, LogLevel, Metrics, MetricsResultSchema, MetricsSchema, MutantActivationSchema, MutantCoverageSchema, MutantResultSchema, MutantRunOptionsSchema, MutantRunResultSchema, MutantRunStatus, MutantStatusSchema, MutantTested, MutationScoreThresholdsSchema, MutationTestReportReady, MutationTestResultSchema, MutationTestingPlanReady, NonNegativeFinite, NonNegativeInt, OpenEndLocationSchema, PackageManager, Percentage, PluginFileUrl, PositionSchema, PropagatedTrace, RENDERED_OPTION_DEFAULTS, ReportType, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFailed, ReporterInitOptions, ReporterPlanDescriptorSchema, ReporterPlanKind, ReporterRpcs, RunTimingSchema, StrykerOptionsSchema, TRACEPARENT_HEADER, TRACESTATE_HEADER, TestDefinitionSchema, TestFileDefinitionDictionarySchema, TestFileSchema, TestResultSchema, TestRunner, TestRunnerCapabilitiesSchema, TestRunnerConfigSchema, TestRunnerCustomConfigSchema, TestRunnerDryRunRequest, TestRunnerFailed, TestRunnerMutantRunRequest, TestRunnerRpcs, TestStatus, ThresholdsSchema, TraceContextMiddleware, TraceContextReference, UndetectedStatus, UntestedStatus, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawnSchema, formatTraceparent, isCustomTestRunner, parseTraceparent, propertyPath, strykerCoreSchema, strykerReportBugUrl, testFilesProvided, toMutantRunResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-plugin-interface",
-  "version": "7.0.0",
+  "version": "7.1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -18,26 +18,26 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.116",
     "@systemfsoftware/stryker-js-instrumenter": "^8.0.0"
   },
   "devDependencies": {
     "@effect/tsgo": "^0.45.0",
     "@microsoft/api-extractor": "^7",
-    "@systemfsoftware/all": "^2",
-    "@systemfsoftware/arethetypeswrong-cli": "^4",
-    "@systemfsoftware/effect-schema-law": "^2",
-    "@systemfsoftware/effect-schema-vite": "^2",
-    "@systemfsoftware/tsconfig": "^1",
+    "@systemfsoftware/all": "^2.1.1",
+    "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
+    "@systemfsoftware/effect-schema-law": "^2.2.0",
+    "@systemfsoftware/effect-schema-vite": "^2.2.0",
+    "@systemfsoftware/tsconfig": "^1.3.5",
     "@types/node": "^24",
     "oxlint": "^1",
     "oxlint-tsgolint": "^7",
     "rimraf": "^6.1.3",
     "tsdown": "^0.23.0",
     "typescript": "^7",
-    "vitest": "^4",
-    "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/tsdown-config": "^0.1.0"
+    "vitest": "^5",
+    "@systemfsoftware/tsdown-config": "^0.1.0",
+    "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "publishConfig": {
     "access": "public",