@systemfsoftware/stryker-js 12.1.1 → 13.0.0

package/dist/{index-B8dqrKV1.d.mts → index-C09A80iv.d.mts}

@@ -1,8 +1,9 @@
 import { Handle, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as Option$1 from "effect/Option";
-import "effect/Result";
+import * as Result from "effect/Result";
 import * as S from "effect/Schema";
 import * as Effect$1 from "effect/Effect";
+import * as Arr from "effect/Array";
 import * as Context from "effect/Context";
 import { Schema } from "effect";
 import * as Rpc from "effect/unstable/rpc/Rpc";
@@ -2670,54 +2671,73 @@ declare interface YieldExpression$1 extends Span$1 {
 }
 //#endregion
 //#region src/Location.schema.d.ts
-/**
- * File coordinates in the mutation-testing-report-schema contract: both line
- * and column are 1-based. The first line of a file is line 1, and the first
- * character of a line is column 1. Slicing a source line by one of these
- * positions uses `line - 1` for the line index and `column - 1` for the
- * character offset.
- */
-declare const PositionSchema: S.Struct<{
+declare const Offset: S.Int;
+type Offset = typeof Offset.Type;
+/** A 1-based line: the first line of a file is line 1. */
+declare const Line: S.Int;
+type Line = typeof Line.Type;
+/** A 1-based column: the first character of a line is column 1. */
+declare const Column: S.Int;
+type Column = typeof Column.Type;
+declare const Position: S.Struct<{
   readonly line: S.Int;
   readonly column: S.Int;
 }>;
-type Position = typeof PositionSchema.Type;
-declare const LocationSchema: 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;
-  }>;
+type Position = typeof Position.Type;
+declare const 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;
+  };
 }>;
-type Location = typeof LocationSchema.Type;
-declare const OpenEndLocationSchema: S.Struct<{
-  readonly start: S.Struct<{
-    readonly line: S.Int;
-    readonly column: S.Int;
-  }>;
-  readonly end: S.optional<S.Struct<{
-    readonly line: S.Int;
-    readonly column: S.Int;
-  }>>;
+type Location = typeof Location.Type;
+declare const OpenEndLocation: S.declare<{
+  readonly start: {
+    readonly line: number;
+    readonly column: number;
+  };
+  readonly end?: {
+    readonly line: number;
+    readonly column: number;
+  } | undefined;
+}, {
+  readonly start: {
+    readonly line: number;
+    readonly column: number;
+  };
+  readonly end?: {
+    readonly line: number;
+    readonly column: number;
+  } | undefined;
 }>;
-type OpenEndLocation = typeof OpenEndLocationSchema.Type;
-/**
- * A mutant's `location` already speaks the report contract (1-based line and
- * column), so the report's location is that location unchanged.
- */
-declare const ReportLocationFromMutant: 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;
-  }>;
+type OpenEndLocation = typeof OpenEndLocation.Type;
+declare const Span: S.declare<{
+  readonly start: number;
+  readonly end: number;
+}, {
+  readonly start: number;
+  readonly end: number;
+}>;
+type Span = typeof Span.Type;
+declare const ScriptOrigin: S.Struct<{
+  readonly line: S.Int;
+  readonly columnShift: S.Int;
 }>;
+type ScriptOrigin = typeof ScriptOrigin.Type;
+type LineStarts = Arr.NonEmptyReadonlyArray<Offset>;
 //#endregion
 //#region src/Syntax.schema.d.ts
 declare const AstFormat: S.Literals<readonly ["js", "ts", "tsx"]>;
