@systemfsoftware/stryker-js-instrumenter 10.0.1 → 11.0.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 11.0.0
+
+### Major Changes
+
+- Mutant identity, status, location, coverage and run options are re-exported from `@systemfsoftware/stryker-js-plugin-interface` as `Mutant`; `Mutator` now holds the registry, catalog and selection, and `Source` holds `LineStarts`, `Offset`, `ScriptOrigin` and `Span`. A mutant switch on a conditional's test is printed in parentheses now, so a ternary-test mutant no longer replaces the whole conditional. Mutants ignored by a `// Stryker disable` directive no longer shift the placed replacements beside them, so every activated arm runs its own replacement.
+
+  Import the moved identity types from the plugin interface.
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js-plugin-interface@11.0.0
+
 ## 10.0.1
 
 ### Patch Changes

package/README.md

@@ -18,6 +18,8 @@ The instrumenter is used internally by the Stryker mutation testing framework to
 
 File formats resolve through a format registry: `coreFormatRegistry` carries the built-in `js`/`ts`/`tsx` entries, `frameworkEntryOf` adapts a framework's `Framework` object into an entry, and `registerEntries` folds additions into a registry (an extension already claimed stays with the earlier entry). `instrument(files, options, registry)` and `disableTypeChecks(file, registry)` accept that registry — defaulting to the core one — and `instrument` returns the files it skipped because no entry claimed their extension.
 
+`options.mutantSetPolicy` states which mutant set the run wants and is required: `'default'` is the product default, and `'full'` turns off the mutant-set pruning the instrumenter would otherwise apply, so the run keeps every mutation the selected mutators can plant.
+
 ## Opt-in mutators
 
 Three mutators that plant Effect concurrency faults are available on request and stay out of the default set. Enable any subset in your Stryker config:
@@ -34,7 +36,7 @@ Three mutators that plant Effect concurrency faults are available on request and
 - **SynchronizationRemoval** drops the guarding effect of `Semaphore.withPermits`/`withPermit` and `Effect.uninterruptible`, letting code that assumed exclusivity or uninterruptibility run without it.
 - **FinalizerEscape** weakens `Effect.ensuring`, `Effect.onExit`, `Effect.onError`, and `Effect.onInterrupt` so their cleanup no longer runs on interruption.
 
-Naming a mutator that does not exist fails the run and lists the names that do. The replacements these mutators plant use Effect 4 APIs, so a repository on Effect 3.x must not opt in.
+Naming a mutator that does not exist fails the run before instrumentation, as a config failure naming the entry. The replacements these mutators plant use Effect 4 APIs, so a repository on Effect 3.x must not opt in.
 
 ## License
 

package/dist/index.d.mts

@@ -3,10 +3,12 @@ import * as Result from "effect/Result";
 import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";
 import { Handle, Workflow } from "@systemfsoftware/effect-cell-types";
+import { Mutant, MutatorCatalog, Options } from "@systemfsoftware/stryker-js-plugin-interface";
 import * as Arr from "effect/Array";
+import { StockCatalog } from "@systemfsoftware/stryker-js-cli-contract";
 import { EmbeddedDocument, FormatId, Framework, FrameworkContext } from "@systemfsoftware/stryker-framework-interface";
-import "oxc-parser";
 import "@oxc-project/types";
