@systemfsoftware/stryker-js 13.1.0 → 15.0.0

package/dist/RunEnvironment.service-B1bsWOQ9.d.mts

@@ -0,0 +1,2927 @@
+import { a as mod_d_exports$6, c as mod_d_exports$9, d as Program$2, f as Statement, i as mod_d_exports$5, l as Ignorer$1, n as mod_d_exports$2$1, o as mod_d_exports$7, r as mod_d_exports$4, s as mod_d_exports$8, t as mod_d_exports$3 } from "./index-Cf9G6kA8.mjs";
+import "./Run.schema-B1HZugu9.mjs";
+import { Cell, Handle, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
+import * as S from "effect/Schema";
+import * as Option$1 from "effect/Option";
+import * as Context from "effect/Context";
+import { Schema } from "effect";
+import * as Effect$1 from "effect/Effect";
+import * as RpcGroup from "effect/rpc/RpcGroup";
+import "effect/Array";
+import * as Result from "effect/Result";
+import * as Cause from "effect/Cause";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
+import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
+import * as Scope from "effect/Scope";
+import * as HashMap from "effect/HashMap";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as EffectDuration from "effect/Duration";
+import * as RpcClient from "effect/rpc/RpcClient";
+import * as Stdio from "effect/Stdio";
+import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
+import { RpcClientError } from "effect/rpc/RpcClientError";
+import * as Socket from "effect/socket/Socket";
+import { PlatformError } from "effect/PlatformError";
+import * as MutableHashSet from "effect/MutableHashSet";
+import "effect/Console";
+import "effect/Runtime";
+//#region src/Worker.schema.d.ts
+/**
+ * The child process hosting a worker ended when it was not supposed to.
+ */
+declare const WorkerExitTypeId: unique symbol;
+type WorkerExitTypeId = typeof WorkerExitTypeId;
+declare const ChildProcessCrashedError_base: Schema.Class<ChildProcessCrashedError, Schema.TaggedStruct<"ChildProcessCrashedError", {
+  readonly pid: Schema.Int;
+  readonly exit: Schema.Union<readonly [Schema.TaggedStruct<"Code", {
+    readonly code: Schema.Int;
+  }>, Schema.TaggedStruct<"Signal", {
+    readonly signal: Schema.NonEmptyString;
+  }>]>;
+  readonly cause: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class ChildProcessCrashedError extends ChildProcessCrashedError_base {
+  readonly [WorkerExitTypeId]: symbol;
+  readonly exitClass: 'InternalError';
+  get message(): string;
+}
+declare const OutOfMemoryError_base: Schema.Class<OutOfMemoryError, Schema.TaggedStruct<"OutOfMemoryError", {
+  readonly pid: Schema.Int;
+  readonly exitCode: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class OutOfMemoryError extends OutOfMemoryError_base {
+  readonly [WorkerExitTypeId]: symbol;
+  readonly exitClass: 'RuntimeError';
+  get message(): string;
+}
+type WorkerExit = ChildProcessCrashedError | OutOfMemoryError;
+type WorkerBootError = WorkerExit | WorkerBootTimeoutError;
+declare const WorkerBootTimeoutError_base: Schema.Class<WorkerBootTimeoutError, Schema.TaggedStruct<"WorkerBootTimeoutError", {
+  readonly pid: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+declare class WorkerBootTimeoutError extends WorkerBootTimeoutError_base {
+  readonly exitClass: 'InternalError';
+  get message(): string;
+}
+//#endregion
+//#region src/ConfigError.schema.d.ts
+declare const ConfigFileNotFoundError_base: S.Class<ConfigFileNotFoundError, S.TaggedStruct<"ConfigFileNotFoundError", {
+  readonly file: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
+  readonly exitClass: 'ConfigError';
+  get message(): string;
+}
+declare const ConfigFileUnsupportedError_base: S.Class<ConfigFileUnsupportedError, S.TaggedStruct<"ConfigFileUnsupportedError", {
+  readonly file: S.String;
+  readonly hint: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileUnsupportedError extends ConfigFileUnsupportedError_base {
+  readonly exitClass: 'ConfigError';
+  get message(): string;
+}
+declare const ConfigFileUnreadableError_base: S.Class<ConfigFileUnreadableError, S.TaggedStruct<"ConfigFileUnreadableError", {
+  readonly file: S.String;
+  readonly cause: S.Unknown;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileUnreadableError extends ConfigFileUnreadableError_base {
+  readonly exitClass: 'ConfigError';
+  get message(): string;
+}
+declare const ConfigFileInvalidError_base: S.Class<ConfigFileInvalidError, S.TaggedStruct<"ConfigFileInvalidError", {
+  readonly file: S.String;
+  readonly cause: S.Unknown;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigFileInvalidError extends ConfigFileInvalidError_base {
+  readonly exitClass: 'ConfigError';
+  get message(): string;
+}
+declare const ConfigError_base: S.Class<ConfigError, S.TaggedStruct<"ConfigError", {
+  readonly message: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ConfigError extends ConfigError_base {
+  readonly exitClass: 'ConfigError';
+}
+//#endregion
+//#region src/stryker-error.schema.d.ts
+declare const StrykerError_base: Schema.Class<StrykerError, Schema.TaggedStruct<"StrykerError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class StrykerError extends StrykerError_base {}
+//#endregion
+//#region ../stryker-js-cli-contract/dist/index.d.mts
+//#region src/output-mode.schema.d.ts
+declare const OutputMode: S.Literals<readonly ["human", "machine"]>;
+type OutputMode = typeof OutputMode.Type;
+declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+type ModeSignal = typeof ModeSignal.Type;
+declare namespace mod_d_exports {
+  export { ModeSignal, OutputMode };
+}
+//#endregion
+//#region src/plugin-load-failure-reason.schema.d.ts
+declare const PluginLoadFailureReason: Schema.Union<readonly [Schema.TaggedStruct<"PeerMissing", {
+  readonly peer: Schema.String;
+}>, Schema.TaggedStruct<"PeerVersionUnsupported", {
+  readonly peer: Schema.String;
+  readonly detail: Schema.String;
+}>, Schema.TaggedStruct<"PeerUnrecognized", {
+  readonly peer: Schema.String;
+}>, Schema.TaggedStruct<"InvalidContribution", {
+  readonly detail: Schema.String;
+}>, Schema.TaggedStruct<"ImportFailed", {
+  readonly cause: Schema.Unknown;
+}>]>;
+type PluginLoadFailureReason = typeof PluginLoadFailureReason.Type;
+//#endregion
+//#region src/run-event.schema.d.ts
+declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+type RunPhase = typeof RunPhase.Type;
+declare const RunId: S.brand<S.String, "RunId">;
+type RunId = typeof RunId.Type;
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly runId: S.brand<S.String, "RunId">;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>, {}>;
+declare class RunStarted extends RunStarted_base {}
+declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
+  readonly phase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+  readonly elapsedMs: S.Finite;
+}>, {}>;
+declare class PhaseEntered extends PhaseEntered_base {}
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+  readonly total: S.Int;
+}>, {}>;
+declare class PlanKnown extends PlanKnown_base {}
+declare const MutantCost: S.Struct<{
+  readonly fixedOverheadMs: S.Finite;
+  readonly testBodyMs: S.Finite;
+  readonly testsExecuted: S.Int;
+  readonly shared: S.Boolean;
+}>;
+type MutantCost = typeof MutantCost.Type;
+declare const RunMutantTestedEvent_base: S.Class<RunMutantTestedEvent, S.TaggedStruct<"mutantTested", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+  readonly location: S.decodeTo<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;
+    };
+  }>, 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 mutatorName: S.brand<S.String, "MutatorName">;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Int;
+  readonly total: S.Int;
+  readonly static: S.Boolean;
+  readonly cost: S.NullOr<S.Struct<{
+    readonly fixedOverheadMs: S.Finite;
+    readonly testBodyMs: S.Finite;
+    readonly testsExecuted: S.Int;
+    readonly shared: S.Boolean;
+  }>>;
+}>, {}>;
+/**
+ * The machine-stream line a tested mutant is published as. Its wire shape is a
+ * published contract: the `mutant` tag and the `file`/`mutator` keys must not
+ * change. The line carries the verified fields of `Reporter.MutantTested` plus
+ * the static classification (R24) and the measured cost breakdown (R39).
+ */
+declare class RunMutantTestedEvent extends RunMutantTestedEvent_base {}
+type RunMutantTested = RunMutantTestedEvent;
+declare const MutantTestedWireSchema: S.TaggedStruct<"mutant", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly file: S.toType<S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>>;
+  readonly location: S.decodeTo<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;
+    };
+  }>, 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 mutator: S.brand<S.String, "MutatorName">;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Int;
+  readonly total: S.Int;
+  readonly static: S.Boolean;
+  readonly cost: S.NullOr<S.Struct<{
+    readonly fixedOverheadMs: S.Finite;
+    readonly testBodyMs: S.Finite;
+    readonly testsExecuted: S.Int;
+    readonly shared: S.Boolean;
+  }>>;
+}>;
+declare const RunMutantTested: S.Codec<RunMutantTested, typeof MutantTestedWireSchema.Encoded>;
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+  readonly elapsedMs: S.Finite;
+  readonly completed: S.Int;
+  readonly total: S.NullOr<S.Int>;
+}>, {}>;
+declare class Heartbeat extends Heartbeat_base {}
+declare const VerdictLocation: 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 VerdictLocation = typeof VerdictLocation.Type;
+declare const VerdictThresholds: S.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+  readonly break: S.NullOr<S.Finite>;
+}>;
+type VerdictThresholds = typeof VerdictThresholds.Type;
+declare const VerdictMutant: S.Struct<{
+  readonly id: S.String;
+  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 mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+}>;
+type VerdictMutant = typeof VerdictMutant.Type;
+type VerdictCounts = mod_d_exports$7.Metrics;
+declare const RunScope: S.Literals<readonly ["full", "diff"]>;
+type RunScope = typeof RunScope.Type;
+declare const MutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+type MutantSetPolicy = typeof MutantSetPolicy.Type;
+declare const PhaseDurations: S.Struct<{
+  readonly prepare: S.Finite;
+  readonly instrument: S.Finite;
+  readonly 'dry-run': S.Finite;
+  readonly 'mutation-test': S.Finite;
+}>;
+type PhaseDurations = typeof PhaseDurations.Type;
+declare const StaticVerdict: S.Struct<{
+  readonly count: S.Int;
+  readonly costMs: S.Finite;
+}>;
+type StaticVerdict = typeof StaticVerdict.Type;
+declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly runId: S.brand<S.String, "RunId">;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+  readonly score: S.NullOr<S.Finite>;
+  readonly thresholds: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+    readonly break: S.NullOr<S.Finite>;
+  }>;
+  readonly reportFile: S.NullOr<S.String>;
+  readonly counts: typeof mod_d_exports$7.Metrics;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    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 mutator: S.String;
+    readonly replacement: S.NullOr<S.String>;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  }>>;
+  readonly scope: S.Literals<readonly ["full", "diff"]>;
+  readonly mutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+  readonly phaseDurations: S.NullOr<S.Struct<{
+    readonly prepare: S.Finite;
+    readonly instrument: S.Finite;
+    readonly 'dry-run': S.Finite;
+    readonly 'mutation-test': S.Finite;
+  }>>;
+  readonly static: S.NullOr<S.Struct<{
+    readonly count: S.Int;
+    readonly costMs: S.Finite;
+  }>>;
+}>, {}>;
+declare class VerdictReached extends VerdictReached_base {}
+declare const FrameworkContributionRow: S.Struct<{
+  readonly name: S.String;
+  readonly formatId: S.String;
+  readonly extensions: S.$Array<S.String>;
+}>;
+type FrameworkContributionRow = typeof FrameworkContributionRow.Type;
+declare const FrameworkModuleRow: S.Struct<{
+  readonly moduleName: S.String;
+  readonly contributions: S.$Array<S.Struct<{
+    readonly name: S.String;
+    readonly formatId: S.String;
+    readonly extensions: S.$Array<S.String>;
+  }>>;
+}>;
+type FrameworkModuleRow = typeof FrameworkModuleRow.Type;
+declare const FormatClaimShadowingRow: S.Struct<{
+  readonly extension: S.String;
+  readonly winner: S.String;
+  readonly loser: S.String;
+}>;
+type FormatClaimShadowingRow = typeof FormatClaimShadowingRow.Type;
+declare const PluginsReported_base: S.Class<PluginsReported, S.TaggedStruct<"plugins", {
+  readonly modules: S.$Array<S.Struct<{
+    readonly moduleName: S.String;
+    readonly contributions: S.$Array<S.Struct<{
+      readonly name: S.String;
+      readonly formatId: S.String;
+      readonly extensions: S.$Array<S.String>;
+    }>>;
+  }>>;
+  readonly shadowings: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly winner: S.String;
+    readonly loser: S.String;
+  }>>;
+}>, {}>;
+declare class PluginsReported extends PluginsReported_base {}
+declare const FormatRegistryRow: S.Struct<{
+  readonly extension: S.String;
+  readonly formatId: S.String;
+  readonly ownerModule: S.String;
+  readonly language: S.String;
+}>;
+type FormatRegistryRow = typeof FormatRegistryRow.Type;
+declare const FormatRegistryResolved_base: S.Class<FormatRegistryResolved, S.TaggedStruct<"formats", {
+  readonly rows: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly formatId: S.String;
+    readonly ownerModule: S.String;
+    readonly language: S.String;
+  }>>;
+}>, {}>;
+declare class FormatRegistryResolved extends FormatRegistryResolved_base {}
+declare const SkippedFileRow: S.Struct<{
+  readonly file: S.String;
+  readonly extension: S.String;
+  readonly reason: S.String;
+}>;
+type SkippedFileRow = typeof SkippedFileRow.Type;
+declare const SkippedReported_base: S.Class<SkippedReported, S.TaggedStruct<"skipped", {
+  readonly files: S.$Array<S.Struct<{
+    readonly file: S.String;
+    readonly extension: S.String;
+    readonly reason: S.String;
+  }>>;
+}>, {}>;
+declare class SkippedReported extends SkippedReported_base {}
+declare const ReuseRefusals: S.Struct<{
+  readonly semanticsChanged: S.Int;
+  readonly policyChanged: S.Int;
+  readonly runInputsChanged: S.Int;
+  readonly closureChanged: S.Int;
+  readonly timeoutUnreproduced: S.Int;
+  readonly flakyDependency: S.Int;
+  readonly noPriorRecord: S.Int;
+}>;
+type ReuseRefusals = typeof ReuseRefusals.Type;
+declare const ReuseReported_base: S.Class<ReuseReported, S.TaggedStruct<"reuse", {
+  readonly reused: S.Int;
+  readonly ran: S.Int;
+  readonly refused: S.Struct<{
+    readonly semanticsChanged: S.Int;
+    readonly policyChanged: S.Int;
+    readonly runInputsChanged: S.Int;
+    readonly closureChanged: S.Int;
+    readonly timeoutUnreproduced: S.Int;
+    readonly flakyDependency: S.Int;
+    readonly noPriorRecord: S.Int;
+  }>;
+}>, {}>;
+declare class ReuseReported extends ReuseReported_base {}
+declare const MutantDetailReported_base: S.Class<MutantDetailReported, S.TaggedStruct<"mutant-detail", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly coveringTests: S.$Array<S.String>;
+  readonly killedBy: S.NullOr<S.String>;
+  readonly reproducer: S.NullOr<S.String>;
+}>, {}>;
+declare class MutantDetailReported extends MutantDetailReported_base {}
+declare const FeedbackJudgment: S.Literals<readonly ["useful", "not-useful"]>;
+type FeedbackJudgment = typeof FeedbackJudgment.Type;
+declare const FeedbackReported_base: S.Class<FeedbackReported, S.TaggedStruct<"feedback", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly judgment: S.Literals<readonly ["useful", "not-useful"]>;
+  readonly reason: S.NullOr<S.String>;
+}>, {}>;
+declare class FeedbackReported extends FeedbackReported_base {}
+declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly code: S.Int;
+  readonly error: S.String;
+  readonly remediation: S.String;
+  readonly reason: S.NullOr<S.Union<readonly [S.TaggedStruct<"PeerMissing", {
+    readonly peer: S.String;
+  }>, S.TaggedStruct<"PeerVersionUnsupported", {
+    readonly peer: S.String;
+    readonly detail: S.String;
+  }>, S.TaggedStruct<"PeerUnrecognized", {
+    readonly peer: S.String;
+  }>, S.TaggedStruct<"InvalidContribution", {
+    readonly detail: S.String;
+  }>, S.TaggedStruct<"ImportFailed", {
+    readonly cause: S.Unknown;
+  }>]>>;
+}>, {}>;
+declare class RunFailed extends RunFailed_base {}
+declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly code: S.Literals<readonly [0]>;
+  readonly help: S.String;
+}>, {}>;
+declare class HelpRendered extends HelpRendered_base {}
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTestedEvent, {
+  readonly _tag: "mutant";
+  readonly id: string;
+  readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
+  readonly file: string & import("effect/Brand").Brand<"CanonicalFileName">;
+  readonly location: {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  };
+  readonly mutator: string;
+  readonly replacement: string | null;
+  readonly completed: number;
+  readonly total: number;
+  readonly static: boolean;
+  readonly cost: {
+    readonly fixedOverheadMs: number;
+    readonly testBodyMs: number;
+    readonly testsExecuted: number;
+    readonly shared: boolean;
+  } | null;
+}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+  QUEUE_BOUND: number;
+};
+type RunEvent = typeof RunEvent.Type;
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+//#endregion
+//#region src/run-event-wire.schema.d.ts
+declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTestedEvent, {
+  readonly _tag: "mutant";
+  readonly id: string;
+  readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
+  readonly file: string & import("effect/Brand").Brand<"CanonicalFileName">;
+  readonly location: {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  };
+  readonly mutator: string;
+  readonly replacement: string | null;
+  readonly completed: number;
+  readonly total: number;
+  readonly static: boolean;
+  readonly cost: {
+    readonly fixedOverheadMs: number;
+    readonly testBodyMs: number;
+    readonly testsExecuted: number;
+    readonly shared: boolean;
+  } | null;
+}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+  QUEUE_BOUND: number;
+}>, S.String, never, never>;
+type RunEventWireLine = typeof RunEventWireLine.Type;
+//#endregion
+//#region src/stream-version.schema.d.ts
+declare const StreamSchemaVersion: S.Literal<"2.0">;
+type StreamSchemaVersion = typeof StreamSchemaVersion.Type;
+declare namespace mod_d_exports$1$1 {
+  export { FeedbackJudgment, FeedbackReported, FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, MutantCost, MutantDetailReported, MutantSetPolicy, PhaseDurations, PhaseEntered, PlanKnown, PluginLoadFailureReason, PluginsReported, ReuseRefusals, ReuseReported, RunEvent, RunEventWireLine, RunFailed, RunId, RunMutantTested, RunMutantTestedEvent, RunPhase, RunScope, RunStarted, RunTerminalEvent, SkippedFileRow, SkippedReported, StaticVerdict, StreamSchemaVersion, VerdictCounts, VerdictLocation, VerdictMutant, VerdictReached, VerdictThresholds };
+}
+//#endregion
+//#region src/run/phase-clock.service.d.ts
+interface PhaseClockShape {
+  readonly markAt: (phase: mod_d_exports$1$1.RunPhase, elapsedMs: number) => Effect$1.Effect<void>;
+  readonly durations: Effect$1.Effect<Option$1.Option<mod_d_exports$1$1.PhaseDurations>>;
+}
+declare const PhaseClock_base: Context.ServiceClass<PhaseClock, "@systemfsoftware/stryker-js/run/phase-clock.service/PhaseClock", PhaseClockShape>;
+declare class PhaseClock extends PhaseClock_base {
+  static readonly layer: (runStartedAt: number) => Layer.Layer<PhaseClock>;
+}
+//#endregion
+//#region src/output-mode.schema.d.ts
+declare const ResolvedMode: S.Struct<{
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+  readonly stdoutIsTTY: S.Boolean;
+}>;
+type ResolvedMode = typeof ResolvedMode.Type;
+//#endregion
+//#region src/frame-run-event.workflow.d.ts
+declare const ResolvedModeInput: S.Struct<{
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>;
+type ResolvedModeInput = typeof ResolvedModeInput.Type;
+//#endregion
+//#region src/run-event-stream.service.d.ts
+type FramedDrain = (framed: Stream.Stream<string, never, never>, toStdout: boolean) => Effect$1.Effect<void, never, never>;
+interface RunEventDrainShape {
+  readonly drainFramed: FramedDrain;
+  readonly setProgressStreamFile: (fileName: string) => Effect$1.Effect<void, never, never>;
+}
+declare const RunEventDrain_base: Context.ServiceClass<RunEventDrain, "@systemfsoftware/stryker-js/run-event-stream.service/RunEventDrain", RunEventDrainShape>;
+declare class RunEventDrain extends RunEventDrain_base {
+  static readonly layer: Layer.Layer<RunEventDrain, never, Stdio.Stdio>;
+  static readonly DefaultProgressStreamFile = "reports/mutation-stream.jsonl";
+  static readonly fileLayer: Layer.Layer<RunEventDrain, never, Stdio.Stdio | FileSystem.FileSystem | Path.Path>;
+}
+declare const RunEventDrainLive: Layer.Layer<RunEventDrain, never, Stdio.Stdio>;
+interface RunEventStream {
+  readonly queue: Queue.Queue<mod_d_exports$1$1.RunEvent, Cause.Done>;
+  readonly runId: mod_d_exports$1$1.RunId;
+  readonly startedAt: number;
+  readonly isOpen: Effect$1.Effect<boolean, never, never>;
+  readonly ensureOpen: (openResolved: ResolvedModeInput) => Effect$1.Effect<void, never, never>;
+  readonly open: Effect$1.Effect<void, never, never>;
+  readonly closeAndDrain: Effect$1.Effect<void, never, never>;
+}
+declare const makeRunEventStream: (resolved: {
+  readonly mode: "human" | "machine";
+  readonly signal: "agent" | "env" | "flag" | "tool" | "tty";
+}) => Effect$1.Effect<{
+  queue: Queue.Queue<mod_d_exports$1$1.FeedbackReported | mod_d_exports$1$1.FormatRegistryResolved | mod_d_exports$1$1.Heartbeat | mod_d_exports$1$1.HelpRendered | mod_d_exports$1$1.MutantDetailReported | mod_d_exports$1$1.PhaseEntered | mod_d_exports$1$1.PlanKnown | mod_d_exports$1$1.PluginsReported | mod_d_exports$1$1.ReuseReported | mod_d_exports$1$1.RunFailed | mod_d_exports$1$1.RunMutantTestedEvent | mod_d_exports$1$1.RunStarted | mod_d_exports$1$1.SkippedReported | mod_d_exports$1$1.VerdictReached, Cause.Done<void>>;
+  runId: string & import("effect/Brand").Brand<"RunId">;
+  startedAt: number;
+  isOpen: Effect$1.Effect<boolean, never, never>;
+  ensureOpen: (openResolved: ResolvedModeInput) => Effect$1.Effect<void, never, never>;
+  open: Effect$1.Effect<void, never, never>;
+  closeAndDrain: Effect$1.Effect<void, never, never>;
+}, never, RunEventDrain | Stdio.Stdio>;
+//#endregion
+//#region src/run-events.service.d.ts
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/run-events.service/RunEvents", Queue.Queue<mod_d_exports$1$1.FeedbackReported | mod_d_exports$1$1.FormatRegistryResolved | mod_d_exports$1$1.Heartbeat | mod_d_exports$1$1.HelpRendered | mod_d_exports$1$1.MutantDetailReported | mod_d_exports$1$1.PhaseEntered | mod_d_exports$1$1.PlanKnown | mod_d_exports$1$1.PluginsReported | mod_d_exports$1$1.ReuseReported | mod_d_exports$1$1.RunFailed | mod_d_exports$1$1.RunMutantTestedEvent | mod_d_exports$1$1.RunStarted | mod_d_exports$1$1.SkippedReported | mod_d_exports$1$1.VerdictReached, Cause.Done<void>>>;
+declare class RunEvents extends RunEvents_base {}
+interface RunIdentityShape {
+  readonly runId: string;
+  readonly basePath: string;
+}
+declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "@systemfsoftware/stryker-js/run-events.service/RunIdentity", RunIdentityShape>;
+declare class RunIdentity extends RunIdentity_base {}
+declare namespace git_diff_schema_d_exports {
+  export { DiffHunk, DiffScopeCommand, DiffScopeDecision, DiffScoped, FullScope, GitCommandFailed, GitDiffError, GitDiffResult, GitRefUnresolved };
+}
+declare const DiffScopeTypeId: unique symbol;
+type DiffScopeTypeId = typeof DiffScopeTypeId;
+declare const DiffHunk: S.Struct<{
+  readonly file: S.String;
+  readonly startLine: S.Int;
+  readonly lineCount: S.Int;
+}>;
+type DiffHunk = typeof DiffHunk.Type;
+declare const GitDiffResult: S.Struct<{
+  readonly ref: S.String;
+  readonly base: S.String;
+  readonly hunks: S.$Array<S.Struct<{
+    readonly file: S.String;
+    readonly startLine: S.Int;
+    readonly lineCount: S.Int;
+  }>>;
+  readonly untrackedFiles: S.$Array<S.String>;
+}>;
+type GitDiffResult = typeof GitDiffResult.Type;
+declare const GitRefUnresolved_base: S.Class<GitRefUnresolved, S.TaggedStruct<"GitRefUnresolved", {
+  readonly ref: S.String;
+  readonly detail: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class GitRefUnresolved extends GitRefUnresolved_base {
+  get message(): string;
+}
+declare const GitCommandFailed_base: S.Class<GitCommandFailed, S.TaggedStruct<"GitCommandFailed", {
+  readonly command: S.String;
+  readonly detail: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class GitCommandFailed extends GitCommandFailed_base {
+  get message(): string;
+}
+type GitDiffError = GitRefUnresolved | GitCommandFailed;
+declare const DiffScopeCommand_base: S.Class<DiffScopeCommand, S.TaggedStruct<"DiffScopeCommand", {
+  readonly hunks: S.$Array<S.Struct<{
+    readonly file: S.String;
+    readonly startLine: S.Int;
+    readonly lineCount: S.Int;
+  }>>;
+  readonly untrackedFiles: S.$Array<S.String>;
+}>, {}>;
+declare class DiffScopeCommand extends DiffScopeCommand_base {
+  static readonly [Workflow.InstrumentationBrand]: {};
+}
+declare const DiffScoped_base: S.Class<DiffScoped, S.TaggedStruct<"DiffScoped", {
+  readonly ranges: S.$Array<S.String>;
+}>, {}>;
+declare class DiffScoped extends DiffScoped_base {
+  readonly [DiffScopeTypeId]: symbol;
+}
+declare const FullScope_base: S.Class<FullScope, S.TaggedStruct<"FullScope", {
+  readonly reason: S.String;
+}>, {}>;
+declare class FullScope extends FullScope_base {
+  readonly [DiffScopeTypeId]: symbol;
+}
+declare const DiffScopeDecision: S.Union<readonly [typeof DiffScoped, typeof FullScope]>;
+type DiffScopeDecision = typeof DiffScopeDecision.Type;
+declare namespace git_diff_service_d_exports {
+  export { GitDiff, GitDiffInput, GitDiffShape };
+}
+interface GitDiffInput {
+  readonly cwd: string;
+  readonly ref: string;
+}
+interface GitDiffShape {
+  readonly changedSince: (input: GitDiffInput) => Effect$1.Effect<GitDiffResult, GitDiffError, ChildProcessSpawner.ChildProcessSpawner | Scope.Scope>;
+}
+declare const GitDiff_base: Context.ServiceClass<GitDiff, "@systemfsoftware/stryker-js/git-diff.service/GitDiff", GitDiffShape>;
+declare class GitDiff extends GitDiff_base {
+  static readonly layer: Layer.Layer<GitDiff>;
+}
+//#endregion
+//#region ../frameworks/interface/dist/index.d.ts
+declare interface EmbeddedDocument {
+  readonly formatId: FormatId;
+  readonly rawContent: string;
+  readonly regions: readonly ScriptRegion[];
+}
+declare type FormatId = string;
+declare interface Framework {
+  readonly kind: 'Framework';
+  readonly name: string;
+  readonly claim: FrameworkClaim;
+  readonly parse: (rawContent: string, context: FrameworkContext) => FrameworkParseResult<EmbeddedDocument>;
+  readonly transform: (document: EmbeddedDocument, context: FrameworkContext) => EmbeddedDocument;
+  readonly print: (document: EmbeddedDocument, context: FrameworkContext) => string;
+  readonly disableTypeChecks: (rawContent: string) => FrameworkParseResult<string>;
+}
+declare interface FrameworkClaim {
+  readonly formatId: FormatId;
+  readonly extensions: readonly string[];
+  readonly language: string;
+  readonly ownerVersion: string;
+  readonly contractVersion: FrameworkContractVersion;
+}
+declare interface FrameworkContext {
+  readonly parseScript: (source: string, scriptFormat: ScriptFormat$1) => Program$2;
+  readonly printScript: (script: Program$2) => string;
+  readonly instrumentationHeader: () => readonly Statement[];
+}
+declare type FrameworkContractVersion = '1';
+declare type FrameworkParseResult<A> = {
+  readonly kind: 'Parsed';
+  readonly value: A;
+} | {
+  readonly kind: 'ParseFailed';
+  readonly message: string;
+};
+declare type ScriptFormat$1 = 'js' | 'ts' | 'tsx';
+declare interface ScriptRegion {
+  readonly start: number;
+  readonly end: number;
+  readonly isExpression: boolean;
+  readonly scriptAst: Program$2;
+}
+//#endregion
+//#region ../stryker-js-instrumenter/dist/index.d.mts
+//#endregion
+//#region ../ignorers/interface/dist/index.d.ts
+declare interface AccessorProperty$1 extends Span$1 {
+  type: AccessorPropertyType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey_2;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value: Expression$1 | null;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  definite?: boolean;
+  accessibility?: TSAccessibility | null;
+  declare?: false;
+  optional?: false;
+  readonly?: false;
+  parent?: Node$1;
+}
+declare type AccessorPropertyType = "AccessorProperty" | "TSAbstractAccessorProperty";
+declare type Argument$1 = SpreadElement$1 | Expression$1;
+declare interface ArrayAssignmentTarget extends Span$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface ArrayExpression$1 extends Span$1 {
+  type: "ArrayExpression";
+  elements: Array<ArrayExpressionElement>;
+  parent?: Node$1;
+}
+declare type ArrayExpressionElement = SpreadElement$1 | null | Expression$1;
+declare interface ArrayPattern$1 extends Span$1 {
+  type: "ArrayPattern";
+  decorators?: [];
+  elements: Array<BindingPattern$1 | BindingRestElement$1 | null>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface ArrowFunctionExpression$1 extends Span$1 {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  async: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType?: TSTypeAnnotation$1 | null;
+  body: FunctionBody | Expression$1;
+  id: null;
+  generator: false;
+  parent?: Node$1;
+}
+declare interface AssignmentExpression$1 extends Span$1 {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: AssignmentTarget;
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+declare interface AssignmentPattern$1 extends Span$1 {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: BindingPattern$1;
+  right: Expression$1;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare type AssignmentTarget = SimpleAssignmentTarget$1 | AssignmentTargetPattern;
+declare type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | AssignmentTarget;
+declare type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTarget;
+declare type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty;
+declare interface AssignmentTargetPropertyIdentifier extends Span$1 {
+  type: "Property";
+  kind: "init";
+  key: IdentifierReference$1;
+  value: IdentifierReference$1 | AssignmentTargetWithDefault;
+  method: false;
+  shorthand: true;
+  computed: false;
+  optional?: false;
+  parent?: Node$1;
+}
+declare interface AssignmentTargetPropertyProperty extends Span$1 {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey_2;
+  value: AssignmentTargetMaybeDefault;
+  method: false;
+  shorthand: false;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1;
+}
+declare interface AssignmentTargetRest extends Span$1 {
+  type: "RestElement";
+  decorators?: [];
+  argument: AssignmentTarget;
+  optional?: false;
+  typeAnnotation?: null;
+  value?: null;
+  parent?: Node$1;
+}
+declare interface AssignmentTargetWithDefault extends Span$1 {
+  type: "AssignmentPattern";
+  decorators?: [];
+  left: AssignmentTarget;
+  right: Expression$1;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface AwaitExpression extends Span$1 {
+  type: "AwaitExpression";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare interface BigIntLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: bigint;
+  raw: string | null;
+  bigint: string;
+  parent?: Node$1;
+}
+declare interface BinaryExpression$1 extends Span$1 {
+  type: "BinaryExpression";
+  left: Expression$1;
+  operator: BinaryOperator;
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
+declare interface BindingIdentifier$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare type BindingPattern$1 = BindingIdentifier$1 | ObjectPattern | ArrayPattern$1 | AssignmentPattern$1;
+declare interface BindingProperty$1 extends Span$1 {
+  type: "Property";
+  kind: "init";
+  key: PropertyKey_2;
+  value: BindingPattern$1;
+  method: false;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1;
+}
+declare interface BindingRestElement$1 extends Span$1 {
+  type: "RestElement";
+  decorators?: [];
+  argument: BindingPattern$1;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value?: null;
+  parent?: Node$1;
+}
+declare interface BlockStatement$1 extends Span$1 {
+  type: "BlockStatement";
+  body: Array<Statement$1>;
+  parent?: Node$1;
+}
+declare interface BooleanLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: boolean;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface BreakStatement$1 extends Span$1 {
+  type: "BreakStatement";
+  label: LabelIdentifier$1 | null;
+  parent?: Node$1;
+}
+declare type Built<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Built<T[number]>> : T) : T extends Span$1 ? { [K in keyof T as K extends keyof Span$1 ? never : K]: Child<T[K]>; } & Partial<Pick<T, keyof Span$1>> : T;
+declare interface CallExpression$1 extends Span$1 {
+  type: "CallExpression";
+  callee: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  arguments: Array<Argument$1>;
+  optional: boolean;
+  parent?: Node$1;
+}
+declare interface CatchClause$1 extends Span$1 {
+  type: "CatchClause";
+  param: BindingPattern$1 | null;
+  body: BlockStatement$1;
+  parent?: Node$1;
+}
+declare type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
+declare interface ChainExpression$1 extends Span$1 {
+  type: "ChainExpression";
+  expression: ChainElement;
+  parent?: Node$1;
+}
+declare type Child<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Child<T[number]>> : T) : T extends Span$1 ? Built<T> | T : T;
+declare interface Class$1 extends Span$1 {
+  type: ClassType;
+  decorators: Array<Decorator$1>;
+  id: BindingIdentifier$1 | null;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  superClass: Expression$1 | null;
+  superTypeArguments?: TSTypeParameterInstantiation$1 | null;
+  implements?: Array<TSClassImplements>;
+  body: ClassBody$1;
+  abstract?: boolean;
+  declare?: boolean;
+  parent?: Node$1;
+}
+declare interface ClassBody$1 extends Span$1 {
+  type: "ClassBody";
+  body: Array<ClassElement>;
+  parent?: Node$1;
+}
+declare type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
+declare type ClassType = "ClassDeclaration" | "ClassExpression";
+declare interface ComputedMemberExpression extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: Expression$1;
+  optional: boolean;
+  computed: true;
+  parent?: Node$1;
+}
+declare interface ConditionalExpression$1 extends Span$1 {
+  type: "ConditionalExpression";
+  test: Expression$1;
+  consequent: Expression$1;
+  alternate: Expression$1;
+  parent?: Node$1;
+}
+declare interface ContinueStatement$1 extends Span$1 {
+  type: "ContinueStatement";
+  label: LabelIdentifier$1 | null;
+  parent?: Node$1;
+}
+declare interface DebuggerStatement extends Span$1 {
+  type: "DebuggerStatement";
+  parent?: Node$1;
+}
+declare type Declaration = VariableDeclaration$1 | Function$1 | Class$1 | TSTypeAliasDeclaration$1 | TSInterfaceDeclaration$1 | TSEnumDeclaration$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSImportEqualsDeclaration$1;
+declare interface Decorator$1 extends Span$1 {
+  type: "Decorator";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface Directive extends Span$1 {
+  type: "ExpressionStatement";
+  expression: StringLiteral$1;
+  directive: string;
+  parent?: Node$1;
+}
+declare interface DoWhileStatement$1 extends Span$1 {
+  type: "DoWhileStatement";
+  body: Statement$1;
+  test: Expression$1;
+  parent?: Node$1;
+}
+declare interface EmptyStatement$1 extends Span$1 {
+  type: "EmptyStatement";
+  parent?: Node$1;
+}
+declare interface ExportAllDeclaration$1 extends Span$1 {
+  type: "ExportAllDeclaration";
+  exported: ModuleExportName | null;
+  source: StringLiteral$1;
+  attributes: Array<ImportAttribute$1>;
+  exportKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare interface ExportDefaultDeclaration$1 extends Span$1 {
+  type: "ExportDefaultDeclaration";
+  declaration: ExportDefaultDeclarationKind;
+  exportKind?: "value";
+  parent?: Node$1;
+}
+declare type ExportDefaultDeclarationKind = Function$1 | Class$1 | TSInterfaceDeclaration$1 | Expression$1;
+declare interface ExportNamedDeclaration$1 extends Span$1 {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration | null;
+  specifiers: Array<ExportSpecifier>;
+  source: StringLiteral$1 | null;
+  exportKind?: ImportOrExportKind;
+  attributes: Array<ImportAttribute$1>;
+  parent?: Node$1;
+}
+declare interface ExportSpecifier extends Span$1 {
+  type: "ExportSpecifier";
+  local: ModuleExportName;
+  exported: ModuleExportName;
+  exportKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
+declare interface ExpressionStatement$1 extends Span$1 {
+  type: "ExpressionStatement";
+  expression: Expression$1;
+  directive?: string | null;
+  parent?: Node$1;
+}
+declare interface ForInStatement$1 extends Span$1 {
+  type: "ForInStatement";
+  left: ForStatementLeft;
+  right: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare type FormalParameter = {
+  decorators?: Array<Decorator$1>;
+} & BindingPattern$1;
+declare interface FormalParameterRest extends Span$1 {
+  type: "RestElement";
+  argument: BindingPattern$1;
+  decorators?: Array<Decorator$1>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value?: null;
+  parent?: Node$1;
+}
+declare interface ForOfStatement$1 extends Span$1 {
+  type: "ForOfStatement";
+  await: boolean;
+  left: ForStatementLeft;
+  right: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface ForStatement$1 extends Span$1 {
+  type: "ForStatement";
+  init: ForStatementInit | null;
+  test: Expression$1 | null;
+  update: Expression$1 | null;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare type ForStatementInit = VariableDeclaration$1 | Expression$1;
+declare type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
+declare interface Function$1 extends Span$1 {
+  type: FunctionType;
+  id: BindingIdentifier$1 | null;
+  generator: boolean;
+  async: boolean;
+  declare?: boolean;
+  typeParameters?: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType?: TSTypeAnnotation$1 | null;
+  body: FunctionBody | null;
+  expression: false;
+  parent?: Node$1;
+}
+declare interface FunctionBody extends Span$1 {
+  type: "BlockStatement";
+  body: Array<Directive | Statement$1>;
+  parent?: Node$1;
+}
+declare type FunctionType = "FunctionDeclaration" | "FunctionExpression" | "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
+declare interface Hashbang extends Span$1 {
+  type: "Hashbang";
+  value: string;
+  parent?: Node$1;
+}
+declare interface IdentifierName$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface IdentifierReference$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface IfStatement$1 extends Span$1 {
+  type: "IfStatement";
+  test: Expression$1;
+  consequent: Statement$1;
+  alternate: Statement$1 | null;
+  parent?: Node$1;
+}
+declare interface Ignorer {
+  readonly name: string;
+  shouldIgnore(node: Node_2, ancestors: readonly Node_2[]): string | undefined;
+}
+declare interface ImportAttribute$1 extends Span$1 {
+  type: "ImportAttribute";
+  key: ImportAttributeKey;
+  value: StringLiteral$1;
+  parent?: Node$1;
+}
+declare type ImportAttributeKey = IdentifierName$1 | StringLiteral$1;
+declare interface ImportDeclaration$1 extends Span$1 {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportDeclarationSpecifier>;
+  source: StringLiteral$1;
+  phase: ImportPhase | null;
+  attributes: Array<ImportAttribute$1>;
+  importKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare type ImportDeclarationSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
+declare interface ImportDefaultSpecifier extends Span$1 {
+  type: "ImportDefaultSpecifier";
+  local: BindingIdentifier$1;
+  parent?: Node$1;
+}
+declare interface ImportExpression$1 extends Span$1 {
+  type: "ImportExpression";
+  source: Expression$1;
+  options: Expression$1 | null;
+  phase: ImportPhase | null;
+  parent?: Node$1;
+}
+declare interface ImportNamespaceSpecifier extends Span$1 {
+  type: "ImportNamespaceSpecifier";
+  local: BindingIdentifier$1;
+  parent?: Node$1;
+}
+declare type ImportOrExportKind = "value" | "type";
+declare type ImportPhase = "source" | "defer";
+declare interface ImportSpecifier extends Span$1 {
+  type: "ImportSpecifier";
+  imported: ModuleExportName;
+  local: BindingIdentifier$1;
+  importKind?: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare interface JSDocNonNullableType$1 extends Span$1 {
+  type: "TSJSDocNonNullableType";
+  typeAnnotation: TSType$1;
+  postfix: boolean;
+  parent?: Node$1;
+}
+declare interface JSDocNullableType$1 extends Span$1 {
+  type: "TSJSDocNullableType";
+  typeAnnotation: TSType$1;
+  postfix: boolean;
+  parent?: Node$1;
+}
+declare interface JSDocUnknownType extends Span$1 {
+  type: "TSJSDocUnknownType";
+  parent?: Node$1;
+}
+declare interface JSXAttribute$1 extends Span$1 {
+  type: "JSXAttribute";
+  name: JSXAttributeName;
+  value: JSXAttributeValue | null;
+  parent?: Node$1;
+}
+declare type JSXAttributeItem = JSXAttribute$1 | JSXSpreadAttribute$1;
+declare type JSXAttributeName = JSXIdentifier$1 | JSXNamespacedName$1;
+declare type JSXAttributeValue = StringLiteral$1 | JSXExpressionContainer$1 | JSXElement$1 | JSXFragment$1;
+declare type JSXChild = JSXText$1 | JSXElement$1 | JSXFragment$1 | JSXExpressionContainer$1 | JSXSpreadChild$1;
+declare interface JSXClosingElement extends Span$1 {
+  type: "JSXClosingElement";
+  name: JSXElementName;
+  parent?: Node$1;
+}
+declare interface JSXClosingFragment extends Span$1 {
+  type: "JSXClosingFragment";
+  parent?: Node$1;
+}
+declare interface JSXElement$1 extends Span$1 {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement$1;
+  children: Array<JSXChild>;
+  closingElement: JSXClosingElement | null;
+  parent?: Node$1;
+}
+declare type JSXElementName = JSXIdentifier$1 | JSXNamespacedName$1 | JSXMemberExpression$1;
+declare interface JSXEmptyExpression extends Span$1 {
+  type: "JSXEmptyExpression";
+  parent?: Node$1;
+}
+declare type JSXExpression = JSXEmptyExpression | Expression$1;
+declare interface JSXExpressionContainer$1 extends Span$1 {
+  type: "JSXExpressionContainer";
+  expression: JSXExpression;
+  parent?: Node$1;
+}
+declare interface JSXFragment$1 extends Span$1 {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  children: Array<JSXChild>;
+  closingFragment: JSXClosingFragment;
+  parent?: Node$1;
+}
+declare interface JSXIdentifier$1 extends Span$1 {
+  type: "JSXIdentifier";
+  name: string;
+  parent?: Node$1;
+}
+declare interface JSXMemberExpression$1 extends Span$1 {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpressionObject;
+  property: JSXIdentifier$1;
+  parent?: Node$1;
+}
+declare type JSXMemberExpressionObject = JSXIdentifier$1 | JSXMemberExpression$1;
+declare interface JSXNamespacedName$1 extends Span$1 {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier$1;
+  name: JSXIdentifier$1;
+  parent?: Node$1;
+}
+declare interface JSXOpeningElement$1 extends Span$1 {
+  type: "JSXOpeningElement";
+  name: JSXElementName;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  attributes: Array<JSXAttributeItem>;
+  selfClosing: boolean;
+  parent?: Node$1;
+}
+declare interface JSXOpeningFragment extends Span$1 {
+  type: "JSXOpeningFragment";
+  attributes?: [];
+  selfClosing?: false;
+  parent?: Node$1;
+}
+declare interface JSXSpreadAttribute$1 extends Span$1 {
+  type: "JSXSpreadAttribute";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare interface JSXSpreadChild$1 extends Span$1 {
+  type: "JSXSpreadChild";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface JSXText$1 extends Span$1 {
+  type: "JSXText";
+  value: string;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface LabeledStatement$1 extends Span$1 {
+  type: "LabeledStatement";
+  label: LabelIdentifier$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface LabelIdentifier$1 extends Span$1 {
+  type: "Identifier";
+  decorators?: [];
+  name: string;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface LogicalExpression$1 extends Span$1 {
+  type: "LogicalExpression";
+  left: Expression$1;
+  operator: LogicalOperator;
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare type LogicalOperator = "||" | "&&" | "??";
+declare type MemberExpression$1 = ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression;
+declare interface MetaProperty$1 extends Span$1 {
+  type: "MetaProperty";
+  meta: IdentifierName$1;
+  property: IdentifierName$1;
+  parent?: Node$1;
+}
+declare interface MethodDefinition$1 extends Span$1 {
+  type: MethodDefinitionType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey_2;
+  value: Function$1;
+  kind: MethodDefinitionKind;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  optional?: boolean;
+  accessibility?: TSAccessibility | null;
+  parent?: Node$1;
+}
+declare type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
+declare type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
+declare type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
+declare type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
+declare type ModuleKind = "script" | "module" | "commonjs";
+declare interface NewExpression$1 extends Span$1 {
+  type: "NewExpression";
+  callee: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  arguments: Array<Argument$1>;
+  parent?: Node$1;
+}
+declare type Node$1 = Program$1 | IdentifierName$1 | IdentifierReference$1 | BindingIdentifier$1 | LabelIdentifier$1 | ThisExpression$1 | ArrayExpression$1 | ObjectExpression$1 | ObjectProperty$1 | TemplateLiteral$1 | TaggedTemplateExpression$1 | TemplateElement$1 | ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression | CallExpression$1 | NewExpression$1 | MetaProperty$1 | SpreadElement$1 | UpdateExpression$1 | UnaryExpression$1 | BinaryExpression$1 | PrivateInExpression$1 | LogicalExpression$1 | ConditionalExpression$1 | AssignmentExpression$1 | ArrayAssignmentTarget | ObjectAssignmentTarget | AssignmentTargetRest | AssignmentTargetWithDefault | AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty | SequenceExpression$1 | Super$1 | AwaitExpression | ChainExpression$1 | ParenthesizedExpression | Directive | Hashbang | BlockStatement$1 | VariableDeclaration$1 | VariableDeclarator$1 | EmptyStatement$1 | ExpressionStatement$1 | IfStatement$1 | DoWhileStatement$1 | WhileStatement$1 | ForStatement$1 | ForInStatement$1 | ForOfStatement$1 | ContinueStatement$1 | BreakStatement$1 | ReturnStatement$1 | WithStatement$1 | SwitchStatement$1 | SwitchCase$1 | LabeledStatement$1 | ThrowStatement$1 | TryStatement$1 | CatchClause$1 | DebuggerStatement | AssignmentPattern$1 | ObjectPattern | BindingProperty$1 | ArrayPattern$1 | BindingRestElement$1 | Function$1 | FunctionBody | ArrowFunctionExpression$1 | YieldExpression$1 | Class$1 | ClassBody$1 | MethodDefinition$1 | PropertyDefinition$1 | PrivateIdentifier$1 | StaticBlock$1 | AccessorProperty$1 | ImportExpression$1 | ImportDeclaration$1 | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportAttribute$1 | ExportNamedDeclaration$1 | ExportDefaultDeclaration$1 | ExportAllDeclaration$1 | ExportSpecifier | V8IntrinsicExpression | BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | StringLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | JSXElement$1 | JSXOpeningElement$1 | JSXClosingElement | JSXFragment$1 | JSXOpeningFragment | JSXClosingFragment | JSXNamespacedName$1 | JSXMemberExpression$1 | JSXExpressionContainer$1 | JSXEmptyExpression | JSXAttribute$1 | JSXSpreadAttribute$1 | JSXIdentifier$1 | JSXSpreadChild$1 | JSXText$1 | TSThisParameter | TSEnumDeclaration$1 | TSEnumBody | TSEnumMember | TSTypeAnnotation$1 | TSLiteralType$1 | TSConditionalType$1 | TSUnionType$1 | TSIntersectionType$1 | TSParenthesizedType$1 | TSTypeOperator$1 | TSArrayType$1 | TSIndexedAccessType$1 | TSTupleType$1 | TSNamedTupleMember$1 | TSOptionalType$1 | TSRestType$1 | TSAnyKeyword | TSStringKeyword | TSBooleanKeyword | TSNumberKeyword | TSNeverKeyword | TSIntrinsicKeyword | TSUnknownKeyword | TSNullKeyword | TSUndefinedKeyword | TSVoidKeyword | TSSymbolKeyword | TSThisType | TSObjectKeyword | TSBigIntKeyword | TSTypeReference$1 | TSQualifiedName$1 | TSTypeParameterInstantiation$1 | TSTypeParameter | TSTypeParameterDeclaration$1 | TSTypeAliasDeclaration$1 | TSClassImplements | TSInterfaceDeclaration$1 | TSInterfaceBody$1 | TSPropertySignature$1 | TSIndexSignature$1 | TSCallSignatureDeclaration$1 | TSMethodSignature$1 | TSConstructSignatureDeclaration$1 | TSIndexSignatureName | TSInterfaceHeritage | TSTypePredicate$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSModuleBlock$1 | TSTypeLiteral | TSInferType$1 | TSTypeQuery$1 | TSImportType$1 | TSImportTypeQualifiedName | TSFunctionType$1 | TSConstructorType$1 | TSMappedType$1 | TSTemplateLiteralType$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSImportEqualsDeclaration$1 | TSExternalModuleReference | TSNonNullExpression$1 | Decorator$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1 | TSInstantiationExpression$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType | ParamPattern$1;
+declare type Node_2 = Simplify<Built<Node$1>> | Node$1;
+declare interface NullLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: null;
+  raw: "null" | null;
+  parent?: Node$1;
+}
+declare interface NumericLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: number;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface ObjectAssignmentTarget extends Span$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
+  optional?: false;
+  typeAnnotation?: null;
+  parent?: Node$1;
+}
+declare interface ObjectExpression$1 extends Span$1 {
+  type: "ObjectExpression";
+  properties: Array<ObjectPropertyKind>;
+  parent?: Node$1;
+}
+declare interface ObjectPattern extends Span$1 {
+  type: "ObjectPattern";
+  decorators?: [];
+  properties: Array<BindingProperty$1 | BindingRestElement$1>;
+  optional?: false;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface ObjectProperty$1 extends Span$1 {
+  type: "Property";
+  kind: PropertyKind;
+  key: PropertyKey_2;
+  value: Expression$1;
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+  parent?: Node$1;
+}
+declare type ObjectPropertyKind = ObjectProperty$1 | SpreadElement$1;
+declare type ParamPattern$1 = FormalParameter | TSParameterProperty | FormalParameterRest;
+declare interface ParenthesizedExpression extends Span$1 {
+  type: "ParenthesizedExpression";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface PrivateFieldExpression extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: PrivateIdentifier$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1;
+}
+declare interface PrivateIdentifier$1 extends Span$1 {
+  type: "PrivateIdentifier";
+  name: string;
+  parent?: Node$1;
+}
+declare interface PrivateInExpression$1 extends Span$1 {
+  type: "BinaryExpression";
+  left: PrivateIdentifier$1;
+  operator: "in";
+  right: Expression$1;
+  parent?: Node$1;
+}
+declare interface Program$1 extends Span$1 {
+  type: "Program";
+  body: Array<Directive | Statement$1>;
+  sourceType: ModuleKind;
+  hashbang: Hashbang | null;
+  parent?: null;
+}
+declare type Program = Simplify<Built<Program$1>>;
+declare interface PropertyDefinition$1 extends Span$1 {
+  type: PropertyDefinitionType;
+  decorators: Array<Decorator$1>;
+  key: PropertyKey_2;
+  typeAnnotation?: TSTypeAnnotation$1 | null;
+  value: Expression$1 | null;
+  computed: boolean;
+  static: boolean;
+  declare?: boolean;
+  override?: boolean;
+  optional?: boolean;
+  definite?: boolean;
+  readonly?: boolean;
+  accessibility?: TSAccessibility | null;
+  parent?: Node$1;
+}
+declare type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition";
+declare type PropertyKey_2 = IdentifierName$1 | PrivateIdentifier$1 | Expression$1;
+declare type PropertyKind = "init" | "get" | "set";
+declare interface RegExpLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: RegExp | null;
+  raw: string | null;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  parent?: Node$1;
+}
+declare interface ReturnStatement$1 extends Span$1 {
+  type: "ReturnStatement";
+  argument: Expression$1 | null;
+  parent?: Node$1;
+}
+declare interface SequenceExpression$1 extends Span$1 {
+  type: "SequenceExpression";
+  expressions: Array<Expression$1>;
+  parent?: Node$1;
+}
+declare type SimpleAssignmentTarget$1 = IdentifierReference$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSNonNullExpression$1 | TSTypeAssertion$1 | MemberExpression$1;
+declare type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+declare interface Span$1 {
+  start: number;
+  end: number;
+  range?: [number, number];
+}
+declare interface SpreadElement$1 extends Span$1 {
+  type: "SpreadElement";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare type Statement$1 = BlockStatement$1 | BreakStatement$1 | ContinueStatement$1 | DebuggerStatement | DoWhileStatement$1 | EmptyStatement$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | IfStatement$1 | LabeledStatement$1 | ReturnStatement$1 | SwitchStatement$1 | ThrowStatement$1 | TryStatement$1 | WhileStatement$1 | WithStatement$1 | Declaration | ModuleDeclaration;
+declare interface StaticBlock$1 extends Span$1 {
+  type: "StaticBlock";
+  body: Array<Statement$1>;
+  parent?: Node$1;
+}
+declare interface StaticMemberExpression$1 extends Span$1 {
+  type: "MemberExpression";
+  object: Expression$1;
+  property: IdentifierName$1;
+  optional: boolean;
+  computed: false;
+  parent?: Node$1;
+}
+declare interface StringLiteral$1 extends Span$1 {
+  type: "Literal";
+  value: string;
+  raw: string | null;
+  parent?: Node$1;
+}
+declare interface Super$1 extends Span$1 {
+  type: "Super";
+  parent?: Node$1;
+}
+declare interface SwitchCase$1 extends Span$1 {
+  type: "SwitchCase";
+  test: Expression$1 | null;
+  consequent: Array<Statement$1>;
+  parent?: Node$1;
+}
+declare interface SwitchStatement$1 extends Span$1 {
+  type: "SwitchStatement";
+  discriminant: Expression$1;
+  cases: Array<SwitchCase$1>;
+  parent?: Node$1;
+}
+declare interface TaggedTemplateExpression$1 extends Span$1 {
+  type: "TaggedTemplateExpression";
+  tag: Expression$1;
+  typeArguments?: TSTypeParameterInstantiation$1 | null;
+  quasi: TemplateLiteral$1;
+  parent?: Node$1;
+}
+declare interface TemplateElement$1 extends Span$1 {
+  type: "TemplateElement";
+  value: TemplateElementValue;
+  tail: boolean;
+  parent?: Node$1;
+}
+declare interface TemplateElementValue {
+  raw: string;
+  cooked: string | null;
+}
+declare interface TemplateLiteral$1 extends Span$1 {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement$1>;
+  expressions: Array<Expression$1>;
+  parent?: Node$1;
+}
+declare interface ThisExpression$1 extends Span$1 {
+  type: "ThisExpression";
+  parent?: Node$1;
+}
+declare interface ThrowStatement$1 extends Span$1 {
+  type: "ThrowStatement";
+  argument: Expression$1;
+  parent?: Node$1;
+}
+declare interface TryStatement$1 extends Span$1 {
+  type: "TryStatement";
+  block: BlockStatement$1;
+  handler: CatchClause$1 | null;
+  finalizer: BlockStatement$1 | null;
+  parent?: Node$1;
+}
+declare type TSAccessibility = "private" | "protected" | "public";
+declare interface TSAnyKeyword extends Span$1 {
+  type: "TSAnyKeyword";
+  parent?: Node$1;
+}
+declare interface TSArrayType$1 extends Span$1 {
+  type: "TSArrayType";
+  elementType: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSAsExpression$1 extends Span$1 {
+  type: "TSAsExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSBigIntKeyword extends Span$1 {
+  type: "TSBigIntKeyword";
+  parent?: Node$1;
+}
+declare interface TSBooleanKeyword extends Span$1 {
+  type: "TSBooleanKeyword";
+  parent?: Node$1;
+}
+declare interface TSCallSignatureDeclaration$1 extends Span$1 {
+  type: "TSCallSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSClassImplements extends Span$1 {
+  type: "TSClassImplements";
+  expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSConditionalType$1 extends Span$1 {
+  type: "TSConditionalType";
+  checkType: TSType$1;
+  extendsType: TSType$1;
+  trueType: TSType$1;
+  falseType: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSConstructorType$1 extends Span$1 {
+  type: "TSConstructorType";
+  abstract: boolean;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1;
+  parent?: Node$1;
+}
+declare interface TSConstructSignatureDeclaration$1 extends Span$1 {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSEnumBody extends Span$1 {
+  type: "TSEnumBody";
+  members: Array<TSEnumMember>;
+  parent?: Node$1;
+}
+declare interface TSEnumDeclaration$1 extends Span$1 {
+  type: "TSEnumDeclaration";
+  id: BindingIdentifier$1;
+  body: TSEnumBody;
+  const: boolean;
+  declare: boolean;
+  parent?: Node$1;
+}
+declare interface TSEnumMember extends Span$1 {
+  type: "TSEnumMember";
+  id: TSEnumMemberName;
+  initializer: Expression$1 | null;
+  computed: boolean;
+  parent?: Node$1;
+}
+declare type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
+declare interface TSExportAssignment$1 extends Span$1 {
+  type: "TSExportAssignment";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface TSExternalModuleReference extends Span$1 {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral$1;
+  parent?: Node$1;
+}
+declare interface TSFunctionType$1 extends Span$1 {
+  type: "TSFunctionType";
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1;
+  parent?: Node$1;
+}
+declare interface TSGlobalDeclaration extends Span$1 {
+  type: "TSModuleDeclaration";
+  id: IdentifierName$1;
+  body: TSModuleBlock$1;
+  kind: "global";
+  declare: boolean;
+  global: true;
+  parent?: Node$1;
+}
+declare interface TSImportEqualsDeclaration$1 extends Span$1 {
+  type: "TSImportEqualsDeclaration";
+  id: BindingIdentifier$1;
+  moduleReference: TSModuleReference;
+  importKind: ImportOrExportKind;
+  parent?: Node$1;
+}
+declare interface TSImportType$1 extends Span$1 {
+  type: "TSImportType";
+  source: StringLiteral$1;
+  options: ObjectExpression$1 | null;
+  qualifier: TSImportTypeQualifier | null;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSImportTypeQualifiedName extends Span$1 {
+  type: "TSQualifiedName";
+  left: TSImportTypeQualifier;
+  right: IdentifierName$1;
+  parent?: Node$1;
+}
+declare type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
+declare interface TSIndexedAccessType$1 extends Span$1 {
+  type: "TSIndexedAccessType";
+  objectType: TSType$1;
+  indexType: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSIndexSignature$1 extends Span$1 {
+  type: "TSIndexSignature";
+  parameters: Array<TSIndexSignatureName>;
+  typeAnnotation: TSTypeAnnotation$1;
+  readonly: boolean;
+  static: boolean;
+  accessibility: null;
+  parent?: Node$1;
+}
+declare interface TSIndexSignatureName extends Span$1 {
+  type: "Identifier";
+  decorators: [];
+  name: string;
+  optional: false;
+  typeAnnotation: TSTypeAnnotation$1;
+  parent?: Node$1;
+}
+declare interface TSInferType$1 extends Span$1 {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter;
+  parent?: Node$1;
+}
+declare interface TSInstantiationExpression$1 extends Span$1 {
+  type: "TSInstantiationExpression";
+  expression: Expression$1;
+  typeArguments: TSTypeParameterInstantiation$1;
+  parent?: Node$1;
+}
+declare interface TSInterfaceBody$1 extends Span$1 {
+  type: "TSInterfaceBody";
+  body: Array<TSSignature>;
+  parent?: Node$1;
+}
+declare interface TSInterfaceDeclaration$1 extends Span$1 {
+  type: "TSInterfaceDeclaration";
+  id: BindingIdentifier$1;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  extends: Array<TSInterfaceHeritage>;
+  body: TSInterfaceBody$1;
+  declare: boolean;
+  parent?: Node$1;
+}
+declare interface TSInterfaceHeritage extends Span$1 {
+  type: "TSInterfaceHeritage";
+  expression: Expression$1;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSIntersectionType$1 extends Span$1 {
+  type: "TSIntersectionType";
+  types: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSIntrinsicKeyword extends Span$1 {
+  type: "TSIntrinsicKeyword";
+  parent?: Node$1;
+}
+declare type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
+declare interface TSLiteralType$1 extends Span$1 {
+  type: "TSLiteralType";
+  literal: TSLiteral;
+  parent?: Node$1;
+}
+declare interface TSMappedType$1 extends Span$1 {
+  type: "TSMappedType";
+  key: BindingIdentifier$1;
+  constraint: TSType$1;
+  nameType: TSType$1 | null;
+  typeAnnotation: TSType$1 | null;
+  optional: TSMappedTypeModifierOperator | false;
+  readonly: TSMappedTypeModifierOperator | null;
+  parent?: Node$1;
+}
+declare type TSMappedTypeModifierOperator = true | "+" | "-";
+declare interface TSMethodSignature$1 extends Span$1 {
+  type: "TSMethodSignature";
+  key: PropertyKey_2;
+  computed: boolean;
+  optional: boolean;
+  kind: TSMethodSignatureKind;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  params: ParamPattern$1[];
+  returnType: TSTypeAnnotation$1 | null;
+  accessibility: null;
+  readonly: false;
+  static: false;
+  parent?: Node$1;
+}
+declare type TSMethodSignatureKind = "method" | "get" | "set";
+declare interface TSModuleBlock$1 extends Span$1 {
+  type: "TSModuleBlock";
+  body: Array<Directive | Statement$1>;
+  parent?: Node$1;
+}
+declare interface TSModuleDeclaration$1 extends Span$1 {
+  type: "TSModuleDeclaration";
+  id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
+  body: TSModuleBlock$1 | null;
+  kind: TSModuleDeclarationKind;
+  declare: boolean;
+  global: false;
+  parent?: Node$1;
+}
+declare type TSModuleDeclarationKind = "module" | "namespace";
+declare type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
+declare interface TSNamedTupleMember$1 extends Span$1 {
+  type: "TSNamedTupleMember";
+  label: IdentifierName$1;
+  elementType: TSTupleElement;
+  optional: boolean;
+  parent?: Node$1;
+}
+declare interface TSNamespaceExportDeclaration$1 extends Span$1 {
+  type: "TSNamespaceExportDeclaration";
+  id: IdentifierName$1;
+  parent?: Node$1;
+}
+declare interface TSNeverKeyword extends Span$1 {
+  type: "TSNeverKeyword";
+  parent?: Node$1;
+}
+declare interface TSNonNullExpression$1 extends Span$1 {
+  type: "TSNonNullExpression";
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface TSNullKeyword extends Span$1 {
+  type: "TSNullKeyword";
+  parent?: Node$1;
+}
+declare interface TSNumberKeyword extends Span$1 {
+  type: "TSNumberKeyword";
+  parent?: Node$1;
+}
+declare interface TSObjectKeyword extends Span$1 {
+  type: "TSObjectKeyword";
+  parent?: Node$1;
+}
+declare interface TSOptionalType$1 extends Span$1 {
+  type: "TSOptionalType";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSParameterProperty extends Span$1 {
+  type: "TSParameterProperty";
+  accessibility: TSAccessibility | null;
+  decorators: Array<Decorator$1>;
+  override: boolean;
+  parameter: FormalParameter;
+  readonly: boolean;
+  static: boolean;
+  parent?: Node$1;
+}
+declare interface TSParenthesizedType$1 extends Span$1 {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSPropertySignature$1 extends Span$1 {
+  type: "TSPropertySignature";
+  computed: boolean;
+  optional: boolean;
+  readonly: boolean;
+  key: PropertyKey_2;
+  typeAnnotation: TSTypeAnnotation$1 | null;
+  accessibility: null;
+  static: false;
+  parent?: Node$1;
+}
+declare interface TSQualifiedName$1 extends Span$1 {
+  type: "TSQualifiedName";
+  left: TSTypeName;
+  right: IdentifierName$1;
+  parent?: Node$1;
+}
+declare interface TSRestType$1 extends Span$1 {
+  type: "TSRestType";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSSatisfiesExpression$1 extends Span$1 {
+  type: "TSSatisfiesExpression";
+  expression: Expression$1;
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
+declare interface TSStringKeyword extends Span$1 {
+  type: "TSStringKeyword";
+  parent?: Node$1;
+}
+declare interface TSSymbolKeyword extends Span$1 {
+  type: "TSSymbolKeyword";
+  parent?: Node$1;
+}
+declare interface TSTemplateLiteralType$1 extends Span$1 {
+  type: "TSTemplateLiteralType";
+  quasis: Array<TemplateElement$1>;
+  types: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSThisParameter extends Span$1 {
+  type: "Identifier";
+  decorators: [];
+  name: "this";
+  optional: false;
+  typeAnnotation: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSThisType extends Span$1 {
+  type: "TSThisType";
+  parent?: Node$1;
+}
+declare type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
+declare interface TSTupleType$1 extends Span$1 {
+  type: "TSTupleType";
+  elementTypes: Array<TSTupleElement>;
+  parent?: Node$1;
+}
+declare type TSType$1 = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType$1 | TSConditionalType$1 | TSConstructorType$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSTemplateLiteralType$1 | TSThisType | TSTupleType$1 | TSTypeLiteral | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUnionType$1 | TSParenthesizedType$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType;
+declare interface TSTypeAliasDeclaration$1 extends Span$1 {
+  type: "TSTypeAliasDeclaration";
+  id: BindingIdentifier$1;
+  typeParameters: TSTypeParameterDeclaration$1 | null;
+  typeAnnotation: TSType$1;
+  declare: boolean;
+  parent?: Node$1;
+}
+declare interface TSTypeAnnotation$1 extends Span$1 {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare interface TSTypeAssertion$1 extends Span$1 {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType$1;
+  expression: Expression$1;
+  parent?: Node$1;
+}
+declare interface TSTypeLiteral extends Span$1 {
+  type: "TSTypeLiteral";
+  members: Array<TSSignature>;
+  parent?: Node$1;
+}
+declare type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
+declare interface TSTypeOperator$1 extends Span$1 {
+  type: "TSTypeOperator";
+  operator: TSTypeOperatorOperator;
+  typeAnnotation: TSType$1;
+  parent?: Node$1;
+}
+declare type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
+declare interface TSTypeParameter extends Span$1 {
+  type: "TSTypeParameter";
+  name: BindingIdentifier$1;
+  constraint: TSType$1 | null;
+  default: TSType$1 | null;
+  in: boolean;
+  out: boolean;
+  const: boolean;
+  parent?: Node$1;
+}
+declare interface TSTypeParameterDeclaration$1 extends Span$1 {
+  type: "TSTypeParameterDeclaration";
+  params: Array<TSTypeParameter>;
+  parent?: Node$1;
+}
+declare interface TSTypeParameterInstantiation$1 extends Span$1 {
+  type: "TSTypeParameterInstantiation";
+  params: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSTypePredicate$1 extends Span$1 {
+  type: "TSTypePredicate";
+  parameterName: TSTypePredicateName;
+  asserts: boolean;
+  typeAnnotation: TSTypeAnnotation$1 | null;
+  parent?: Node$1;
+}
+declare type TSTypePredicateName = IdentifierName$1 | TSThisType;
+declare interface TSTypeQuery$1 extends Span$1 {
+  type: "TSTypeQuery";
+  exprName: TSTypeQueryExprName;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
+declare interface TSTypeReference$1 extends Span$1 {
+  type: "TSTypeReference";
+  typeName: TSTypeName;
+  typeArguments: TSTypeParameterInstantiation$1 | null;
+  parent?: Node$1;
+}
+declare interface TSUndefinedKeyword extends Span$1 {
+  type: "TSUndefinedKeyword";
+  parent?: Node$1;
+}
+declare interface TSUnionType$1 extends Span$1 {
+  type: "TSUnionType";
+  types: Array<TSType$1>;
+  parent?: Node$1;
+}
+declare interface TSUnknownKeyword extends Span$1 {
+  type: "TSUnknownKeyword";
+  parent?: Node$1;
+}
+declare interface TSVoidKeyword extends Span$1 {
+  type: "TSVoidKeyword";
+  parent?: Node$1;
+}
+declare interface UnaryExpression$1 extends Span$1 {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  argument: Expression$1;
+  prefix: true;
+  parent?: Node$1;
+}
+declare type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
+declare interface UpdateExpression$1 extends Span$1 {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  prefix: boolean;
+  argument: SimpleAssignmentTarget$1;
+  parent?: Node$1;
+}
+declare type UpdateOperator = "++" | "--";
+declare interface V8IntrinsicExpression extends Span$1 {
+  type: "V8IntrinsicExpression";
+  name: IdentifierName$1;
+  arguments: Array<Argument$1>;
+  parent?: Node$1;
+}
+declare interface VariableDeclaration$1 extends Span$1 {
+  type: "VariableDeclaration";
+  kind: VariableDeclarationKind;
+  declarations: Array<VariableDeclarator$1>;
+  declare?: boolean;
+  parent?: Node$1;
+}
+declare type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
+declare interface VariableDeclarator$1 extends Span$1 {
+  type: "VariableDeclarator";
+  id: BindingPattern$1;
+  init: Expression$1 | null;
+  definite?: boolean;
+  parent?: Node$1;
+}
+declare interface WhileStatement$1 extends Span$1 {
+  type: "WhileStatement";
+  test: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface WithStatement$1 extends Span$1 {
+  type: "WithStatement";
+  object: Expression$1;
+  body: Statement$1;
+  parent?: Node$1;
+}
+declare interface YieldExpression$1 extends Span$1 {
+  type: "YieldExpression";
+  delegate: boolean;
+  argument: Expression$1 | null;
+  parent?: Node$1;
+}
+declare const ScriptOrigin: S.Struct<{
+  readonly line: S.Int;
+  readonly columnShift: S.Int;
+}>;
+type ScriptOrigin = typeof ScriptOrigin.Type;
+//#endregion
+//#region src/Syntax.schema.d.ts
+declare const AstFormat: S.Literals<readonly ["js", "ts", "tsx"]>;
+type AstFormat = typeof AstFormat.Type;
+//#endregion
+//#region src/Ast.schema.d.ts
+interface SpannedComment {
+  readonly type: 'Line' | 'Block';
+  readonly value: string;
+  readonly start: number;
+  readonly end: number;
+}
+type ScriptFormat = Extract<AstFormat, 'js' | 'ts' | 'tsx'>;
+interface BaseAst {
+  originFileName: string;
+  rawContent: string;
+  root: Program;
+  offset?: ScriptOrigin;
+}
+interface EmbeddedAst {
+  format: 'embedded';
+  formatId: FormatId;
+  originFileName: string;
+  rawContent: string;
+  document: EmbeddedDocument;
+  readonly context: FrameworkContext;
+  scripts: readonly EmbeddedScript[];
+}
+interface EmbeddedScript {
+  readonly region: number;
+  readonly ast: ScriptAst;
+}
+interface JSAst extends BaseAst {
+  format: 'js';
+  root: Program;
+  comments: readonly SpannedComment[];
+}
+interface TSAst extends BaseAst {
+  format: 'ts';
+  root: Program;
+  comments: readonly SpannedComment[];
+}
+interface TsxAst extends BaseAst {
+  format: 'tsx';
+  root: Program;
+  comments: readonly SpannedComment[];
+}
+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: mod_d_exports$2$1.MutantId;
+  readonly fileName: string;
+  readonly original: Node_2;
+  readonly location: mod_d_exports$2$1.Location;
+  readonly replacementCode: string;
+}
+interface MutatorContext {
+  readonly parent: Node_2 | undefined;
+  readonly grandParent: Node_2 | undefined;
+  readonly ancestors: readonly Node_2[];
+  readonly mutantSetPolicy: mod_d_exports$5.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: mod_d_exports$5.MutantSetPolicyType;
+  noHeader?: boolean;
+}
+type MutatorEntry = readonly [name: string, mutate: Mutator];
+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[];
+}
+//#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.decodeTo<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;
+  };
+}>, 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;
+}
+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>;
+}>;
+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;
+  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.decodeTo<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;
+      };
+    }>, 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.String, "MutatorName">;
+    readonly replacement: S.String;
+    readonly location: S.decodeTo<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;
+      };
+    }>, 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>>;
+    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/MutantIdentity.d.ts
+interface MutantTuple {
+  readonly fileName: string;
+  readonly mutatorName: string;
+  readonly originalCode: string;
+  readonly replacementCode: string;
+}
+//#endregion
+//#region src/Transformer.service.d.ts
+interface TransformerOptions extends MutatorOptions {
+  ignorers: readonly Ignorer[];
+}
+interface MutantCollector {
+  /** 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$1.Effect<readonly string[], ParseFailed | InstrumentError>;
+interface TransformerContext {
+  transform: AstTransformer;
+  options: TransformerOptions;
+  mutateDescription: MutateDescription;
+  registry: FormatRegistry;
+  readonly basePath?: string | undefined;
+}
+//#endregion
+//#region src/Format.schema.d.ts
+type FormatKind = 'script' | 'embedded';
+interface FormatClaim<Kind extends FormatKind = FormatKind> {
+  readonly formatId: FormatId;
+  readonly extensions: readonly string[];
+  readonly language: string;
+  readonly kind: Kind;
+}
+interface ScriptHooks {
+  readonly parse: (text: string, fileName: string, context: ParserContext) => Effect$1.Effect<Ast, ParseFailed | InstrumentError>;
+  readonly transform: AstTransformer;
+  readonly print: (ast: Ast, context: PrinterContext) => string;
+  readonly disableTypeChecks: (ast: Ast) => Effect$1.Effect<string, InstrumentError>;
+}
+interface FormatHooks extends ScriptHooks {
+  readonly owner: string;
+  readonly ownerVersion: string;
+}
+interface ScriptFormatEntry extends FormatHooks {
+  readonly claim: FormatClaim<'script'>;
+  readonly scriptFormat: ScriptFormat;
+}
+interface EmbeddedFormatEntry extends FormatHooks {
+  readonly claim: FormatClaim<'embedded'>;
+}
+type FormatEntry = ScriptFormatEntry | EmbeddedFormatEntry;
+type EntryForFormat = (formatId: string) => Option$1.Option<FormatEntry>;
+interface FormatRegistry {
+  readonly entries: readonly FormatEntry[];
+  readonly entryForFormat: EntryForFormat;
+  readonly entryForExtension: (extension: string) => Option$1.Option<FormatEntry>;
+}
+//#endregion
+//#region src/Format.d.ts
+declare const extensionOf: (fileName: string) => string;
+declare const registerEntries: {
+  (registry: FormatRegistry, additions: readonly FormatEntry[]): FormatRegistry;
+  (additions: readonly FormatEntry[]): (registry: FormatRegistry) => FormatRegistry;
+};
+declare const coreFormatRegistry: FormatRegistry;
+//#endregion
+//#region src/FrameworkEntry.d.ts
+declare const frameworkEntryOf: {
+  (moduleName: string, framework: Framework): EmbeddedFormatEntry;
+  (framework: Framework): (moduleName: string) => EmbeddedFormatEntry;
+};
+declare namespace mod_d_exports$1 {
+  export { EmbeddedFormatEntry, FormatClaim, FormatEntry, FormatHooks, FormatKind, FormatRegistry, ScriptFormatEntry, coreFormatRegistry, extensionOf, frameworkEntryOf, registerEntries };
+}
+//#endregion
+//#region src/Instrument.service.d.ts
+interface File extends FileDescription {
+  name: string;
+  content: string;
+}
+interface InstrumentResult {
+  files: readonly File[];
+  mutants: readonly mod_d_exports$2$1.Mutant[];
+  skipped: readonly InstrumentFileSkip[];
+}
+declare const instrument: {
+  (files: readonly File[], options: InstrumenterOptions, registry?: FormatRegistry): Effect$1.Effect<InstrumentResult$1, InstrumentError>;
+  (options: InstrumenterOptions, registry?: FormatRegistry): (files: readonly File[]) => Effect$1.Effect<InstrumentResult$1, InstrumentError>;
+};
+declare const disableTypeChecks: {
+  (file: File, registry?: FormatRegistry): Effect$1.Effect<File, InstrumentError>;
+  (registry?: FormatRegistry): (file: File) => Effect$1.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, InstrumenterContext, InstrumenterOptions, MutateDescription, ParserOptions, disableTypeChecks, instrument };
+}
+//#endregion
+//#region src/IncrementalDiff.schema.d.ts
+declare const TimeoutEvidenceSchema: S.Struct<{
+  readonly timeoutKind: S.Literals<readonly ["wallClock", "hitLimit"]>;
+  readonly reproductions: S.Natural;
+}>;
+type TimeoutEvidence = S.Schema.Type<typeof TimeoutEvidenceSchema>;
+//#endregion
+//#region src/IncrementalReport.schema.d.ts
+declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
+  readonly incrementalVersion: S.String;
+  readonly schemaVersion: S.String;
+  readonly verdictSemanticsVersion: S.Int;
+  readonly mutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+  readonly runInputsDigest: S.String;
+  readonly thresholds: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+  }>;
+  readonly files: 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 mutatorName: S.String;
+      readonly replacement: S.String;
+      readonly location: S.decodeTo<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;
+        };
+      }>, 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.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+      readonly killedBy: S.optional<S.$Array<S.String>>;
+      readonly coveredBy: S.optional<S.$Array<S.String>>;
+      readonly static: S.optional<S.Boolean>;
+      readonly statusReason: S.optional<S.String>;
+      readonly testsCompleted: S.optional<S.Finite>;
+      readonly description: S.optional<S.String>;
+      readonly duration: S.optional<S.Finite>;
+    }>>;
+    readonly formatIdentity: S.optional<S.Struct<{
+      readonly formatId: S.String;
+      readonly ownerModule: S.String;
+      readonly ownerVersion: S.String;
+    }>>;
+  }>>;
+  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 name: S.String;
+      readonly location: S.optional<S.decodeTo<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;
+      }>, 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;
+        }>>;
+      }>, never, never>>;
+    }>>;
+  }>>>;
+  readonly dryRunCoverage: S.optionalKey<S.Unknown>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+type IncrementalReport = S.Schema.Type<typeof IncrementalReportSchema>;
+//#endregion
+//#region src/Project.schema.d.ts
+interface ProjectFile extends mod_d_exports$2.FileDescription {
+  readonly name: string;
+  readonly mutate: mod_d_exports$2.MutateDescription;
+  readonly content: string | undefined;
+  readonly originalContent: string | undefined;
+}
+interface Project {
+  readonly fileDescriptions: mod_d_exports$2.FileDescriptions;
+  readonly incrementalReport: IncrementalReport | undefined;
+  readonly testFiles: readonly string[];
+  readonly files: MutableHashMap.MutableHashMap<string, ProjectFile>;
+  readonly filesToMutate: MutableHashMap.MutableHashMap<string, ProjectFile>;
+}
+//#endregion
+//#region src/project-files.service.d.ts
+type ContentPair = readonly [ProjectFile, string];
+type PathPair = readonly [string, string];
+interface InPlaceTarget {
+  readonly backupDirectory: string;
+  readonly basePath: string;
+}
+interface SandboxTarget {
+  readonly workingDirectory: string;
+  readonly basePath: string;
+}
+interface ProjectFilesShape {
+  readonly read: (file: ProjectFile) => Effect$1.Effect<string, PlatformError>;
+  readonly readAll: (files: Iterable<ProjectFile>) => Effect$1.Effect<readonly ContentPair[], PlatformError>;
+  readonly readAllOriginal: (files: Iterable<ProjectFile>) => Effect$1.Effect<readonly ContentPair[], PlatformError>;
+  readonly writeAllInPlace: (files: Iterable<readonly [string, ProjectFile]>, target: InPlaceTarget) => Effect$1.Effect<readonly PathPair[], PlatformError>;
+  readonly writeAllToSandbox: (files: Iterable<readonly [string, ProjectFile]>, target: SandboxTarget) => Effect$1.Effect<readonly PathPair[], PlatformError>;
+}
+declare const ProjectFiles_base: Context.ServiceClass<ProjectFiles, "@systemfsoftware/stryker-js/project-files.service/ProjectFiles", ProjectFilesShape>;
+declare class ProjectFiles extends ProjectFiles_base {
+  static readonly layer: Layer.Layer<ProjectFiles, never, FileSystem.FileSystem | Path.Path>;
+}
+//#endregion
+//#region src/spawned-socket-worker.handle.d.ts
+declare const TypeId$1: unique symbol;
+type TypeId$1 = typeof TypeId$1;
+interface SpawnedSocketWorkerSlot {
+  readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+}
+declare const SpawnedSocketWorker: Handle.Definition<typeof TypeId$1, {
+  readonly pid: number;
+  readonly exited: Effect$1.Effect<never, WorkerExit>;
+}, SpawnedSocketWorkerSlot, never>;
+type SpawnedSocketWorker = Handle.Of<typeof SpawnedSocketWorker>;
+declare const make: (worker: {
+  readonly pid: number;
+  readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+  readonly exited: Effect$1.Effect<never, WorkerExit>;
+}) => SpawnedSocketWorker;
+//#endregion
+//#region src/WorkerLauncher.service.d.ts
+interface WorkerSpawnParams {
+  readonly entrypoint: string;
+  readonly workingDirectory: string;
+  readonly execArgv: readonly string[];
+  readonly optionsJson: string;
+  readonly tempDirPrefix: string;
+  readonly env?: Readonly<Record<string, string>> | undefined;
+}
+interface WorkerLauncherShape {
+  readonly spawn: (params: WorkerSpawnParams) => Effect$1.Effect<SpawnedSocketWorker, ChildProcessCrashedError, Scope.Scope>;
+}
+declare const WorkerLauncher_base: Context.ServiceClass<WorkerLauncher, "@systemfsoftware/stryker-js/WorkerLauncher.service/WorkerLauncher", WorkerLauncherShape>;
+declare class WorkerLauncher extends WorkerLauncher_base {}
+//#endregion
+//#region src/reporter-stream.service.d.ts
+declare const ReporterStageTypeId: unique symbol;
+/**
+ * An attached reporter stage, opaque at the engine boundary: the published
+ * phase types carry this handle so the attachment machinery (queues, fibers,
+ * the state latch) never reaches an adopter's compiler. Constructed only by
+ * `attachReporterFactories`.
+ */
+interface ReporterStage {
+  readonly [ReporterStageTypeId]: typeof ReporterStageTypeId;
+}
+declare const REPORTER_EVENT_BATCH_BOUND = 128;
+type ReporterWorkerClient = RpcClient.RpcClient<RpcGroup.Rpcs<typeof mod_d_exports$6.ReporterRpcs>, RpcClientError>;
+declare const reporterWorkerFactory: (client: ReporterWorkerClient) => mod_d_exports$8.ReporterFactory;
+interface SpawnReporterWorkerParams {
+  readonly entrypoint: string;
+  readonly projectBasePath: string;
+  readonly execArgv: readonly string[];
+  readonly options: mod_d_exports$5.StrykerOptions;
+  readonly tempDirPrefix: string;
+}
+declare const spawnReporterWorker: (params: SpawnReporterWorkerParams) => Effect$1.Effect<ReporterWorkerClient, WorkerBootError, Scope.Scope | WorkerLauncher>;
+//#endregion
+//#region src/dry-run-coverage.schema.d.ts
+declare const DryRunCoverageSchema: S.Struct<{
+  readonly tests: S.$Array<S.Union<readonly [S.Struct<{
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"failed">;
+    readonly failureMessage: S.String;
+  }>, S.Struct<{
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"skipped">;
+  }>, S.Struct<{
+    readonly id: S.brand<S.NonEmptyString, "TestId">;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>>;
+    readonly status: S.Literal<"success">;
+  }>]>>;
+  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 globalTestInputs: S.$Array<S.String>;
+  readonly timeOverheadMs: S.Finite;
+  readonly flakyTestIds: S.$Array<S.String>;
+  readonly flakyMutantIds: S.$Array<S.String>;
+  readonly testClosureDigest: S.String;
+  readonly runInputsDigest: S.String;
+}>;
+type DryRunCoverage = S.Schema.Type<typeof DryRunCoverageSchema>;
+//#endregion
+//#region src/test-coverage.schema.d.ts
+interface TestCoverage {
+  readonly testsByMutantId: MutableHashMap.MutableHashMap<string, MutableHashSet.MutableHashSet<mod_d_exports$9.TestResult>>;
+  readonly testsById: MutableHashMap.MutableHashMap<string, mod_d_exports$9.TestResult>;
+  readonly staticCoverage: mod_d_exports$2$1.CoverageData | undefined;
+  readonly hitsByMutantId: MutableHashMap.MutableHashMap<string, number>;
+  readonly dryRunCoverage?: DryRunCoverage | undefined;
+}
+//#endregion
+//#region src/Sandbox.handle.d.ts
+declare const TypeId: unique symbol;
+type TypeId = typeof TypeId;
+declare const SandboxHandle: Handle.Definition<typeof TypeId, {
+  readonly workingDirectory: string;
+}, {
+  readonly fileMap: Map<string, string>;
+  readonly basePath: string;
+  readonly pathService: Path.Path;
+}, never>;
+type SandboxHandle = Handle.Of<typeof SandboxHandle>;
+//#endregion
+//#region src/decode-mutator-selection.workflow.d.ts
+declare const MutatorSelectionTypeId: unique symbol;
+type MutatorSelectionTypeId = typeof MutatorSelectionTypeId;
+declare const MutatorSelectionDecoded_base: S.Class<MutatorSelectionDecoded, S.TaggedStruct<"MutatorSelectionDecoded", {
+  readonly excludedMutations: S.$Array<S.String>;
+  readonly optInMutations: S.$Array<S.String>;
+}>, {}>;
+declare class MutatorSelectionDecoded extends MutatorSelectionDecoded_base {
+  readonly [MutatorSelectionTypeId]: symbol;
+}
+//#endregion
+//#region src/plan-mutator-catalogs.workflow.d.ts
+declare const MergedCatalogSchema: S.Struct<{
+  readonly provider: S.brand<S.String, "MutatorProvider">;
+  readonly entries: S.$Array<S.Struct<{
+    readonly id: S.brand<S.String, "MutatorCatalogId">;
+    readonly name: S.brand<S.String, "MutatorName">;
+    readonly tier: S.Literals<readonly ["default", "optIn"]>;
+    readonly definition: S.NonEmptyString;
+    readonly examples: S.$Array<S.Struct<{
+      readonly before: S.String;
+      readonly after: S.$Array<S.String>;
+    }>>;
+  }>>;
+}>;
+type MergedCatalog = typeof MergedCatalogSchema.Type;
+//#endregion
+//#region src/Plugins.schema.d.ts
+type PluginKind = mod_d_exports$6.PluginKind;
+interface WorkerPluginDescriptor<K extends mod_d_exports$6.WorkerPluginKind = mod_d_exports$6.WorkerPluginKind> {
+  readonly kind: K;
+  readonly name: string;
+  readonly workerEntry: string;
+}
+interface EvaluatorPluginDescriptor {
+  readonly kind: 'Evaluator';
+  readonly name: string;
+}
+type AnyWorkerPluginDescriptor = { [K in mod_d_exports$6.WorkerPluginKind]: WorkerPluginDescriptor<K>; }[mod_d_exports$6.WorkerPluginKind];
+type AnyPluginDescriptor = AnyWorkerPluginDescriptor | EvaluatorPluginDescriptor;
+type PluginDescriptorOf<K extends PluginKind> = Extract<AnyPluginDescriptor, {
+  readonly kind: K;
+}>;
+type PluginDescriptor<K extends PluginKind = PluginKind> = PluginDescriptorOf<K>;
+interface WorkerPluginSource<K extends mod_d_exports$6.WorkerPluginKind = mod_d_exports$6.WorkerPluginKind> {
+  readonly kind: K;
+  readonly name: string;
+  readonly modulePath: string;
+  readonly workerEntry: string;
+}
+interface EvaluatorPluginSource {
+  readonly kind: 'Evaluator';
+  readonly name: string;
+  readonly modulePath: string;
+}
+type AnyWorkerPluginSource = { [K in mod_d_exports$6.WorkerPluginKind]: WorkerPluginSource<K>; }[mod_d_exports$6.WorkerPluginKind];
+type PluginSource = AnyWorkerPluginSource | EvaluatorPluginSource;
+interface LoadedMutatorProvider {
+  readonly moduleName: string;
+  readonly contribution: mod_d_exports$4.ContributionValue;
+}
+interface LoadedPlugins<A = unknown> {
+  readonly schemaContributions: readonly Record<string, A>[];
+  readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
+  readonly pluginModulePaths: readonly string[];
+  readonly pluginSources: readonly PluginSource[];
+  readonly ignorers: readonly Ignorer$1[];
+  readonly mutators: readonly LoadedMutatorProvider[];
+  readonly frameworks: readonly {
+    readonly moduleName: string;
+    readonly framework: Framework;
+  }[];
+}
+//#endregion
+//#region src/reporter-output.service.d.ts
+type OutputChannel = 'stdout' | 'stderr';
+interface ReporterOutputShape {
+  readonly write: (channel: OutputChannel, chunks: readonly string[]) => Effect$1.Effect<void, PlatformError>;
+}
+declare const ReporterOutput_base: Context.ServiceClass<ReporterOutput, "@systemfsoftware/stryker-js/reporter-output.service/ReporterOutput", ReporterOutputShape>;
+declare class ReporterOutput extends ReporterOutput_base {
+  static readonly layer: Layer.Layer<ReporterOutput, never, Stdio.Stdio>;
+}
+//#endregion
+//#region src/reporter.service.d.ts
+interface ReporterShape {
+  readonly builtin: Readonly<Record<string, mod_d_exports$8.ReporterFactory>>;
+}
+declare const Reporter_base: Context.ServiceClass<Reporter, "@systemfsoftware/stryker-js/reporter.service/Reporter", ReporterShape>;
+declare class Reporter extends Reporter_base {
+  static readonly layer: Layer.Layer<Reporter, never, ReporterOutput | FileSystem.FileSystem | Path.Path>;
+}
+//#endregion
+//#region src/run/explain-file-skip.workflow.d.ts
+declare const FrameworkClaimant: S.Struct<{
+  readonly package: S.String;
+  readonly extensions: S.$Array<S.String>;
+}>;
+type FrameworkClaimant = S.Schema.Type<typeof FrameworkClaimant>;
+//#endregion
+//#region src/run/prepare.cell.d.ts
+interface PrepareDone {
+  readonly project: Project;
+  readonly loadedPlugins: LoadedPlugins;
+  readonly ignorers: readonly Ignorer$1[];
+  readonly mutatorCatalogs: readonly MergedCatalog[];
+  readonly mutatorSelection: MutatorSelectionDecoded;
+  readonly formatRegistry: mod_d_exports$1.FormatRegistry;
+  readonly options: mod_d_exports$5.StrykerOptions;
+  readonly temporaryDirectoryPath: string;
+  readonly reporterStage: ReporterStage;
+  readonly frameworkClaimants: readonly FrameworkClaimant[];
+}
+interface PrepareExecutorArgs {
+  cliOptions: mod_d_exports$5.PartialStrykerOptions;
+  targetMutatePatterns: string[] | undefined;
+}
+//#endregion
+//#region src/run/instrument.cell.d.ts
+interface InstrumentDone extends PrepareDone {
+  readonly mutants: readonly mod_d_exports$2$1.Mutant[];
+  readonly sandbox: SandboxHandle;
+  readonly concurrency: {
+    readonly testRunners: number;
+    readonly checkers: number;
+  };
+}
+//#endregion
+//#region src/run/dry-run.cell.d.ts
+interface DryRunDone extends InstrumentDone {
+  readonly dryRunResult: mod_d_exports$9.CompleteDryRunResult;
+  readonly testCoverage: TestCoverage;
+  readonly timeOverhead: EffectDuration.Duration;
+}
+//#endregion
+//#region src/run/mutation-test.cell.d.ts
+interface MutationTestDone {
+  readonly results: readonly mod_d_exports$2$1.RunMutantResult[];
+  readonly verdict: mod_d_exports$6.ExitClass | null;
+}
+//#endregion
+//#region src/mutation-reporting.service.d.ts
+interface MutationReportingInput {
+  readonly results: readonly mod_d_exports$2$1.RunMutantResult[];
+  readonly options: mod_d_exports$5.StrykerOptions;
+  readonly project: Project;
+  readonly testCoverage: TestCoverage;
+  readonly runId: string;
+  readonly resolvedMode: ResolvedMode;
+  readonly basePath: string;
+  readonly reporterStage: ReporterStage;
+  readonly formatRegistry: mod_d_exports$1.FormatRegistry;
+  readonly closureDigestsByMutantId?: Readonly<Record<string, string>>;
+  readonly timeoutEvidenceByMutantId?: Readonly<Record<string, TimeoutEvidence>>;
+}
+interface MutationReportingService {
+  readonly reportCheckFailure: (mutant: mod_d_exports$2$1.MutantTestCoverage, result: Exclude<mod_d_exports$3.CheckResult, mod_d_exports$3.PassedCheckResult>) => Effect$1.Effect<mod_d_exports$2$1.RunMutantResult>;
+  readonly reportMutantRunResult: (mutant: mod_d_exports$2$1.MutantTestCoverage, result: mod_d_exports$9.MutantRunResult) => Effect$1.Effect<mod_d_exports$2$1.RunMutantResult>;
+  readonly reportAll: (input: MutationReportingInput) => Effect$1.Effect<MutationTestDone, PlatformError>;
+  readonly checkpoint: (input: MutationReportingInput, plannedMutants: readonly mod_d_exports$2$1.Mutant[]) => Effect$1.Effect<void, PlatformError>;
+}
+declare const MutationReporting_base: Context.ServiceClass<MutationReporting, "@systemfsoftware/stryker-js/mutation-reporting.service/MutationReporting", MutationReportingService>;
+declare class MutationReporting extends MutationReporting_base {
+  static readonly layer: Layer.Layer<MutationReporting, never, FileSystem.FileSystem | Path.Path | RunEvents | ProjectFiles | PhaseClock>;
+}
+//#endregion
+//#region src/Worker.service.d.ts
+interface IdGeneratorShape {
+  readonly next: Effect$1.Effect<number>;
+}
+declare const IdGenerator_base: Context.ServiceClass<IdGenerator, "@systemfsoftware/stryker-js/Worker.service/IdGenerator", IdGeneratorShape>;
+declare class IdGenerator extends IdGenerator_base {
+  static readonly layer: Layer.Layer<IdGenerator, never, never>;
+}
+//#endregion
+//#region src/run/StageServices.service.d.ts
+type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | GitDiff | IdGenerator | MutationReporting | Path.Path | PhaseClock | ProjectFiles | Reporter | RunEnvironment | RunEvents | Scope.Scope | Stdio.Stdio | WorkerLauncher;
+type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | GitDiff | Path.Path | Stdio.Stdio | WorkerLauncher;
+type RunStageServices = ProjectFiles | Reporter | RunEnvironment | RunEvents | IdGenerator | MutationReporting | PhaseClock | Scope.Scope;
+type WiredRunLayer = Layer.Layer<RunStageServices | EnginePorts, never, never>;
+//#endregion
+//#region src/run/RunEnvironment.service.d.ts
+interface RunEnvironmentShape {
+  readonly runId: string;
+  readonly resolvedMode: ResolvedMode;
+  readonly runStartedAt: number;
+  readonly basePath: string;
+  readonly builtinReporters: Readonly<Record<string, mod_d_exports$8.ReporterFactory>>;
+  readonly allowConsoleColors: boolean;
+}
+declare const RunEnvironment_base: Context.ServiceClass<RunEnvironment, "@systemfsoftware/stryker-js/run/RunEnvironment.service/RunEnvironment", RunEnvironmentShape>;
+declare class RunEnvironment extends RunEnvironment_base {
+  static readonly stage: {
+    (env: RunEnvironmentShape, events?: Queue.Queue<mod_d_exports$1$1.RunEvent, Cause.Done>): Layer.Layer<RunStageServices, never, EnginePorts>;
+    (events?: Queue.Queue<mod_d_exports$1$1.RunEvent, Cause.Done>): (env: RunEnvironmentShape) => Layer.Layer<RunStageServices, never, EnginePorts>;
+  };
+  static readonly forStream: {
+    (mode: ResolvedMode, stream: RunEventStream, host: {
+      readonly noColor?: string | undefined;
+      readonly builtinReporters: Readonly<Record<string, mod_d_exports$8.ReporterFactory>>;
+    }): Effect$1.Effect<RunEnvironmentShape, PlatformError, FileSystem.FileSystem>;
+    (stream: RunEventStream, host: {
+      readonly noColor?: string | undefined;
+      readonly builtinReporters: Readonly<Record<string, mod_d_exports$8.ReporterFactory>>;
+    }): (mode: ResolvedMode) => Effect$1.Effect<RunEnvironmentShape, PlatformError, FileSystem.FileSystem>;
+  };
+}
+//#endregion
+export { makeRunEventStream as $, ReporterWorkerClient as A, ProjectFile as B, PluginSource as C, TestCoverage as D, SandboxHandle as E, WorkerLauncherShape as F, git_diff_service_d_exports as G, mod_d_exports$2 as H, WorkerSpawnParams as I, RunIdentity as J, git_diff_schema_d_exports as K, SpawnedSocketWorker as L, reporterWorkerFactory as M, spawnReporterWorker as N, REPORTER_EVENT_BATCH_BOUND as O, WorkerLauncher as P, RunEventStream as Q, make as R, PluginKind as S, WorkerPluginSource as T, Framework as U, IncrementalReportSchema as V, GitDiff as W, RunEventDrain as X, RunIdentityShape as Y, RunEventDrainLive as Z, EvaluatorPluginDescriptor as _, StageServices as a, StrykerError as at, PluginDescriptor as b, IdGeneratorShape as c, ConfigFileNotFoundError as ct, InstrumentDone as d, ChildProcessCrashedError as dt, ResolvedModeInput as et, PrepareDone as f, OutOfMemoryError as ft, AnyWorkerPluginSource as g, AnyWorkerPluginDescriptor as h, WorkerExit as ht, RunStageServices as i, mod_d_exports$1$1 as it, SpawnReporterWorkerParams as j, ReporterStage as k, MutationTestDone as l, ConfigFileUnreadableError as lt, AnyPluginDescriptor as m, WorkerBootTimeoutError as mt, RunEnvironmentShape as n, PhaseClock as nt, WiredRunLayer as o, ConfigError as ot, PrepareExecutorArgs as p, WorkerBootError as pt, RunEvents as q, EnginePorts as r, mod_d_exports as rt, IdGenerator as s, ConfigFileInvalidError as st, RunEnvironment as t, ResolvedMode as tt, DryRunDone as u, ConfigFileUnsupportedError as ut, EvaluatorPluginSource as v, WorkerPluginDescriptor as w, PluginDescriptorOf as x, LoadedPlugins as y, Project as z };