@systemfsoftware/stryker-js-instrumenter 7.0.0 → 7.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 7.1.0
+
+### Minor Changes
+
+- Types that appear on the published CLI and instrumenter APIs are now exported.
+
 ## 7.0.0
 
 ### Major Changes

package/dist/Mutant-BYxuyyRL.d.mts

@@ -0,0 +1,163 @@
+import * as S from "effect/Schema";
+//#region src/Location.schema.d.ts
+declare const PositionSchema: S.Struct<{
+  readonly line: S.Finite;
+  readonly column: S.Finite;
+}>;
+type Position = typeof PositionSchema.Type;
+declare const LocationSchema: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+  readonly end: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+}>;
+type Location = typeof LocationSchema.Type;
+declare const OpenEndLocationSchema: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+  readonly end: S.optional<S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>>;
+}>;
+type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+//#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 Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
+  readonly id: S.NonEmptyString;
+  readonly fileName: S.NonEmptyString;
+  readonly mutatorName: S.NonEmptyString;
+  readonly replacement: S.String;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+  }>;
+  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>;
+}>, {}>;
+declare class Mutant extends Mutant_base {}
+declare const RunOptionsFields: {
+  timeout: S.Finite;
+  disableBail: S.Boolean;
+};
+declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
+type MutantActivation = typeof MutantActivationSchema.Type;
+declare const MutantRunOptionsSchema: S.Struct<{
+  readonly timeout: S.Finite;
+  readonly disableBail: S.Boolean;
+  readonly activeMutant: typeof Mutant;
+  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.Finite>;
+}>;
+//#endregion
+//#region src/Mutant.d.ts
+interface MutantCoverage {
+  readonly perTest: Record<string, Record<string, number>>;
+  readonly static: Record<string, number>;
+}
+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;
+  readonly sandboxFileName: string;
+  readonly mutantActivation: MutantActivation;
+  readonly reloadEnvironment: boolean;
+}
+interface EarlyResultPlan {
+  readonly plan: 'EarlyResult';
+  readonly mutant: Mutant;
+}
+interface RunPlan {
+  readonly plan: 'Run';
+  readonly mutant: Mutant;
+  readonly runOptions: MutantRunOptions;
+  readonly netTime: number;
+}
+type TestPlan = EarlyResultPlan | RunPlan;
+declare const isMutant: (value: unknown) => value is Mutant;
+type MutantTestCoverage = Mutant & {
+  readonly coveredBy: ReadonlyArray<string> | undefined;
+  readonly static: boolean | undefined;
+};
+type RunMutantResult = Mutant & {
+  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 INSTRUMENTER_CONSTANTS: Readonly<{
+  NAMESPACE: '__stryker__';
+  MUTATION_COVERAGE_OBJECT: 'mutantCoverage';
+  ACTIVE_MUTANT: 'activeMutant';
+  CURRENT_TEST_ID: 'currentTestId';
+  HIT_COUNT: 'hitCount';
+  HIT_LIMIT: 'hitLimit';
+  ACTIVE_MUTANT_ENV_VARIABLE: '__STRYKER_ACTIVE_MUTANT__';
+}>;
+interface InstrumenterContext {
+  activeMutant?: string;
+  currentTestId?: string;
+  mutantCoverage?: MutantCoverage;
+  hitCount?: number;
+  hitLimit?: number;
+}
+declare function normalizeFileName(fileName: string): string;
+interface ErrnoException extends Error {
+  code?: string;
+  errno?: number;
+  path?: string;
+  syscall?: string;
+}
+declare function isErrnoException(error: unknown): error is ErrnoException;
+declare function errorToString(error: unknown): string;
+declare const ERROR_CODES: Readonly<{
+  NoSuchFileOrDirectory: 'ENOENT';
+}>;
+interface MutationRange {
+  readonly start: Position;
+  readonly end: Position;
+}
+type MutateDescription = ReadonlyArray<MutationRange> | boolean;
+interface FileDescription {
+  readonly mutate: MutateDescription;
+}
+type FileDescriptions = Record<string, FileDescription>;
+type MutantRunPlan = RunPlan;
+type MutantEarlyResultPlan = EarlyResultPlan;
+type MutantTestPlan = TestPlan;
+declare const causeText: (cause: unknown, depth: number) => string | undefined;
+//#endregion
+export { MutantActivationSchema as A, PositionSchema as B, causeText as C, normalizeFileName as D, isMutant as E, Location as F, LocationSchema as I, OpenEndLocation as L, MutantStatus as M, MutantStatusSchema as N, Mutant as O, RunOptionsFields as P, OpenEndLocationSchema as R, TestPlan as S, isErrnoException as T, MutateDescription as _, EarlyResultPlan as a, RunOptions as b, FileDescriptions as c, MutantCoverage as d, MutantEarlyResultPlan as f, MutantTestPlan as g, MutantTestCoverage as h, ERROR_CODES as i, MutantRunOptionsSchema as j, MutantActivation as k, INSTRUMENTER_CONSTANTS as l, MutantRunPlan as m, CoverageData as n, ErrnoException as o, MutantRunOptions as p, CoveragePerTestId as r, FileDescription as s, Coverage as t, InstrumenterContext as u, MutationRange as v, errorToString as w, RunPlan as x, RunMutantResult as y, Position as z };

package/dist/Mutant-DnhV_fpo.mjs

@@ -0,0 +1,128 @@
+import * as Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+//#region src/Location.schema.ts
+const PositionSchema = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const LocationSchema = S.Struct({
+	start: PositionSchema,
+	end: PositionSchema
+});
+const OpenEndLocationSchema = S.Struct({
+	start: PositionSchema,
+	end: S.optional(PositionSchema)
+});
+//#endregion
+//#region src/Mutant.schema.ts
+const MutantStatusSchema = S.Literals([
+	"Killed",
+	"Survived",
+	"NoCoverage",
+	"CompileError",
+	"RuntimeError",
+	"Timeout",
+	"Ignored",
+	"Pending"
+]);
+var Mutant = class extends S.TaggedClass()("Mutant", {
+	id: S.NonEmptyString,
+	fileName: S.NonEmptyString,
+	mutatorName: S.NonEmptyString,
+	replacement: S.String,
+	location: LocationSchema,
+	status: S.optional(MutantStatusSchema),
+	statusReason: S.optional(S.String),
+	coveredBy: S.optional(S.Array(S.String)),
+	static: S.optional(S.Boolean),
+	testsCompleted: S.optional(S.Finite),
+	description: S.optional(S.String)
+}) {};
+const RunOptionsFields = {
+	timeout: S.Finite,
+	disableBail: S.Boolean
+};
+const MutantActivationSchema = S.Literals(["runtime", "static"]);
+const MutantRunOptionsSchema = S.Struct({
+	...RunOptionsFields,
+	activeMutant: Mutant,
+	sandboxFileName: S.String,
+	mutantActivation: MutantActivationSchema,
+	reloadEnvironment: S.Boolean,
+	testFilter: S.optionalKey(S.Array(S.String)),
+	hitLimit: S.optionalKey(S.Finite)
+});
+//#endregion
+//#region src/Mutant.ts
+const isMutant = (value) => S.is(Mutant)(value);
+const INSTRUMENTER_CONSTANTS = Object.freeze({
+	NAMESPACE: "__stryker__",
+	MUTATION_COVERAGE_OBJECT: "mutantCoverage",
+	ACTIVE_MUTANT: "activeMutant",
+	CURRENT_TEST_ID: "currentTestId",
+	HIT_COUNT: "hitCount",
+	HIT_LIMIT: "hitLimit",
+	ACTIVE_MUTANT_ENV_VARIABLE: "__STRYKER_ACTIVE_MUTANT__"
+});
+function normalizeFileName(fileName) {
+	return fileName.replace(/\\/g, "/");
+}
+const hasText = (value) => Predicate.isString(value) && value.length > 0;
+const textIfNonEmpty = (value) => Option.getOrUndefined(Option.filter(Option.fromUndefinedOr(value), hasText));
+const fieldOf = (value, key) => Match.value(key in value).pipe(Match.when(true, () => {
+	return Reflect.get(value, key);
+}), Match.orElse(() => void 0));
+const hasStringCode = (error) => Match.value(fieldOf(error, "code")).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
+function isErrnoException(error) {
+	return Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
+}
+const isEmptyNumber = (value) => Match.value(value).pipe(Match.when(0, () => true), Match.orElse(Number.isNaN));
+const isEmptyError = (error) => Match.value(error).pipe(Match.when(Match.undefined, () => true), Match.when(Match.null, () => true), Match.when(Match.string, (text) => text.length === 0), Match.when(Match.number, isEmptyNumber), Match.when(Match.boolean, (value) => !value), Match.orElse(() => false));
+const formatErrnoException = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), Match.orElse(() => `${error.name}: ${error.code} (${error.syscall})`));
+const formatError = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.message}\n${stack}`), Match.orElse(() => `${error.name}: ${error.message}`));
+const isJsonPrimitive = (value) => Match.value(value).pipe(Match.when(Match.number, () => true), Match.when(Match.boolean, () => true), Match.when(Match.bigint, () => true), Match.orElse(() => false));
+const jsonText = (error) => {
+	try {
+		return textIfNonEmpty(JSON.stringify(error));
+	} catch {
+		return;
+	}
+};
+const isNonPlaceholderText = (text) => Match.value({
+	hasLength: text.length > 0,
+	isPlaceholder: text === "[object Object]"
+}).pipe(Match.when({
+	hasLength: true,
+	isPlaceholder: false
+}, () => true), Match.orElse(() => false));
+const isUsableText = (value) => Match.value(value).pipe(Match.when(Match.string, isNonPlaceholderText), Match.orElse(() => false));
+const usableText = (value) => Match.value(value).pipe(Match.when(isUsableText, (text) => text), Match.orElse(() => ""));
+const objectToStringText = (value) => Match.value(fieldOf(value, "toString")).pipe(Match.when(Match.instanceOf(Function), (callable) => {
+	try {
+		return usableText(Reflect.apply(callable, value, []));
+	} catch {
+		return "";
+	}
+}), Match.orElse(() => ""));
+const isObjectType = (cause) => typeof cause === "object";
+const toStringText = (error) => Match.value(error).pipe(Match.when(Match.null, () => ""), Match.when(isObjectType, (value) => objectToStringText(value)), Match.orElse(() => ""));
+const stringifyRest = (error) => Match.value(jsonText(error)).pipe(Match.when(hasText, (json) => json), Match.orElse(() => toStringText(error)));
+const stringifyNonError = (error) => Match.value(error).pipe(Match.when(Match.string, (text) => text), Match.when(isJsonPrimitive, (primitive) => JSON.stringify(primitive)), Match.orElse(() => stringifyRest(error)));
+const errorText = (error) => Match.value(error).pipe(Match.when(isErrnoException, formatErrnoException), Match.orElse(() => formatError(error)));
+function errorToString(error) {
+	return Match.value(error).pipe(Match.when(isEmptyError, () => ""), Match.when(Match.instanceOf(Error), errorText), Match.orElse(() => stringifyNonError(error)));
+}
+const ERROR_CODES = Object.freeze({ NoSuchFileOrDirectory: "ENOENT" });
+const errorNameOf = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), (error) => textIfNonEmpty(error.name)), Match.orElse(() => void 0));
+const tagOf = (value) => Match.value(textIfNonEmpty(fieldOf(value, "_tag"))).pipe(Match.when(hasText, (tag) => tag), Match.orElse(() => errorNameOf(value)));
+const textWithNested = (own, nested) => Match.value(own).pipe(Match.when(hasText, (text) => appendNested(text, nested)), Match.orElse(() => nested));
+const appendNested = (own, nested) => Match.value(nested).pipe(Match.when(hasText, (text) => `${own}: ${text}`), Match.orElse(() => own));
+const errorMessage = (error) => Match.value(error.message.length > 0).pipe(Match.when(true, () => error.message), Match.orElse(() => tagOf(error)));
+const errorMessageOrTag = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), errorMessage), Match.orElse(() => tagOf(value)));
+const messageText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "message"))).pipe(Match.when(hasText, (message) => message), Match.orElse(() => errorMessageOrTag(value)));
+const ownCauseText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "reason"))).pipe(Match.when(hasText, (reason) => reason), Match.orElse(() => messageText(value)));
+const causeText = (cause, depth) => Match.value(cause).pipe(Match.when(() => depth > 4, () => void 0), Match.when(Match.undefined, () => void 0), Match.when(Match.null, () => void 0), Match.when(Match.string, textIfNonEmpty), Match.when(isObjectType, (value) => textWithNested(ownCauseText(value), causeText(fieldOf(value, "cause"), depth + 1))), Match.orElse(() => void 0));
+//#endregion
+export { isErrnoException as a, Mutant as c, MutantStatusSchema as d, RunOptionsFields as f, PositionSchema as h, errorToString as i, MutantActivationSchema as l, OpenEndLocationSchema as m, INSTRUMENTER_CONSTANTS as n, isMutant as o, LocationSchema as p, causeText as r, normalizeFileName as s, ERROR_CODES as t, MutantRunOptionsSchema as u };

package/dist/index.d.mts

@@ -1,22 +1,73 @@
 import * as Effect from 'effect/Effect';
-import { FileDescription } from '@systemfsoftware/stryker-js-language';
-import { Mutant } from '@systemfsoftware/stryker-js-language';
 import * as S from 'effect/Schema';
 import { YieldableError } from 'effect/Cause';
 
+export declare const causeText: (cause: unknown, depth: number) => string | undefined;
+
+export declare interface Coverage {
+    readonly static: CoverageData;
+    readonly perTest: CoveragePerTestId;
+}
+
+export declare type CoverageData = Record<string, number>;
+
+export declare type CoveragePerTestId = Record<string, CoverageData>;
+
 export declare const disableTypeChecks: (file: File_2) => Effect.Effect<File_2, InstrumentError>;
 
+export declare interface EarlyResultPlan {
+    readonly plan: 'EarlyResult';
+    readonly mutant: Mutant;
+}
+
+export declare interface ErrnoException extends Error {
+    code?: string;
+    errno?: number;
+    path?: string;
+    syscall?: string;
+}
+
+export declare const ERROR_CODES: Readonly<{
+    NoSuchFileOrDirectory: 'ENOENT';
+}>;
+
+export declare function errorToString(error: unknown): string;
+
 declare interface File_2 extends FileDescription {
     name: string;
     content: string;
 }
 export { File_2 as File }
 
-export declare const instrument: (files: readonly File_2[], options: InstrumenterOptions, basePath?: string) => Effect.Effect<InstrumentResult$1, InstrumentError>;
+export declare interface FileDescription {
+    readonly mutate: MutateDescription;
+}
+
+export declare type FileDescriptions = Record<string, FileDescription>;
+
+export declare const instrument: (files: readonly File_2[], options: InstrumenterOptions, basePath?: string) => Effect.Effect<InstrumentResult, InstrumentError>;
+
+export declare const INSTRUMENTER_CONSTANTS: Readonly<{
+    NAMESPACE: '__stryker__';
+    MUTATION_COVERAGE_OBJECT: 'mutantCoverage';
+    ACTIVE_MUTANT: 'activeMutant';
+    CURRENT_TEST_ID: 'currentTestId';
+    HIT_COUNT: 'hitCount';
+    HIT_LIMIT: 'hitLimit';
+    ACTIVE_MUTANT_ENV_VARIABLE: '__STRYKER_ACTIVE_MUTANT__';
+}>;
+
+export declare interface InstrumenterContext {
+    activeMutant?: string;
+    currentTestId?: string;
+    mutantCoverage?: MutantCoverage;
+    hitCount?: number;
+    hitLimit?: number;
+}
 
 export declare type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
 
-declare const InstrumenterOptionsSchema: S.Struct<{
+export declare const InstrumenterOptionsSchema: S.Struct<{
     readonly excludedMutations: S.$Array<S.String>;
     readonly ignorers: S.$Array<S.Unknown>;
     readonly noHeader: S.optional<S.Boolean>;
@@ -31,31 +82,154 @@ declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"Ins
     readonly cause: S.Defect;
 }>, YieldableError>;
 
-declare class InstrumentResult$1 extends InstrumentResult_base {}
-
 export declare interface InstrumentResult {
     files: readonly File_2[];
     mutants: readonly Mutant[];
 }
 
-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.Finite;
-                readonly column: S.Finite;
-            }>;
-            readonly end: S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>;
-        }>>]>;
-    }>>;
-    readonly mutants: S.$Array<typeof Mutant>;
+export declare function isErrnoException(error: unknown): error is ErrnoException;
+
+export declare const isMutant: (value: unknown) => value is Mutant;
+
+export declare type Location = typeof LocationSchema.Type;
+
+export declare const LocationSchema: S.Struct<{
+    readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+    }>;
+    readonly end: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+    }>;
+}>;
+
+export declare class Mutant extends Mutant_base {}
+
+declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
+    readonly id: S.NonEmptyString;
+    readonly fileName: S.NonEmptyString;
+    readonly mutatorName: S.NonEmptyString;
+    readonly replacement: S.String;
+    readonly location: S.Struct<{
+        readonly start: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+        }>;
+        readonly end: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+        }>;
+    }>;
+    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>;
 }>, {}>;
 
+export declare type MutantActivation = typeof MutantActivationSchema.Type;
+
+export declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
+
+export declare interface MutantCoverage {
+    readonly perTest: Record<string, Record<string, number>>;
+    readonly static: Record<string, number>;
+}
+
+export declare type MutantEarlyResultPlan = EarlyResultPlan;
+
+export declare interface MutantRunOptions extends RunOptions {
+    readonly testFilter?: readonly string[];
+    readonly hitLimit?: number;
+    readonly activeMutant: Mutant;
+    readonly sandboxFileName: string;
+    readonly mutantActivation: MutantActivation;
+    readonly reloadEnvironment: boolean;
+}
+
+export declare const MutantRunOptionsSchema: S.Struct<{
+    readonly timeout: S.Finite;
+    readonly disableBail: S.Boolean;
+    readonly activeMutant: typeof Mutant;
+    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.Finite>;
+}>;
+
+export declare type MutantRunPlan = RunPlan;
+
+export declare type MutantStatus = typeof MutantStatusSchema.Type;
+
+export declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+
+export declare type MutantTestCoverage = Mutant & {
+    readonly coveredBy: ReadonlyArray<string> | undefined;
+    readonly static: boolean | undefined;
+};
+
+export declare type MutantTestPlan = TestPlan;
+
+export declare type MutateDescription = ReadonlyArray<MutationRange> | boolean;
+
+export declare interface MutationRange {
+    readonly start: Position;
+    readonly end: Position;
+}
+
+export declare function normalizeFileName(fileName: string): string;
+
+export declare type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+
+export declare const OpenEndLocationSchema: S.Struct<{
+    readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+    }>;
+    readonly end: S.optional<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+    }>>;
+}>;
+
 export declare interface ParserOptions {}
 
+export declare type Position = typeof PositionSchema.Type;
+
+export declare const PositionSchema: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+}>;
+
+export declare type RunMutantResult = Mutant & {
+    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;
+};
+
+export declare interface RunOptions {
+    readonly timeout: number;
+    readonly disableBail: boolean;
+}
+
+export declare const RunOptionsFields: {
+    timeout: S.Finite;
+    disableBail: S.Boolean;
+};
+
+export declare interface RunPlan {
+    readonly plan: 'Run';
+    readonly mutant: Mutant;
+    readonly runOptions: MutantRunOptions;
+    readonly netTime: number;
+}
+
+export declare type TestPlan = EarlyResultPlan | RunPlan;
+
 export { }

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js-language";
+import { a as isErrnoException, c as Mutant, d as MutantStatusSchema, f as RunOptionsFields, h as PositionSchema, i as errorToString, l as MutantActivationSchema, m as OpenEndLocationSchema, n as INSTRUMENTER_CONSTANTS, o as isMutant, p as LocationSchema, r as causeText, s as normalizeFileName, t as ERROR_CODES, u as MutantRunOptionsSchema } from "./Mutant-DnhV_fpo.mjs";
 import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
 import * as S from "effect/Schema";
@@ -18,13 +18,13 @@ var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-i
 		return this.message;
 	}
 };
-const PositionSchema = S.Struct({
+const PositionSchema$1 = S.Struct({
 	line: S.Finite,
 	column: S.Finite
 });
 const RangeSchema = S.Struct({
-	start: PositionSchema,
-	end: PositionSchema
+	start: PositionSchema$1,
+	end: PositionSchema$1
 });
 const MutateDescriptionSchema = S.Union([S.Boolean, S.Array(RangeSchema)]);
 const FileSchema = S.Struct({
@@ -33,7 +33,7 @@ const FileSchema = S.Struct({
 	mutate: MutateDescriptionSchema
 });
 const IgnorerSchema = S.Unknown;
-S.Struct({
+const InstrumenterOptionsSchema = S.Struct({
 	excludedMutations: S.Array(S.String),
 	ignorers: S.Array(IgnorerSchema),
 	noHeader: S.optional(S.Boolean)
@@ -52,6 +52,9 @@ S.Literals([
 //#endregion
 //#region src/Syntax.ts
 /**
+* Syntax — the instrumenter's AST shapes, location helpers and syntax utilities.
+*/
+/**
 * Determines if a location (needle) is included in an other location (haystack)
 * @param haystack The range to look in
 * @param needle the range to search for
@@ -5126,4 +5129,4 @@ const instrument = (files, options, basePath) => Effect.gen(function* () {
 	});
 });
 //#endregion
-export { disableTypeChecks, instrument };
+export { ERROR_CODES, INSTRUMENTER_CONSTANTS, InstrumenterOptionsSchema, LocationSchema, Mutant, MutantActivationSchema, MutantRunOptionsSchema, MutantStatusSchema, OpenEndLocationSchema, PositionSchema, RunOptionsFields, causeText, disableTypeChecks, errorToString, instrument, isErrnoException, isMutant, normalizeFileName };

package/dist/mutants.d.mts

@@ -0,0 +1,2 @@
+import { A as MutantActivationSchema, B as PositionSchema, C as causeText, D as normalizeFileName, E as isMutant, F as Location, I as LocationSchema, L as OpenEndLocation, M as MutantStatus, N as MutantStatusSchema, O as Mutant, P as RunOptionsFields, R as OpenEndLocationSchema, S as TestPlan, T as isErrnoException, _ as MutateDescription, a as EarlyResultPlan, b as RunOptions, c as FileDescriptions, d as MutantCoverage, f as MutantEarlyResultPlan, g as MutantTestPlan, h as MutantTestCoverage, i as ERROR_CODES, j as MutantRunOptionsSchema, k as MutantActivation, l as INSTRUMENTER_CONSTANTS, m as MutantRunPlan, n as CoverageData, o as ErrnoException, p as MutantRunOptions, r as CoveragePerTestId, s as FileDescription, t as Coverage, u as InstrumenterContext, v as MutationRange, w as errorToString, x as RunPlan, y as RunMutantResult, z as Position } from "./Mutant-BYxuyyRL.mjs";
+export { type Coverage, type CoverageData, type CoveragePerTestId, ERROR_CODES, type EarlyResultPlan, type ErrnoException, type FileDescription, type FileDescriptions, INSTRUMENTER_CONSTANTS, type InstrumenterContext, type Location, LocationSchema, Mutant, type MutantActivation, MutantActivationSchema, type MutantCoverage, type MutantEarlyResultPlan, type MutantRunOptions, MutantRunOptionsSchema, type MutantRunPlan, type MutantStatus, MutantStatusSchema, type MutantTestCoverage, type MutantTestPlan, type MutateDescription, type MutationRange, type OpenEndLocation, OpenEndLocationSchema, type Position, PositionSchema, type RunMutantResult, type RunOptions, RunOptionsFields, type RunPlan, type TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName };

package/dist/mutants.mjs

@@ -0,0 +1,2 @@
+import { a as isErrnoException, c as Mutant, d as MutantStatusSchema, f as RunOptionsFields, h as PositionSchema, i as errorToString, l as MutantActivationSchema, m as OpenEndLocationSchema, n as INSTRUMENTER_CONSTANTS, o as isMutant, p as LocationSchema, r as causeText, s as normalizeFileName, t as ERROR_CODES, u as MutantRunOptionsSchema } from "./Mutant-DnhV_fpo.mjs";
+export { ERROR_CODES, INSTRUMENTER_CONSTANTS, LocationSchema, Mutant, MutantActivationSchema, MutantRunOptionsSchema, MutantStatusSchema, OpenEndLocationSchema, PositionSchema, RunOptionsFields, causeText, errorToString, isErrnoException, isMutant, normalizeFileName };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-instrumenter",
-  "version": "7.0.0",
+  "version": "7.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -18,6 +18,10 @@
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
     },
+    "./mutants": {
+      "types": "./dist/mutants.d.mts",
+      "default": "./dist/mutants.mjs"
+    },
     "./package.json": "./package.json"
   },
   "license": "Apache-2.0",
@@ -28,8 +32,7 @@
     "angular-html-parser": "~10.4.0",
     "effect": "4.0.0-rc.112",
     "oxc-parser": "^0.140.0",
-    "oxc-walker": "^1",
-    "@systemfsoftware/stryker-js-language": "^5.0.0"
+    "oxc-walker": "^1"
   },
   "devDependencies": {
     "@effect/tsgo": "^0.45.0",
@@ -45,9 +48,9 @@
     "tsdown": "^0.23.0",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/vitest-config": "^0.1.0",
     "@systemfsoftware/tsdown-config": "^0.1.0",
-    "@systemfsoftware/stryker-ignorer-interface": "^0.1.0"
+    "@systemfsoftware/stryker-ignorer-interface": "^0.1.0",
+    "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "engines": {
     "node": ">=20.0.0"