+import "oxc-parser";
 //#region src/ErrorText.schema.d.ts
 declare const ErrorText_base: S.Class<ErrorText, S.Struct<{
   readonly text: S.NonEmptyString;
@@ -1341,57 +1343,6 @@ declare interface YieldExpression$1 extends Span$1 {
 //#region src/Location.schema.d.ts
 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 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 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 OpenEndLocation.Type;
 declare const Span: S.declare<{
   readonly start: number;
   readonly end: number;
@@ -1456,6 +1407,94 @@ interface TsxAst extends BaseAst {
 type ScriptAst = JSAst | TSAst | TsxAst;
 type Ast = JSAst | TSAst | TsxAst | EmbeddedAst;
 //#endregion
+//#region src/Mutator.service.d.ts
+interface Mutable {
+  mutatorName: string;
+  ignoreReason?: string | undefined;
+  replacement: Node_2;
+}
+interface Mutant$1 extends Mutable {
+  readonly id: Mutant.MutantId;
+  readonly fileName: string;
+  readonly original: Node_2;
+  readonly location: Mutant.Location;
+  readonly replacementCode: string;
+}
+interface MutatorContext {
+  readonly parent: Node_2 | undefined;
+  readonly grandParent: Node_2 | undefined;
+  readonly ancestors: readonly Node_2[];
+  readonly mutantSetPolicy: Options.MutantSetPolicyType;
+}
+/**
+ * One mutator: a pure function from a node to the mutants it produces.
+ *
+ * A function, not an object with a `mutate` method and a `name` field. The name
+ * lived inside every mutator AND as its position in a hand-written list, so the
+ * two could disagree; the registry's key is now the only place a name is
+ * written.
+ */
+type Mutator = (node: Node_2, context: MutatorContext) => Iterable<Node_2>;
+interface MutatorOptions {
+  excludedMutations: string[];
+  mutators: MutatorSelection;
+  mutantSetPolicy: Options.MutantSetPolicyType;
+  noHeader?: boolean;
+}
+/**
+ * Every mutator this instrumenter can apply, named explicitly.
+ *
+ * This list is deliberately hand-written rather than self-registering. A
+ * registry populated by import side effects — each mutator module calling
+ * `registerMutator(self)` at module scope — makes the mutant population depend
+ * on which imports were evaluated: import order decides the order, a bundler
+ * that judges a side-effect-only import unused drops a mutator entirely, and
+ * anything reading the array before the last import finished sees a short list.
+ * Every one of those failures REMOVES mutants, which RAISES the mutation score,
+ * so the tool reports a better number for doing less work and nothing anywhere
+ * says so.
+ *
+ * Naming each mutator here costs one line when a mutator is added and makes
+ * that line a compile-checked import instead of a runtime effect.
+ *
+ * `optInMutators` below follows the same hand-written rule, for the same
+ * reason: a mutator exists for a run only when a human named it here.
+ */
+declare const defaultMutators: Readonly<Record<StockCatalog.StockDefaultName, Mutator>>;
+declare const optInMutators: Readonly<Record<StockCatalog.StockOptInName, Mutator>>;
+type MutatorEntry = readonly [name: string, mutate: Mutator];
+interface MutatorRegistry {
+  readonly defaults: Readonly<Record<string, Mutator>>;
+  readonly optIn: Readonly<Record<string, Mutator>>;
+}
+declare const stockRegistry: MutatorRegistry;
+interface RegistryCatalog {
+  readonly entries: ReadonlyArray<{
+    readonly name: string;
+    readonly tier: MutatorCatalog.Tier;
+  }>;
+}
+interface RegistryContribution {
+  readonly entries: ReadonlyArray<{
+    readonly name: string;
+    readonly implementation: Mutator;
+  }>;
+}
+declare const registryOf: {
+  (catalogs: ReadonlyArray<RegistryCatalog>, contributions: ReadonlyArray<RegistryContribution>): MutatorRegistry;
+  (contributions: ReadonlyArray<RegistryContribution>): (catalogs: ReadonlyArray<RegistryCatalog>) => MutatorRegistry;
+};
+interface MutatorSelection {
+  /** Every default, then each opt-in the run named, in the registry's declared order. */
+  readonly active: readonly MutatorEntry[];
+  /** Every name a `Stryker disable` directive may reference, selected or not. */
+  readonly known: readonly string[];
+}
+declare const selectMutators: {
+  (registry: MutatorRegistry, optInMutations: readonly string[]): MutatorSelection;
+  (optInMutations: readonly string[]): (registry: MutatorRegistry) => MutatorSelection;
+};
+//#endregion
 //#region src/Instrument.schema.d.ts
 declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
   readonly message: S.String;
@@ -1464,7 +1503,7 @@ declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"Ins
 declare class InstrumentError extends InstrumentError_base {
   get message(): string;
 }
-declare const MutateDescriptionSchema: S.Union<readonly [S.Boolean, S.$Array<S.declare<{
+declare const MutateDescriptionSchema: S.Union<readonly [S.Boolean, S.$Array<S.decodeTo<S.declare<{
   readonly start: {
     readonly line: number;
     readonly column: number;
@@ -1482,7 +1521,16 @@ declare const MutateDescriptionSchema: S.Union<readonly [S.Boolean, S.$Array<S.d
     readonly line: number;
     readonly column: number;
   };
-}>>]>;
+}>, 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;
+  }>;
+}>, never, never>>]>;
 type MutateDescription = typeof MutateDescriptionSchema.Type;
 interface FileDescription {
   readonly mutate: MutateDescription;
@@ -1491,10 +1539,13 @@ type FileDescriptions = Record<string, FileDescription>;
 declare const InstrumenterOptionsSchema: S.Struct<{
   readonly excludedMutations: S.$Array<S.String>;
   readonly ignorers: S.$Array<S.Unknown>;
+  readonly mutators: S.Unknown;
+  readonly mutantSetPolicy: S.Literals<readonly ["default", "full"]>;
   readonly noHeader: S.optional<S.Boolean>;
-  readonly optInMutations: S.optional<S.$Array<S.String>>;
 }>;
-type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
+type InstrumenterOptions = Omit<typeof InstrumenterOptionsSchema.Type, 'mutators'> & {
+  readonly mutators: MutatorSelection;
+};
 declare const InstrumentFileSkip_base: S.Class<InstrumentFileSkip, S.TaggedStruct<"InstrumentFileSkip", {
   readonly file: S.String;
   readonly extension: S.String;
@@ -1505,7 +1556,7 @@ declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<
   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 mutate: S.Union<readonly [S.Boolean, S.$Array<S.decodeTo<S.declare<{
       readonly start: {
         readonly line: number;
         readonly column: number;
@@ -1523,15 +1574,24 @@ declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<
         readonly line: number;
         readonly column: number;
       };
-    }>>]>;
+    }>, 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;
+      }>;
+    }>, never, never>>]>;
   }>>;
   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 mutatorName: S.brand<S.String, "MutatorName">;
     readonly replacement: S.String;
