@systemfsoftware/stryker-js-instrumenter 9.0.1 → 10.0.1

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 10.0.1
+
+### Patch Changes
+
+- The packages now depend on `@systemfsoftware/effect-cell-types` 11.
+
+  - Every tagged error now has a one-line message built from its fields, so a failure names the file, mutant, plugin, worker or exit code involved instead of an empty message. The errors' tags, fields and encoded forms are unchanged.
+
+## 10.0.0
+
+### Major Changes
+
+- Rendering a caught cause is a function now, not a method on a schema class. `ErrorText.errorTextOf(cause)` and `ErrorText.causeTextOf(cause)` replace `ErrorText.ErrorText.fromCause(cause)` and `ErrorText.CauseText.fromCause(cause)`.
+
+  Replace the two calls: `ErrorText.ErrorText.fromCause(cause)` becomes `ErrorText.errorTextOf(cause)`, and `ErrorText.CauseText.fromCause(cause)` becomes `ErrorText.causeTextOf(cause)`. Both return the same `Option.Option<ErrorText>` and `Option.Option<CauseText>` as before. The `ErrorText` and `CauseText` classes, their value types, and `ErrnoException` are unchanged.
+
+- File names handed to `instrument` are canonicalized: a backslash in an input path is folded to `/`, in the returned file names and in each mutant's file name alike. A result now reports one spelling of a path, matching the spelling `Mutant.fileName` already used, instead of echoing whatever separator the caller passed.
+
+  No call-site change is needed — keep passing plain strings to `instrument`.
+
+- Mutant ids are decimal index strings. Every schema that carried a mutant id as a plain string now decodes `Mutant.MutantId` and refuses anything else: the mutation report and its mutant results, reporter events (`mutationTestingPlanReady` plans, `mutantTested`), the machine run stream (`mutant` and `verdict`), the survivors prior report, and the mutant coverage keys produced by test runners.
+
+  Mutant ids are minted only as the mutant's canonical non-negative decimal index (`Mutant.MutantId`), including in the instrumenter's planned mutants, placement sites, and checker answers. Consume the new `Mutant.MutantId` schema instead of assuming an arbitrary non-empty string; ids such as `constructor` or `__proto__` no longer decode.
+
+- A mutant's status is declared once, as the eight-value `Mutant.MutantStatus`, plus the named subsets a run partitions on: `Mutant.SurvivorStatus`, `Mutant.RememberedStatus`, `Mutant.EphemeralStatus`, and `Mutant.ActionableStatus`. Import the subset your decision matches instead of re-listing the statuses you accept.
+
+  Mutants are tagged structs now. A status reason decodes only together with a status, and the remembered-mutant and ignored-mutant rows carry the same narrowed status as the subset they were selected by.
+
+- Source locations are 1-based and validated end to end. `Mutant.Location`, `Mutant.Position`, `Mutant.Span`, `Mutant.OpenEndLocation`, `Mutant.ScriptOrigin`, and `Mutant.LineStarts` replace the former `LocationSchema`, `PositionSchema`, and `OpenEndLocationSchema`; a location whose end precedes its start, or a line or column below 1, no longer decodes.
+
+  - A mutant location always speaks the report contract, so a producer that minted 0-based coordinates or a bare number must switch to the new schemas.
+  - An embedded script's origin is a `ScriptOrigin` (1-based line plus a column shift), not a position.
+  - Incremental state from releases that stored the earlier column base is no longer matched: those mutants are re-tested, not reused, while the run rewrites the state.
+
+### Patch Changes
+
+- Stages now run as cells over workflows, multi-item work runs as Effect streams, pools and worker transport use scoped Effect resources, and named operations are traced with Effect.fn. The Angular ignorer now declares @systemfsoftware/stryker-ignorer-kit as a runtime dependency.
+
 ## 9.0.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,8 +1,9 @@
 import * as Option from "effect/Option";
-import "effect/Result";
+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 * as Arr from "effect/Array";
 import { EmbeddedDocument, FormatId, Framework, FrameworkContext } from "@systemfsoftware/stryker-framework-interface";
 import "oxc-parser";
 import "@oxc-project/types";
@@ -10,16 +11,12 @@ import "@oxc-project/types";
 declare const ErrorText_base: S.Class<ErrorText, S.Struct<{
   readonly text: S.NonEmptyString;
 }>, {}>;
-declare class ErrorText extends ErrorText_base {
-  static fromCause: <A>(cause: A) => Option.Option<ErrorText>;
-}
+declare class ErrorText extends ErrorText_base {}
 type ErrorTextValue = ErrorText;
 declare const CauseText_base: S.Class<CauseText, S.Struct<{
   readonly text: S.NonEmptyString;
 }>, {}>;
-declare class CauseText extends CauseText_base {
-  static fromCause: <A>(cause: A) => Option.Option<CauseText>;
-}
+declare class CauseText extends CauseText_base {}
 type CauseTextValue = CauseText;
 interface ErrnoException extends Error {
   code?: string;
@@ -27,8 +24,12 @@ interface ErrnoException extends Error {
   path?: string;
   syscall?: string;
 }
+//#endregion
+//#region src/error-text.d.ts
+declare const errorTextOf: <A = unknown>(cause: A) => Option.Option<ErrorText>;
+declare const causeTextOf: <A = unknown>(cause: A) => Option.Option<CauseText>;
 declare namespace mod_d_exports {
-  export { CauseText, CauseTextValue, ErrnoException, ErrorText, ErrorTextValue };
+  export { CauseText, CauseTextValue, ErrnoException, ErrorText, ErrorTextValue, causeTextOf, errorTextOf };
 }
 //#endregion
 //#region ../ignorers/interface/dist/index.d.ts
@@ -1338,54 +1339,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"]>;
@@ -1403,7 +1423,7 @@ interface BaseAst {
   originFileName: string;
   rawContent: string;
   root: Program;
-  offset?: Position;
+  offset?: ScriptOrigin;
 }
 interface EmbeddedAst {
   format: 'embedded';
@@ -1436,29 +1456,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.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>;
@@ -1466,15 +1646,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;
@@ -1482,10 +1687,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;
@@ -1493,8 +1730,8 @@ declare const MutantRunOptionsSchema: S.Struct<{
   readonly hitLimit: S.optionalKey<S.Int>;
 }>;
 declare const MutantCoverageSchema: 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.Type;
 type CoverageData = Record<string, number>;
@@ -1542,11 +1779,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__";
@@ -1561,92 +1798,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.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;
@@ -1654,7 +1805,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;
@@ -1753,10 +1904,29 @@ declare const disableTypeChecks: {
   (registry?: FormatRegistry): (file: File) => Effect.Effect<File, InstrumentError>;
 };
 declare namespace mod_d_exports$2 {
-  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 };
 }
+//#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;
+};
+export declare const locationOf: {
+  (lineStarts: LineStarts, span: Span): Location;
+  (span: Span): (lineStarts: LineStarts) => 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>;
+};
 declare namespace mod_d_exports$3 {
-  export { CanonicalFileName, CanonicalFileName as CanonicalFileNameValue, Coverage, CoverageData, CoveragePerTestId, EarlyResultPlan, InstrumenterContext, Location, LocationSchema, 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, 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, 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
 export { mod_d_exports as ErrorText, mod_d_exports$1 as Format, mod_d_exports$2 as Instrument, mod_d_exports$3 as Mutant };