@@ -2735,7 +2755,7 @@ interface BaseAst {
   originFileName: string;
   rawContent: string;
   root: Program;
-  offset?: Position;
+  offset?: ScriptOrigin;
 }
 interface EmbeddedAst {
   format: 'embedded';
@@ -2768,29 +2788,189 @@ interface TsxAst extends BaseAst {
 type ScriptAst = JSAst | TSAst | TsxAst;
 type Ast = JSAst | TSAst | TsxAst | EmbeddedAst;
 //#endregion
+//#region src/Instrument.schema.d.ts
+declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
+  readonly message: S.String;
+  readonly cause: S.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class InstrumentError extends InstrumentError_base {
+  get message(): string;
+}
+declare const MutateDescriptionSchema: S.Union<readonly [S.Boolean, S.$Array<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;
+  };
+}>>]>;
+type MutateDescription = typeof MutateDescriptionSchema.Type;
+interface FileDescription {
+  readonly mutate: MutateDescription;
+}
+type FileDescriptions = Record<string, FileDescription>;
+declare const InstrumenterOptionsSchema: S.Struct<{
+  readonly excludedMutations: S.$Array<S.String>;
+  readonly ignorers: S.$Array<S.Unknown>;
+  readonly noHeader: S.optional<S.Boolean>;
+  readonly optInMutations: S.optional<S.$Array<S.String>>;
+}>;
+type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
+declare const InstrumentFileSkip_base: S.Class<InstrumentFileSkip, S.TaggedStruct<"InstrumentFileSkip", {
+  readonly file: S.String;
+  readonly extension: S.String;
+  readonly reason: S.String;
+}>, {}>;
+declare class InstrumentFileSkip extends InstrumentFileSkip_base {}
+declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<"InstrumentResult", {
+  readonly files: S.$Array<S.Struct<{
+    readonly name: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+    readonly content: S.String;
+    readonly mutate: S.Union<readonly [S.Boolean, S.$Array<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 mutants: S.$Array<S.Struct<{
+    readonly _tag: S.tag<"Mutant">;
+    readonly id: S.brand<S.String, "MutantId">;
+    readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+    readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
+    readonly replacement: 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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
+    readonly statusReason: S.optional<S.String>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly static: S.optional<S.Boolean>;
+    readonly testsCompleted: S.optional<S.Finite>;
+    readonly description: S.optional<S.String>;
+  }>>;
+  readonly skipped: S.$Array<typeof InstrumentFileSkip>;
+}>, {}>;
+declare class InstrumentResult$1 extends InstrumentResult_base {}
+//#endregion
+//#region src/Parser.schema.d.ts
+declare const ParseFailed_base: S.Class<ParseFailed, S.TaggedStruct<"ParseFailed", {
+  readonly fileName: S.String;
+  readonly message: S.String;
+  readonly location: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+  readonly cause: S.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class ParseFailed extends ParseFailed_base {
+  get message(): string;
+}
+//#endregion
+//#region src/Parser.service.d.ts
+interface ParserOptions {}
+interface ParserContext {
+  parse: (code: string, fileName: string, scriptFormat: ScriptFormat) => Effect$1.Effect<ScriptAst, ParseFailed>;
+}
+//#endregion
+//#region src/print/PrintFailed.schema.d.ts
+declare const PrintFailed_base: S.Class<PrintFailed, S.TaggedStruct<"PrintFailed", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class PrintFailed extends PrintFailed_base {}
+//#endregion
+//#region src/Printer.d.ts
+interface PrinterContext {
+  print: (file: Ast, context: PrinterContext) => Result.Result<string, PrintFailed>;
+}
+//#endregion
 //#region src/Mutant.schema.d.ts
 declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
 type MutantStatus = typeof MutantStatusSchema.Type;
-declare const MutantId: S.brand<S.NonEmptyString, "MutantId">;
+declare const SurvivorStatusSchema: S.Literals<readonly ["Survived", "NoCoverage"]>;
+type SurvivorStatus = typeof SurvivorStatusSchema.Type;
+declare const RememberedStatusSchema: S.Literals<readonly ["Survived", "Killed", "Timeout", "NoCoverage", "Ignored"]>;
+type RememberedStatus = typeof RememberedStatusSchema.Type;
+declare const EphemeralStatusSchema: S.Literals<readonly ["CompileError", "RuntimeError", "Pending"]>;
+type EphemeralStatus = typeof EphemeralStatusSchema.Type;
+declare const ActionableStatusSchema: S.Literals<readonly ["Survived", "NoCoverage", "Timeout", "RuntimeError"]>;
+type ActionableStatus = typeof ActionableStatusSchema.Type;
+declare const MutantId: S.brand<S.String, "MutantId">;
 type MutantId = typeof MutantId.Type;
 declare const MutatorName: S.brand<S.NonEmptyString, "MutatorName">;
 type MutatorName = typeof MutatorName.Type;
 declare const CanonicalFileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
 type CanonicalFileName = typeof CanonicalFileName.Type;
-declare const Mutant_base: S.Class<Mutant$1, S.TaggedStruct<"Mutant", {
-  readonly id: S.brand<S.NonEmptyString, "MutantId">;
+/**
+ * A mutant's file location in the mutation-testing-report-schema contract:
+ * 1-based line and 1-based column, the same base the JSON report and the
+ * machine stream emit. Every producer on the instrument path (node spans,
+ * embedded-region shifts) targets this base; no downstream layer converts.
+ */
+declare const Mutant$1: S.Struct<{
+  readonly _tag: S.tag<"Mutant">;
+  readonly id: S.brand<S.String, "MutantId">;
   readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
   readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
   readonly replacement: 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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
   readonly statusReason: S.optional<S.String>;
@@ -2798,15 +2978,40 @@ declare const Mutant_base: S.Class<Mutant$1, S.TaggedStruct<"Mutant", {
   readonly static: S.optional<S.Boolean>;
   readonly testsCompleted: S.optional<S.Finite>;
   readonly description: S.optional<S.String>;
-}>, {}>;
-/**
- * A mutant's file location in the mutation-testing-report-schema contract:
- * 1-based line and 1-based column, the same base the JSON report and the
- * machine stream emit. Every producer on the instrument path (node spans,
- * embedded-region shifts) targets this base; no downstream layer converts.
- */
-declare class Mutant$1 extends Mutant_base {}
-declare const MutantFromUnknown: S.compose<typeof Mutant$1, S.Unknown>;
+}>;
+type Mutant$1 = typeof Mutant$1.Type;
+declare const MutantFromUnknown: S.compose<S.Struct<{
+  readonly _tag: S.tag<"Mutant">;
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+  readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
+  readonly replacement: 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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
+  readonly statusReason: S.optional<S.String>;
+  readonly coveredBy: S.optional<S.$Array<S.String>>;
+  readonly static: S.optional<S.Boolean>;
+  readonly testsCompleted: S.optional<S.Finite>;
+  readonly description: S.optional<S.String>;
+}>, S.Unknown>;
 type MutantFromUnknown = typeof MutantFromUnknown.Type;
 declare const RunOptionsFields: {
   timeout: S.Finite;
@@ -2814,10 +3019,42 @@ declare const RunOptionsFields: {
 };
 declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
 type MutantActivation = typeof MutantActivationSchema.Type;
+declare const HitCount: S.Int;
 declare const MutantRunOptionsSchema: S.Struct<{
   readonly timeout: S.Finite;
   readonly disableBail: S.Boolean;
-  readonly activeMutant: typeof Mutant$1;
+  readonly activeMutant: S.Struct<{
+    readonly _tag: S.tag<"Mutant">;
+    readonly id: S.brand<S.String, "MutantId">;
+    readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+    readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
+    readonly replacement: 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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
+    readonly statusReason: S.optional<S.String>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly static: S.optional<S.Boolean>;
+    readonly testsCompleted: S.optional<S.Finite>;
+    readonly description: S.optional<S.String>;
+  }>;
   readonly sandboxFileName: S.String;
   readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
   readonly reloadEnvironment: S.Boolean;
@@ -2825,8 +3062,8 @@ declare const MutantRunOptionsSchema: S.Struct<{
   readonly hitLimit: S.optionalKey<S.Int>;
 }>;
 declare const MutantCoverageSchema$1: S.Struct<{
-  readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Int>>;
-  readonly static: S.$Record<S.String, S.Int>;
+  readonly perTest: S.$Record<S.String, S.$Record<S.brand<S.String, "MutantId">, S.Int>>;
+  readonly static: S.$Record<S.brand<S.String, "MutantId">, S.Int>;
 }>;
 type MutantCoverage = typeof MutantCoverageSchema$1.Type;
 type CoverageData = Record<string, number>;
@@ -2874,11 +3111,11 @@ declare const InstrumenterContext_base: S.Class<InstrumenterContext, S.Struct<{
   readonly activeMutant: S.optional<S.String>;
   readonly currentTestId: S.optional<S.String>;
   readonly mutantCoverage: S.optional<S.Struct<{
-    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Int>>;
-    readonly static: S.$Record<S.String, S.Int>;
+    readonly perTest: S.$Record<S.String, S.$Record<S.brand<S.String, "MutantId">, S.Int>>;
+    readonly static: S.$Record<S.brand<S.String, "MutantId">, S.Int>;
   }>>;
-  readonly hitCount: S.optional<S.Finite>;
-  readonly hitLimit: S.optional<S.Finite>;
+  readonly hitCount: S.optional<S.Int>;
+  readonly hitLimit: S.optional<S.Int>;
 }>, {}>;
 declare class InstrumenterContext extends InstrumenterContext_base {
   static readonly NAMESPACE = "__stryker__";
@@ -2893,92 +3130,6 @@ type MutantRunPlan = RunPlan;
 type MutantEarlyResultPlan = EarlyResultPlan;
 type MutantTestPlan = TestPlan;
 //#endregion
-//#region src/Instrument.schema.d.ts
-declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
-  readonly message: S.String;
-  readonly cause: S.Defect;
-}>, import("effect/Cause").YieldableError>;
-declare class InstrumentError extends InstrumentError_base {
-  get message(): string;
-}
-declare const MutateDescriptionSchema: S.Union<readonly [S.Boolean, S.$Array<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;
-  }>;
-}>>]>;
-type MutateDescription = typeof MutateDescriptionSchema.Type;
-interface MutationRange {
-  readonly start: Position;
-  readonly end: Position;
-}
-interface FileDescription {
-  readonly mutate: MutateDescription;
-}
-type FileDescriptions = Record<string, FileDescription>;
-declare const InstrumenterOptionsSchema: S.Struct<{
-  readonly excludedMutations: S.$Array<S.String>;
-  readonly ignorers: S.$Array<S.Unknown>;
-  readonly noHeader: S.optional<S.Boolean>;
-  readonly optInMutations: S.optional<S.$Array<S.String>>;
-}>;
-type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
-declare const InstrumentFileSkip_base: S.Class<InstrumentFileSkip, S.TaggedStruct<"InstrumentFileSkip", {
-  readonly file: S.String;
-  readonly extension: S.String;
-  readonly reason: S.String;
-}>, {}>;
-declare class InstrumentFileSkip extends InstrumentFileSkip_base {}
-declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<"InstrumentResult", {
-  readonly files: S.$Array<S.Struct<{
-    readonly name: S.String;
-    readonly content: S.String;
-    readonly mutate: S.Union<readonly [S.Boolean, S.$Array<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 mutants: S.$Array<typeof Mutant$1>;
-  readonly skipped: S.$Array<typeof InstrumentFileSkip>;
-}>, {}>;
-declare class InstrumentResult$1 extends InstrumentResult_base {}
-//#endregion
-//#region src/Parser.schema.d.ts
-declare const ParseFailed_base: S.Class<ParseFailed, S.TaggedStruct<"ParseFailed", {
-  readonly fileName: S.String;
-  readonly message: S.String;
-  readonly location: S.Struct<{
-    readonly line: S.Finite;
-    readonly column: S.Finite;
-  }>;
-  readonly cause: S.Defect;
-}>, import("effect/Cause").YieldableError>;
-declare class ParseFailed extends ParseFailed_base {
-  get message(): string;
-}
-//#endregion
-//#region src/Parser.service.d.ts
-interface ParserOptions {}
-interface ParserContext {
-  parse: (code: string, fileName: string, scriptFormat: ScriptFormat) => Effect$1.Effect<ScriptAst, ParseFailed>;
-}
-//#endregion
-//#region src/Printer.d.ts
-type Printer<T extends Ast = Ast> = (file: T, context: PrinterContext) => string;
-interface PrinterContext {
-  print: Printer<Ast>;
-}
-//#endregion
 //#region src/Mutator.service.d.ts
 interface Mutable {
   mutatorName: string;
@@ -2986,7 +3137,7 @@ interface Mutable {
   replacement: Node_2;
 }
 interface Mutant extends Mutable {
-  readonly id: string;
+  readonly id: MutantId;
   readonly fileName: string;
   readonly original: Node_2;
   readonly location: Location;
@@ -3085,53 +3236,61 @@ declare const disableTypeChecks: {
   (registry?: FormatRegistry): (file: File) => Effect$1.Effect<File, InstrumentError>;
 };
 declare namespace mod_d_exports$2$1 {
-  export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterOptions, MutateDescription, MutationRange, ParserOptions, disableTypeChecks, instrument };
+  export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterOptions, MutateDescription, ParserOptions, disableTypeChecks, instrument };
 }
 declare namespace mod_d_exports$3$1 {
-  export { CanonicalFileName, CanonicalFileName as CanonicalFileNameValue, Coverage, CoverageData, CoveragePerTestId, EarlyResultPlan, InstrumenterContext, Location, LocationSchema, Mutant$1 as Mutant, MutantActivation, MutantActivationSchema, MutantCoverage, MutantCoverageSchema$1 as MutantCoverageSchema, MutantEarlyResultPlan, MutantFromUnknown, MutantFromUnknown as MutantFromUnknownValue, MutantId, MutantId as MutantIdValue, MutantRunOptions, MutantRunOptionsSchema, MutantRunPlan, MutantStatus, MutantStatusSchema, MutantTestCoverage, MutantTestPlan, MutatorName, MutatorName as MutatorNameValue, OpenEndLocation, OpenEndLocationSchema, Position, PositionSchema, ReportLocationFromMutant, RunMutantResult, RunOptions, RunOptionsFields, RunPlan, TestPlan };
+  export { ActionableStatus, ActionableStatusSchema, CanonicalFileName, CanonicalFileName as CanonicalFileNameValue, Column, Coverage, CoverageData, CoveragePerTestId, EarlyResultPlan, EphemeralStatus, EphemeralStatusSchema, HitCount, InstrumenterContext, Line, LineStarts, Location, Mutant$1 as Mutant, MutantActivation, MutantActivationSchema, MutantCoverage, MutantCoverageSchema$1 as MutantCoverageSchema, MutantEarlyResultPlan, MutantFromUnknown, MutantFromUnknown as MutantFromUnknownValue, MutantId, MutantId as MutantIdValue, MutantRunOptions, MutantRunOptionsSchema, MutantRunPlan, MutantStatus, MutantStatusSchema, MutantTestCoverage, MutantTestPlan, MutatorName, MutatorName as MutatorNameValue, Offset, OpenEndLocation, Position, RememberedStatus, RememberedStatusSchema, RunMutantResult, RunOptions, RunOptionsFields, RunPlan, ScriptOrigin, Span, SurvivorStatus, SurvivorStatusSchema, TestPlan };
 }
 //#endregion
 //#region ../stryker-js-plugin-interface/dist/index.d.mts
 //#region src/Checker.schema.d.ts
 declare const CheckerMutantWire: S.Struct<{
-  readonly id: S.brand<S.NonEmptyString, "MutantId">;
+  readonly id: S.brand<S.String, "MutantId">;
   readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
   readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
   readonly replacement: 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;
+    };
   }>;
 }>;
 type CheckerMutantWire = typeof CheckerMutantWire.Type;
-declare const CheckStatus: S.Literals<readonly ["passed", "compileError"]>;
-type CheckStatus = typeof CheckStatus.Type;
-declare const CheckResultSchema: S.Union<readonly [S.Struct<{
+declare const CheckResultSchema: S.toTaggedUnion<"status", readonly [S.Struct<{
   readonly status: S.Literal<"passed">;
 }>, S.Struct<{
   readonly status: S.Literal<"compileError">;
   readonly reason: S.String;
 }>]>;
+declare const CheckStatus: S.Literals<readonly ["passed", "compileError"]>;
+type CheckStatus = typeof CheckStatus.Type;
 declare const CheckerFailed_base: S.Class<CheckerFailed, S.TaggedStruct<"CheckerFailed", {
   readonly cause: S.String;
   readonly checkerName: S.String;
-  readonly mutantIds: S.$Array<S.String>;
+  readonly mutantIds: S.$Array<S.brand<S.String, "MutantId">>;
 }>, import("effect/Cause").YieldableError>;
 declare class CheckerFailed extends CheckerFailed_base {}
-interface FailedCheckResult {
-  readonly reason: string;
+type CheckResult = typeof CheckResultSchema.Type;
+type FailedCheckResult = Extract<CheckResult, {
   readonly status: 'compileError';
-}
-interface PassedCheckResult {
+}>;
+type PassedCheckResult = Extract<CheckResult, {
   readonly status: 'passed';
-}
-type CheckResult = FailedCheckResult | PassedCheckResult;
+}>;
 //#endregion
 //#region src/Checker.service.d.ts
 interface CheckerService {
@@ -3145,25 +3304,34 @@ declare namespace mod_d_exports {
   export { CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerFailed, CheckerMutantWire, CheckerService, FailedCheckResult, PassedCheckResult };
 }
 declare const MutantResultSchema: S.Struct<{
-  readonly id: S.String;
+  readonly id: S.brand<S.String, "MutantId">;
   readonly mutatorName: S.String;
   readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-  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 replacement: S.optional<S.String>;
   readonly description: S.optional<S.String>;
   readonly statusReason: S.optional<S.String>;
   readonly static: S.optional<S.Boolean>;
-  readonly coveredBy: S.optional<S.$Array<S.String>>;
-  readonly killedBy: S.optional<S.$Array<S.String>>;
+  readonly coveredBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
+  readonly killedBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
   readonly testsCompleted: S.optional<S.Int>;
   readonly duration: S.optional<S.Finite>;
 }>;
@@ -3172,25 +3340,34 @@ declare const FileResultSchema: S.Struct<{
   readonly language: S.String;
   readonly source: S.String;
   readonly mutants: S.$Array<S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.String, "MutantId">;
     readonly mutatorName: S.String;
     readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-    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 replacement: S.optional<S.String>;
     readonly description: S.optional<S.String>;
     readonly statusReason: S.optional<S.String>;
     readonly static: S.optional<S.Boolean>;
-    readonly coveredBy: S.optional<S.$Array<S.String>>;
-    readonly killedBy: S.optional<S.$Array<S.String>>;
+    readonly coveredBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
+    readonly killedBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
     readonly testsCompleted: S.optional<S.Int>;
     readonly duration: S.optional<S.Finite>;
   }>>;
@@ -3200,59 +3377,86 @@ declare const FileResultDictionarySchema: S.$Record<S.String, S.Struct<{
   readonly language: S.String;
   readonly source: S.String;
   readonly mutants: S.$Array<S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.String, "MutantId">;
     readonly mutatorName: S.String;
     readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-    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 replacement: S.optional<S.String>;
     readonly description: S.optional<S.String>;
     readonly statusReason: S.optional<S.String>;
     readonly static: S.optional<S.Boolean>;
-    readonly coveredBy: S.optional<S.$Array<S.String>>;
-    readonly killedBy: S.optional<S.$Array<S.String>>;
+    readonly coveredBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
+    readonly killedBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
     readonly testsCompleted: S.optional<S.Int>;
     readonly duration: S.optional<S.Finite>;
   }>>;
 }>>;
 type FileResultDictionary = typeof FileResultDictionarySchema.Type;
 declare const TestDefinitionSchema: S.Struct<{
-  readonly id: S.String;
+  readonly id: S.brand<S.NonEmptyString, "TestId">;
   readonly name: S.String;
-  readonly location: S.optional<S.Struct<{
-    readonly start: S.Struct<{
-      readonly line: S.Int;
-      readonly column: S.Int;
-    }>;
-    readonly end: S.optional<S.Struct<{
-      readonly line: S.Int;
-      readonly column: S.Int;
-    }>>;
+  readonly location: S.optional<S.declare<{
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end?: {
+      readonly line: number;
+      readonly column: number;
+    } | undefined;
+  }, {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end?: {
+      readonly line: number;
+      readonly column: number;
+    } | undefined;
   }>>;
 }>;
 type TestDefinition = typeof TestDefinitionSchema.Type;
 declare const TestFileSchema: S.Struct<{
   readonly source: S.optional<S.String>;
   readonly tests: S.$Array<S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
-    readonly location: S.optional<S.Struct<{
-      readonly start: S.Struct<{
-        readonly line: S.Int;
-        readonly column: S.Int;
-      }>;
-      readonly end: S.optional<S.Struct<{
-        readonly line: S.Int;
-        readonly column: S.Int;
-      }>>;
+    readonly location: S.optional<S.declare<{
+      readonly start: {
+        readonly line: number;
+        readonly column: number;
+      };
+      readonly end?: {
+        readonly line: number;
+        readonly column: number;
+      } | undefined;
+    }, {
+      readonly start: {
+        readonly line: number;
+        readonly column: number;
+      };
+      readonly end?: {
+        readonly line: number;
+        readonly column: number;
+      } | undefined;
     }>>;
   }>>;
 }>;
@@ -3260,31 +3464,48 @@ type TestFile = typeof TestFileSchema.Type;
 declare const TestFileDefinitionDictionarySchema: S.$Record<S.String, S.Struct<{
   readonly source: S.optional<S.String>;
   readonly tests: S.$Array<S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
-    readonly location: S.optional<S.Struct<{
-      readonly start: S.Struct<{
-        readonly line: S.Int;
-        readonly column: S.Int;
-      }>;
-      readonly end: S.optional<S.Struct<{
-        readonly line: S.Int;
-        readonly column: S.Int;
-      }>>;
+    readonly location: S.optional<S.declare<{
+      readonly start: {
+        readonly line: number;
+        readonly column: number;
+      };
+      readonly end?: {
+        readonly line: number;
+        readonly column: number;
+      } | undefined;
+    }, {
+      readonly start: {
+        readonly line: number;
+        readonly column: number;
+      };
+      readonly end?: {
+        readonly line: number;
+        readonly column: number;
+      } | undefined;
     }>>;
   }>>;
 }>>;
 type TestFileDefinitionDictionary = typeof TestFileDefinitionDictionarySchema.Type;
-declare const ThresholdsSchema: S.decodeTo<S.declare<{
+declare const OrderedThresholds: S.declare<{
   readonly high: number;
   readonly low: number;
+  readonly break: number | null;
 }, {
   readonly high: number;
   readonly low: number;
-}>, S.Struct<{
-  readonly high: S.Finite;
-  readonly low: S.Finite;
-}>, never, never>;
+  readonly break: number | null;
+}>;
+declare const ThresholdsSchema: S.declare<{
+  readonly high: number;
+  readonly low: number;
+  readonly break: number | null;
+}, {
+  readonly high: number;
+  readonly low: number;
+  readonly break: number | null;
+}>;
 type Thresholds = typeof ThresholdsSchema.Type;
 declare const BrandingInformationSchema: S.Struct<{
   readonly homepageUrl: S.String;
@@ -3309,54 +3530,71 @@ declare const MutationTestResultSchema: S.Struct<{
     readonly language: S.String;
     readonly source: S.String;
     readonly mutants: S.$Array<S.Struct<{
-      readonly id: S.String;
+      readonly id: S.brand<S.String, "MutantId">;
       readonly mutatorName: S.String;
       readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-      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 replacement: S.optional<S.String>;
       readonly description: S.optional<S.String>;
       readonly statusReason: S.optional<S.String>;
       readonly static: S.optional<S.Boolean>;
-      readonly coveredBy: S.optional<S.$Array<S.String>>;
-      readonly killedBy: S.optional<S.$Array<S.String>>;
+      readonly coveredBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
+      readonly killedBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
       readonly testsCompleted: S.optional<S.Int>;
       readonly duration: S.optional<S.Finite>;
     }>>;
   }>>;
-  readonly thresholds: S.decodeTo<S.declare<{
+  readonly thresholds: S.declare<{
     readonly high: number;
     readonly low: number;
+    readonly break: number | null;
   }, {
     readonly high: number;
     readonly low: number;
-  }>, S.Struct<{
-    readonly high: S.Finite;
-    readonly low: S.Finite;
-  }>, never, never>;
+    readonly break: number | null;
+  }>;
   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>;
     readonly tests: S.$Array<S.Struct<{
-      readonly id: S.String;
+      readonly id: S.brand<S.NonEmptyString, "TestId">;
       readonly name: S.String;
-      readonly location: S.optional<S.Struct<{
-        readonly start: S.Struct<{
-          readonly line: S.Int;
-          readonly column: S.Int;
-        }>;
-        readonly end: S.optional<S.Struct<{
-          readonly line: S.Int;
-          readonly column: S.Int;
-        }>>;
+      readonly location: S.optional<S.declare<{
+        readonly start: {
+          readonly line: number;
+          readonly column: number;
+        };
+        readonly end?: {
+          readonly line: number;
+          readonly column: number;
+        } | undefined;
+      }, {
+        readonly start: {
+          readonly line: number;
+          readonly column: number;
+        };
+        readonly end?: {
+          readonly line: number;
+          readonly column: number;
+        } | undefined;
       }>>;
     }>>;
   }>>>;
@@ -3374,6 +3612,8 @@ declare const MutationTestResultSchema: S.Struct<{
 type MutationTestResult = typeof MutationTestResultSchema.Type;
 //#endregion
 //#region src/ExitClass.schema.d.ts
+declare const ExitCode: S.Int;
+type ExitCode = typeof ExitCode.Type;
 declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
 type ExitClass = typeof ExitClass.Type;
 declare const ExitCodeFromClass: S.decodeTo<S.Literals<readonly [1, 2, 3, 4]>, S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>, never, never>;
@@ -3451,7 +3691,7 @@ declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
     readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
   }>>, never>;
   readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-  readonly concurrency: S.optionalKey<S.Union<readonly [S.Finite, S.String]>>;
+  readonly concurrency: S.optionalKey<S.Union<readonly [S.Int, S.String]>>;
   readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
     readonly command: S.withDecodingDefaultKey<S.String, never>;
   }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
@@ -3460,7 +3700,7 @@ declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
     readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly maxTestsToLog: S.withDecodingDefaultKey<S.Int, never>;
     readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
     readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
@@ -3476,8 +3716,8 @@ declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
   readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
   readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
   readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
-  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
-  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Int, never>;
+  readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Int, never>;
   readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
   readonly mutator: S.withDecodingDefaultKey<S.Struct<{
     readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
@@ -3517,7 +3757,7 @@ declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
     readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
   }>, never, never>, never>;
   readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
-  readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
+  readonly timeoutMS: S.withDecodingDefaultKey<S.Int, never>;
   readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
   readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
   readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
@@ -3582,9 +3822,6 @@ declare class Metrics extends Metrics_base {
   get totalMutants(): number;
   get mutationScore(): MutationScore;
   get mutationScoreBasedOnCoveredCode(): MutationScore;
-  static fromMutants(mutants: readonly {
-    readonly status: string;
-  }[]): Metrics;
 }
 declare const MetricsSchema: typeof Metrics;
 interface MetricsResult {
@@ -3600,8 +3837,6 @@ interface MetricsResultEncoded {
 declare const MetricsResultSchema: S.Codec<MetricsResult, MetricsResultEncoded>;
 //#endregion
 //#region src/ReporterEvent.schema.d.ts
-declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
-type ReporterEventKind = typeof ReporterEventKind.Type;
 declare const RunTimingSchema: S.Struct<{
   readonly net: S.Finite;
   readonly overhead: S.Finite;
@@ -3609,7 +3844,7 @@ declare const RunTimingSchema: S.Struct<{
 type RunTiming = typeof RunTimingSchema.Type;
 declare const ReporterPlanKind: S.Literals<readonly ["EarlyResult", "Run"]>;
 declare const ReporterPlanDescriptorSchema: S.Struct<{
-  readonly mutantId: S.String;
+  readonly mutantId: S.brand<S.String, "MutantId">;
   readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
   readonly netTime: S.Finite;
   readonly reloadEnvironment: S.Boolean;
@@ -3625,7 +3860,7 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
   }>;
   readonly testCount: S.Int;
   readonly tests: S.$Array<S.Union<readonly [S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
     readonly timeSpentMs: S.Finite;
     readonly fileName: S.optionalKey<S.String>;
@@ -3636,7 +3871,7 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
     readonly status: S.Literal<"failed">;
     readonly failureMessage: S.String;
   }>, S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
     readonly timeSpentMs: S.Finite;
     readonly fileName: S.optionalKey<S.String>;
@@ -3646,7 +3881,7 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
     }>>;
     readonly status: S.Literal<"skipped">;
   }>, S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
     readonly timeSpentMs: S.Finite;
     readonly fileName: S.optionalKey<S.String>;
@@ -3661,7 +3896,7 @@ declare class DryRunCompleted extends DryRunCompleted_base {}
 declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
   readonly total: S.Int;
   readonly plans: S.$Array<S.Struct<{
-    readonly mutantId: S.String;
+    readonly mutantId: S.brand<S.String, "MutantId">;
     readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
     readonly netTime: S.Finite;
     readonly reloadEnvironment: S.Boolean;
@@ -3669,20 +3904,29 @@ declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S
 }>, {}>;
 declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
 declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
-  readonly id: S.String;
+  readonly id: S.brand<S.String, "MutantId">;
   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 fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+  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 mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
   readonly replacement: S.NullOr<S.String>;
   readonly completed: S.Int;
   readonly total: S.Int;
@@ -3695,54 +3939,71 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
       readonly language: S.String;
       readonly source: S.String;
       readonly mutants: S.$Array<S.Struct<{
-        readonly id: S.String;
+        readonly id: S.brand<S.String, "MutantId">;
         readonly mutatorName: S.String;
         readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-        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 replacement: S.optional<S.String>;
         readonly description: S.optional<S.String>;
         readonly statusReason: S.optional<S.String>;
         readonly static: S.optional<S.Boolean>;
-        readonly coveredBy: S.optional<S.$Array<S.String>>;
-        readonly killedBy: S.optional<S.$Array<S.String>>;
+        readonly coveredBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
+        readonly killedBy: S.optional<S.$Array<S.brand<S.NonEmptyString, "TestId">>>;
         readonly testsCompleted: S.optional<S.Int>;
         readonly duration: S.optional<S.Finite>;
       }>>;
     }>>;
-    readonly thresholds: S.decodeTo<S.declare<{
+    readonly thresholds: S.declare<{
       readonly high: number;
       readonly low: number;
+      readonly break: number | null;
     }, {
       readonly high: number;
       readonly low: number;
-    }>, S.Struct<{
-      readonly high: S.Finite;
-      readonly low: S.Finite;
-    }>, never, never>;
+      readonly break: number | null;
+    }>;
     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>;
       readonly tests: S.$Array<S.Struct<{
-        readonly id: S.String;
+        readonly id: S.brand<S.NonEmptyString, "TestId">;
         readonly name: S.String;
-        readonly location: S.optional<S.Struct<{
-          readonly start: S.Struct<{
-            readonly line: S.Int;
-            readonly column: S.Int;
-          }>;
-          readonly end: S.optional<S.Struct<{
-            readonly line: S.Int;
-            readonly column: S.Int;
-          }>>;
+        readonly location: S.optional<S.declare<{
+          readonly start: {
+            readonly line: number;
+            readonly column: number;
+          };
+          readonly end?: {
+            readonly line: number;
+            readonly column: number;
+          } | undefined;
+        }, {
+          readonly start: {
+            readonly line: number;
+            readonly column: number;
+          };
+          readonly end?: {
+            readonly line: number;
+            readonly column: number;
+          } | undefined;
         }>>;
       }>>;
     }>>>;
@@ -3760,8 +4021,10 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
   readonly metrics: S.Codec<MetricsResult, MetricsResultEncoded, never, never>;
 }>, {}>;
 declare class MutationTestReportReady extends MutationTestReportReady_base {}
-declare const ReporterEventUnion: S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
-type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
+declare const ReporterEventUnion: S.toTaggedUnion<"_tag", readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
+type ReporterEvent = typeof ReporterEventUnion.Type;
+declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+type ReporterEventKind = typeof ReporterEventKind.Type;
 declare const ReporterEventSchema: StandardSchemaV1<typeof ReporterEventUnion['Encoded'], ReporterEvent>;
 interface ReporterInit {
   readonly traceparent?: string | undefined;
@@ -3776,6 +4039,8 @@ declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"Repor
 declare class ReporterFailed extends ReporterFailed_base {}
 //#endregion
 //#region src/TestRunner.schema.d.ts
+declare const TestId: S.brand<S.NonEmptyString, "TestId">;
+type TestId = typeof TestId.Type;
 declare const DryRunStatus: S.Literals<readonly ["complete", "error", "timeout"]>;
 type DryRunStatus = typeof DryRunStatus.Type;
 declare const TestStatus: S.Literals<readonly ["success", "failed", "skipped"]>;
@@ -3783,7 +4048,7 @@ type TestStatus = typeof TestStatus.Type;
 declare const MutantRunStatus: S.Literals<readonly ["killed", "survived", "timeout", "error"]>;
 type MutantRunStatus = typeof MutantRunStatus.Type;
 declare const TestResultSchema: S.Union<readonly [S.Struct<{
-  readonly id: S.String;
+  readonly id: S.brand<S.NonEmptyString, "TestId">;
   readonly name: S.String;
   readonly timeSpentMs: S.Finite;
   readonly fileName: S.optionalKey<S.String>;
@@ -3794,7 +4059,7 @@ declare const TestResultSchema: S.Union<readonly [S.Struct<{
   readonly status: S.Literal<"failed">;
   readonly failureMessage: S.String;
 }>, S.Struct<{
-  readonly id: S.String;
+  readonly id: S.brand<S.NonEmptyString, "TestId">;
   readonly name: S.String;
   readonly timeSpentMs: S.Finite;
   readonly fileName: S.optionalKey<S.String>;
@@ -3804,7 +4069,7 @@ declare const TestResultSchema: S.Union<readonly [S.Struct<{
   }>>;
   readonly status: S.Literal<"skipped">;
 }>, S.Struct<{
-  readonly id: S.String;
+  readonly id: S.brand<S.NonEmptyString, "TestId">;
   readonly name: S.String;
   readonly timeSpentMs: S.Finite;
   readonly fileName: S.optionalKey<S.String>;
@@ -3815,13 +4080,13 @@ declare const TestResultSchema: S.Union<readonly [S.Struct<{
   readonly status: S.Literal<"success">;
 }>]>;
 declare const MutantCoverageSchema: S.Struct<{
-  readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
-  readonly static: S.$Record<S.String, S.Finite>;
+  readonly perTest: S.$Record<S.String, S.$Record<S.brand<S.String, "MutantId">, S.Finite>>;
+  readonly static: S.$Record<S.brand<S.String, "MutantId">, S.Finite>;
 }>;
 declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
   readonly status: S.Literal<"complete">;
   readonly tests: S.$Array<S.Union<readonly [S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
     readonly timeSpentMs: S.Finite;
     readonly fileName: S.optionalKey<S.String>;
@@ -3832,7 +4097,7 @@ declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
     readonly status: S.Literal<"failed">;
     readonly failureMessage: S.String;
   }>, S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
     readonly timeSpentMs: S.Finite;
     readonly fileName: S.optionalKey<S.String>;
@@ -3842,7 +4107,7 @@ declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
     }>>;
     readonly status: S.Literal<"skipped">;
   }>, S.Struct<{
-    readonly id: S.String;
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
     readonly name: S.String;
     readonly timeSpentMs: S.Finite;
     readonly fileName: S.optionalKey<S.String>;
@@ -3853,8 +4118,8 @@ declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
     readonly status: S.Literal<"success">;
   }>]>>;
   readonly mutantCoverage: S.optionalKey<S.Struct<{
-    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
-    readonly static: S.$Record<S.String, S.Finite>;
+    readonly perTest: S.$Record<S.String, S.$Record<S.brand<S.String, "MutantId">, S.Finite>>;
+    readonly static: S.$Record<S.brand<S.String, "MutantId">, S.Finite>;
   }>>;
 }>, S.Struct<{
   readonly status: S.Literal<"timeout">;
@@ -3865,12 +4130,12 @@ declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
 }>]>;
 declare const MutantRunResultSchema: S.Union<readonly [S.Struct<{
   readonly status: S.Literal<"killed">;
-  readonly killedBy: S.$Array<S.String>;
+  readonly killedBy: S.$Array<S.brand<S.NonEmptyString, "TestId">>;
   readonly failureMessage: S.String;
-  readonly nrOfTests: S.Finite;
+  readonly nrOfTests: S.Int;
 }>, S.Struct<{
   readonly status: S.Literal<"survived">;
-  readonly nrOfTests: S.Finite;
+  readonly nrOfTests: S.Int;
 }>, S.Struct<{
   readonly status: S.Literal<"timeout">;
   readonly reason: S.optionalKey<S.String>;
@@ -3896,7 +4161,7 @@ declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"T
 }>, import("effect/Cause").YieldableError>;
 declare class TestRunnerFailed extends TestRunnerFailed_base {}
 interface BaseTestResult {
-  readonly id: string;
+  readonly id: TestId;
   readonly name: string;
   readonly timeSpentMs: number;
   readonly fileName?: string;
@@ -3933,7 +4198,7 @@ interface TimeoutMutantRunResult {
 }
 interface KilledMutantRunResult {
   readonly status: 'killed';
-  readonly killedBy: readonly string[];
+  readonly killedBy: readonly TestId[];
   readonly failureMessage: string;
   readonly nrOfTests: number;
 }
@@ -3959,6 +4224,10 @@ interface TestRunnerCapabilities {
 //#region src/Plugin.schema.d.ts
 declare const WorkerPluginKind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
 type WorkerPluginKind = typeof WorkerPluginKind.Type;
+declare const EvaluatorPluginKind: S.Literal<"Evaluator">;
+type EvaluatorPluginKind = typeof EvaluatorPluginKind.Type;
+declare const PluginKindSchema: S.Union<readonly [S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>, S.Literal<"Evaluator">]>;
+type PluginKind = typeof PluginKindSchema.Type;
 declare const TestRunnerDryRunRequest: S.Struct<{
   readonly options: S.Struct<{
     readonly timeout: S.Finite;
@@ -3973,7 +4242,38 @@ declare const TestRunnerMutantRunRequest: S.Struct<{
   readonly options: S.Struct<{
     readonly timeout: S.Finite;
     readonly disableBail: S.Boolean;
-    readonly activeMutant: typeof mod_d_exports$3$1.Mutant;
+    readonly activeMutant: S.Struct<{
+      readonly _tag: S.tag<"Mutant">;
+      readonly id: S.brand<S.String, "MutantId">;
+      readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+      readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
+      readonly replacement: 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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
+      readonly statusReason: S.optional<S.String>;
+      readonly coveredBy: S.optional<S.$Array<S.String>>;
+      readonly static: S.optional<S.Boolean>;
+      readonly testsCompleted: S.optional<S.Finite>;
+      readonly description: S.optional<S.String>;
+    }>;
     readonly sandboxFileName: S.String;
     readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
     readonly reloadEnvironment: S.Boolean;
@@ -3985,24 +4285,33 @@ type TestRunnerMutantRunRequest = typeof TestRunnerMutantRunRequest.Type;
 declare const CheckerRequest: S.Struct<{
   readonly checkerName: S.String;
   readonly mutants: S.$Array<S.Struct<{
-    readonly id: S.brand<S.NonEmptyString, "MutantId">;
+    readonly id: S.brand<S.String, "MutantId">;
     readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
     readonly mutatorName: S.brand<S.NonEmptyString, "MutatorName">;
     readonly replacement: 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;
+      };
     }>;
   }>>;
 }>;
 type CheckerRequest = typeof CheckerRequest.Type;
-declare const CheckerCheckResult: S.$Record<S.String, S.Union<readonly [S.Struct<{
+declare const CheckerCheckResult: S.$Record<S.String, S.toTaggedUnion<"status", readonly [S.Struct<{
   readonly status: S.Literal<"passed">;
 }>, S.Struct<{
   readonly status: S.Literal<"compileError">;
@@ -4010,11 +4319,16 @@ declare const CheckerCheckResult: S.$Record<S.String, S.Union<readonly [S.Struct
 }>]>>;
 declare const CheckerGroupResult: S.$Array<S.$Array<S.String>>;
 declare const ReporterInitOptions: S.Struct<{
-  readonly traceparent: S.optionalKey<S.String>;
+  readonly traceparent: S.optionalKey<S.decodeTo<S.Struct<{
+    readonly version: S.String;
+    readonly traceId: S.String;
+    readonly spanId: S.String;
+    readonly traceFlags: S.Int;
+  }>, S.String, never, never>>;
   readonly tracestate: S.optionalKey<S.String>;
 }>;
 type ReporterInitOptions = typeof ReporterInitOptions.Type;
-declare const ReporterEventBatch: S.$Array<S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>>;
+declare const ReporterEventBatch: S.$Array<S.toTaggedUnion<"_tag", readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>>;
 type ReporterEventBatch = typeof ReporterEventBatch.Type;
 declare const ReporterAck: S.Void;
 declare const ReporterDrained: S.Void;
@@ -4051,17 +4365,30 @@ declare const PropagatedTrace_base: Context.ServiceClass<PropagatedTrace, "@syst
 declare class PropagatedTrace extends PropagatedTrace_base {}
 declare const TraceContextMiddleware_base: RpcMiddleware.ServiceClass<TraceContextMiddleware, "@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", typeof PropagatedTrace, Schema.Never, never, never, true>;
 declare class TraceContextMiddleware extends TraceContextMiddleware_base {}
-type TracedRpc<Tag extends string, Payload extends Schema.Top = Schema.Void, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never> = Rpc.Rpc<Tag, Payload, Success, Error, typeof TraceContextMiddleware, RpcMiddleware.ApplyServices<typeof TraceContextMiddleware['Identifier'], never>>;
+type TracedRpc<Tag extends string, Payload extends Schema.Top = Schema.Void, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never> = Rpc.AddMiddleware<Rpc.Rpc<Tag, Payload, Success, Error>, typeof TraceContextMiddleware>;
 //#endregion
 //#region src/PluginRpcs.service.d.ts
-declare const TestRunnerRpcs: RpcGroup.RpcGroup<TracedRpc<'capabilities', Schema.Void, typeof TestRunnerCapabilitiesSchema, typeof TestRunnerFailed> | TracedRpc<'dryRun', typeof TestRunnerDryRunRequest, typeof DryRunResultSchema, typeof TestRunnerFailed> | TracedRpc<'mutantRun', typeof TestRunnerMutantRunRequest, typeof MutantRunResultSchema, typeof TestRunnerFailed>>;
-declare const CheckerRpcs: RpcGroup.RpcGroup<TracedRpc<'check', typeof CheckerRequest, typeof CheckerCheckResult, typeof CheckerFailed> | TracedRpc<'group', typeof CheckerRequest, typeof CheckerGroupResult, typeof CheckerFailed>>;
-declare const ReporterRpcs: RpcGroup.RpcGroup<TracedRpc<'init', typeof ReporterInitOptions, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'onEventBatch', typeof ReporterEventBatch, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'flush', Schema.Void, typeof ReporterDrained, typeof ReporterFailed>>;
+declare const capabilities: TracedRpc<'capabilities', Schema.Void, typeof TestRunnerCapabilitiesSchema, typeof TestRunnerFailed>;
+declare const dryRun: TracedRpc<'dryRun', typeof TestRunnerDryRunRequest, typeof DryRunResultSchema, typeof TestRunnerFailed>;
+declare const mutantRun: TracedRpc<'mutantRun', typeof TestRunnerMutantRunRequest, typeof MutantRunResultSchema, typeof TestRunnerFailed>;
+declare const check: TracedRpc<'check', typeof CheckerRequest, typeof CheckerCheckResult, typeof CheckerFailed>;
+declare const group: TracedRpc<'group', typeof CheckerRequest, typeof CheckerGroupResult, typeof CheckerFailed>;
+declare const init: TracedRpc<'init', typeof ReporterInitOptions, typeof ReporterAck, typeof ReporterFailed>;
+declare const onEventBatch: TracedRpc<'onEventBatch', typeof ReporterEventBatch, typeof ReporterAck, typeof ReporterFailed>;
+declare const flush: TracedRpc<'flush', Schema.Void, typeof ReporterDrained, typeof ReporterFailed>;
+declare const TestRunnerRpcs: RpcGroup.RpcGroup<typeof capabilities | typeof dryRun | typeof mutantRun>;
+declare const CheckerRpcs: RpcGroup.RpcGroup<typeof check | typeof group>;
+declare const ReporterRpcs: RpcGroup.RpcGroup<typeof init | typeof onEventBatch | typeof flush>;
 declare namespace mod_d_exports$3 {
-  export { BoundaryError, BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, CheckerCheckResult, CheckerGroupResult, CheckerRequest, CheckerRpcs, ExitClass, ExitCodeFromClass, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterInitOptions, ReporterRpcs, TestRunnerDryRunRequest, TestRunnerMutantRunRequest, TestRunnerRpcs, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema };
+  export { BoundaryError, BoundaryErrorSchema, BoundaryPayloadRejected, BoundaryUnrecognizedSignal, CheckerCheckResult, CheckerGroupResult, CheckerRequest, CheckerRpcs, EvaluatorPluginKind, ExitClass, ExitCode, ExitCodeFromClass, PluginKind, PluginKindSchema, ReporterAck, ReporterDrained, ReporterEventBatch, ReporterInitOptions, ReporterRpcs, TestRunnerDryRunRequest, TestRunnerMutantRunRequest, TestRunnerRpcs, WorkerEntryUrl, WorkerPluginKind, WorkerPluginSpawn, WorkerPluginSpawnSchema };
 }
+//#endregion
+//#region src/Metrics.d.ts
+declare const metricsFromMutants: (mutants: readonly {
+  readonly status: mod_d_exports$3$1.MutantStatus;
+}[]) => Metrics;
 declare namespace mod_d_exports$4 {
-  export { BrandingInformation, BrandingInformationSchema, Dependencies, DependenciesSchema, DetectedStatus, FileResult, FileResultDictionary, FileResultDictionarySchema, FileResultSchema, FrameworkInformation, FrameworkInformationSchema, InvalidStatus, Metrics, MetricsResult, MetricsResultEncoded, MetricsResultSchema, MetricsSchema, MutantResult, MutantResultSchema, MutationScore, MutationTestResult, MutationTestResultSchema, NonNegativeFinite, NonNegativeInt, Percentage, TestDefinition, TestDefinitionSchema, TestFile, TestFileDefinitionDictionary, TestFileDefinitionDictionarySchema, TestFileSchema, Thresholds, ThresholdsSchema, UndetectedStatus, UntestedStatus };
+  export { BrandingInformation, BrandingInformationSchema, Dependencies, DependenciesSchema, DetectedStatus, FileResult, FileResultDictionary, FileResultDictionarySchema, FileResultSchema, FrameworkInformation, FrameworkInformationSchema, InvalidStatus, Metrics, MetricsResult, MetricsResultEncoded, MetricsResultSchema, MetricsSchema, MutantResult, MutantResultSchema, MutationScore, MutationTestResult, MutationTestResultSchema, NonNegativeFinite, NonNegativeInt, OrderedThresholds, Percentage, TestDefinition, TestDefinitionSchema, TestFile, TestFileDefinitionDictionary, TestFileDefinitionDictionarySchema, TestFileSchema, Thresholds, ThresholdsSchema, UndetectedStatus, UntestedStatus, metricsFromMutants };
 }
 declare namespace mod_d_exports$5 {
   export { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterEvent, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFactory, ReporterFailed, ReporterInit, ReporterPlanDescriptor, ReporterPlanDescriptorSchema, ReporterPlanKind, RunTiming, RunTimingSchema };
@@ -4087,7 +4414,7 @@ interface TestRunnerService {
 declare const TestRunner_base: Context.ServiceClass<TestRunner, "@systemfsoftware/stryker-js-plugin-interface/TestRunner.service/TestRunner", TestRunnerService>;
 declare class TestRunner extends TestRunner_base {}
 declare namespace mod_d_exports$6 {
-  export { BaseTestResult, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisSchema, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, ErrorDryRunResult, ErrorMutantRunResult, FailedTestResult, HitLimitReason, HitLimitReasonPrefix, HitLimitReasonText, KilledMutantRunResult, MutantCoverageSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, SkippedTestResult, SuccessTestResult, SurvivedMutantRunResult, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestRunnerService, TestStatus, TimeoutDryRunResult, TimeoutMutantRunResult, WallClockTimeoutReason };
+  export { BaseTestResult, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisSchema, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, ErrorDryRunResult, ErrorMutantRunResult, FailedTestResult, HitLimitReason, HitLimitReasonPrefix, HitLimitReasonText, KilledMutantRunResult, MutantCoverageSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, SkippedTestResult, SuccessTestResult, SurvivedMutantRunResult, TestId, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestRunnerService, TestStatus, TimeoutDryRunResult, TimeoutMutantRunResult, WallClockTimeoutReason };
 }
 //#endregion
 export { mod_d_exports$5 as a, mod_d_exports$2$1 as c, Ignorer$1 as d, Node_2$1 as f, mod_d_exports$4 as i, mod_d_exports$3$1 as l, mod_d_exports$2 as n, mod_d_exports$6 as o, mod_d_exports$3 as r, mod_d_exports$1 as s, mod_d_exports as t, Framework as u };