-    readonly location: S.declare<{
+    readonly location: S.decodeTo<S.declare<{
       readonly start: {
         readonly line: number;
         readonly column: number;
@@ -1549,7 +1609,16 @@ declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<
         readonly line: number;
         readonly column: number;
       };
-    }>;
+    }>, 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;
+      }>;
+    }>, never, never>;
     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>>;
@@ -1592,239 +1661,23 @@ 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 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;
-/**
- * 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.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>;
-}>;
-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;
-  disableBail: S.Boolean;
-};
-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: 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;
-  readonly testFilter: S.optionalKey<S.$Array<S.String>>;
-  readonly hitLimit: S.optionalKey<S.Int>;
-}>;
-declare const MutantCoverageSchema: S.Struct<{
-  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.Type;
-type CoverageData = Record<string, number>;
-type CoveragePerTestId = Record<string, CoverageData>;
-interface Coverage {
-  readonly static: CoverageData;
-  readonly perTest: CoveragePerTestId;
-}
-interface RunOptions {
-  readonly timeout: number;
-  readonly disableBail: boolean;
-}
-interface MutantRunOptions extends RunOptions {
-  readonly testFilter?: readonly string[];
-  readonly hitLimit?: number;
-  readonly activeMutant: Mutant$1;
-  readonly sandboxFileName: string;
-  readonly mutantActivation: MutantActivation;
-  readonly reloadEnvironment: boolean;
-}
-interface EarlyResultPlan {
-  readonly plan: 'EarlyResult';
-  readonly mutant: Mutant$1;
-}
-interface RunPlan {
-  readonly plan: 'Run';
-  readonly mutant: Mutant$1;
-  readonly runOptions: MutantRunOptions;
-  readonly netTime: number;
-}
-type TestPlan = EarlyResultPlan | RunPlan;
-type MutantTestCoverage = Mutant$1 & {
-  readonly coveredBy: ReadonlyArray<string> | undefined;
-  readonly static: boolean | undefined;
-};
-type RunMutantResult = Mutant$1 & {
-  readonly status: MutantStatus;
-  readonly statusReason?: string | undefined;
-  readonly testsCompleted?: number | undefined;
-  readonly killedBy?: readonly string[] | undefined;
-  readonly coveredBy?: readonly string[] | undefined;
-  readonly static?: boolean | undefined;
-};
-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.brand<S.String, "MutantId">, S.Int>>;
-    readonly static: S.$Record<S.brand<S.String, "MutantId">, S.Int>;
-  }>>;
-  readonly hitCount: S.optional<S.Int>;
-  readonly hitLimit: S.optional<S.Int>;
-}>, {}>;
-declare class InstrumenterContext extends InstrumenterContext_base {
-  static readonly NAMESPACE = "__stryker__";
-  static readonly MUTATION_COVERAGE_OBJECT = "mutantCoverage";
-  static readonly ACTIVE_MUTANT = "activeMutant";
-  static readonly CURRENT_TEST_ID = "currentTestId";
-  static readonly HIT_COUNT = "hitCount";
-  static readonly HIT_LIMIT = "hitLimit";
-  static readonly ACTIVE_MUTANT_ENV_VARIABLE = "__STRYKER_ACTIVE_MUTANT__";
-}
-type MutantRunPlan = RunPlan;
-type MutantEarlyResultPlan = EarlyResultPlan;
-type MutantTestPlan = TestPlan;
-//#endregion
-//#region src/Mutator.service.d.ts
-interface Mutable {
-  mutatorName: string;
-  ignoreReason?: string | undefined;
-  replacement: Node_2;
-}
-interface Mutant extends Mutable {
-  readonly id: MutantId;
+//#region src/MutantIdentity.d.ts
+interface MutantTuple {
   readonly fileName: string;
-  readonly original: Node_2;
-  readonly location: Location;
+  readonly mutatorName: string;
+  readonly originalCode: string;
   readonly replacementCode: string;
 }
-interface MutatorOptions {
-  excludedMutations: string[];
-  optInMutations: readonly string[];
-  noHeader?: boolean;
-}
 //#endregion
 //#region src/Transformer.service.d.ts
 interface TransformerOptions extends MutatorOptions {
   ignorers: readonly Ignorer[];
 }
 interface MutantCollector {
-  readonly nextIndex: number;
-  readonly append: (mutants: readonly Mutant[]) => void;
-  readonly map: <A>(transform: (mutant: Mutant) => A) => readonly A[];
+  /** 0-based, counting this collector's earlier occurrences of the same tuple. */
+  readonly ordinalOf: (tuple: MutantTuple) => number;
+  readonly append: (mutants: readonly Mutant$1[]) => void;
+  readonly map: <A>(transform: (mutant: Mutant$1) => A) => readonly A[];
 }
 type AstTransformer<T extends Ast = Ast> = (ast: T, mutantCollector: MutantCollector, context: TransformerContext) => Effect.Effect<readonly string[], ParseFailed | InstrumentError>;
 interface TransformerContext {
@@ -1892,7 +1745,7 @@ interface File extends FileDescription {
 }
 interface InstrumentResult {
   files: readonly File[];
-  mutants: readonly Mutant$1[];
+  mutants: readonly Mutant.Mutant[];
   skipped: readonly InstrumentFileSkip[];
 }
 declare const instrument: {
@@ -1903,30 +1756,54 @@ declare const disableTypeChecks: {
   (file: File, registry?: FormatRegistry): Effect.Effect<File, InstrumentError>;
   (registry?: FormatRegistry): (file: File) => Effect.Effect<File, InstrumentError>;
 };
+//#endregion
+//#region src/InstrumentContext.schema.d.ts
+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.decodeTo<S.$Record<S.brand<S.String, "MutantId">, S.Int>, S.$Record<S.String, S.Int>, never, never>>;
+    readonly static: S.decodeTo<S.$Record<S.brand<S.String, "MutantId">, S.Int>, S.$Record<S.String, S.Int>, never, never>;
+  }>>;
+  readonly hitCount: S.optional<S.Int>;
+  readonly hitLimit: S.optional<S.Int>;
+}>, {}>;
+declare class InstrumenterContext extends InstrumenterContext_base {
+  static readonly NAMESPACE = "__stryker__";
+  static readonly MUTATION_COVERAGE_OBJECT = "mutantCoverage";
+  static readonly ACTIVE_MUTANT = "activeMutant";
+  static readonly CURRENT_TEST_ID = "currentTestId";
+  static readonly HIT_COUNT = "hitCount";
+  static readonly HIT_LIMIT = "hitLimit";
+  static readonly ACTIVE_MUTANT_ENV_VARIABLE = "__STRYKER_ACTIVE_MUTANT__";
+}
 declare namespace mod_d_exports$2 {
-  export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterOptions, MutateDescription, ParserOptions, disableTypeChecks, instrument };
+  export { File, FileDescription, FileDescriptions, InstrumentError, InstrumentFileSkip, InstrumentResult, InstrumenterContext, InstrumenterOptions, MutateDescription, ParserOptions, disableTypeChecks, instrument };
 }
 //#endregion
 //#region src/Location.d.ts
 export declare const lineStartsOf: (text: string) => LineStarts;
 export declare const positionAt: {
-  (lineStarts: LineStarts, offset: Offset): Position;
-  (offset: Offset): (lineStarts: LineStarts) => Position;
+  (lineStarts: LineStarts, offset: Offset): Mutant.Position;
+  (offset: Offset): (lineStarts: LineStarts) => Mutant.Position;
 };
 export declare const locationOf: {
-  (lineStarts: LineStarts, span: Span): Location;
-  (span: Span): (lineStarts: LineStarts) => Location;
+  (lineStarts: LineStarts, span: Span): Mutant.Location;
+  (span: Span): (lineStarts: LineStarts) => Mutant.Location;
 };
 export declare const originAt: {
   (lineStarts: LineStarts, offset: Offset): ScriptOrigin;
   (offset: Offset): (lineStarts: LineStarts) => ScriptOrigin;
 };
 export declare const offsetAt: {
-  (lineStarts: LineStarts, position: Position): Option.Option<Offset>;
-  (position: Position): (lineStarts: LineStarts) => Option.Option<Offset>;
+  (lineStarts: LineStarts, position: Mutant.Position): Option.Option<Offset>;
+  (position: Mutant.Position): (lineStarts: LineStarts) => Option.Option<Offset>;
 };
 declare namespace mod_d_exports$3 {
-  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, 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 };
+  export { Mutator, MutatorContext, MutatorEntry, MutatorRegistry, MutatorSelection, RegistryCatalog, RegistryContribution, defaultMutators, optInMutators, registryOf, selectMutators, stockRegistry };
+}
+declare namespace mod_d_exports$4 {
+  export { LineStarts, Offset, ScriptOrigin, Span };
 }
 //#endregion
-export { mod_d_exports as ErrorText, mod_d_exports$1 as Format, mod_d_exports$2 as Instrument, mod_d_exports$3 as Mutant };
+export { mod_d_exports as ErrorText, mod_d_exports$1 as Format, mod_d_exports$2 as Instrument, mod_d_exports$3 as Mutator, mod_d_exports$4 as Source };