@systemfsoftware/stryker-js 4.0.0 → 6.0.0

package/dist/index.d.mts

@@ -1,18 +1,179 @@
 import * as Cause from 'effect/Cause';
+import { Cell } from '@systemfsoftware/effect-cell-types';
+import * as ChildProcessSpawner from 'effect/unstable/process/ChildProcessSpawner';
 import * as Context from 'effect/Context';
+import * as DateTime from 'effect/DateTime';
+import * as Duration from 'effect/Duration';
+import { Duration as Duration_2 } from 'effect/Duration';
 import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';
 import * as FileSystem from 'effect/FileSystem';
 import * as HashMap from 'effect/HashMap';
 import * as Layer from 'effect/Layer';
+import * as MutableHashMap from 'effect/MutableHashMap';
+import * as MutableHashSet from 'effect/MutableHashSet';
 import * as Option from 'effect/Option';
 import * as Path from 'effect/Path';
+import { PlatformError } from 'effect/PlatformError';
 import * as Queue from 'effect/Queue';
+import * as Rpc from 'effect/unstable/rpc/Rpc';
+import * as RpcClient from 'effect/unstable/rpc/RpcClient';
+import { RpcClientError } from 'effect/unstable/rpc/RpcClientError';
+import * as RpcGroup from 'effect/unstable/rpc/RpcGroup';
+import * as RpcMiddleware from 'effect/unstable/rpc/RpcMiddleware';
 import * as S from 'effect/Schema';
-import { StandardSchemaV1 } from 'effect/StandardSchema';
+import * as Schedule from 'effect/Schedule';
+import { Schema } from 'effect';
+import * as Scope from 'effect/Scope';
+import * as Socket from 'effect/unstable/socket/Socket';
+import * as Stdio from 'effect/Stdio';
 import { YieldableError } from 'effect/Cause';
 
-export declare type AnyPluginContribution = { [K in PluginKind]: PluginContribution<K>; }[PluginKind];
+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";
+
+export declare const ACTIONABLE_STATUSES: readonly ['Survived', 'NoCoverage', 'Timeout', 'RuntimeError'];
+
+export declare type AnyPluginDescriptor = AnyWorkerPluginDescriptor | EvaluatorPluginDescriptor;
+
+export declare type AnyWorkerPluginDescriptor = { [K in WorkerPluginKind]: WorkerPluginDescriptor<K>; }[WorkerPluginKind];
+
+export declare type AnyWorkerPluginSource = { [K in WorkerPluginKind]: WorkerPluginSource<K>; }[WorkerPluginKind];
+
+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;
+}
 
 export declare interface BaseTestResult {
     readonly id: string;
@@ -22,71 +183,204 @@ export declare interface BaseTestResult {
     readonly startPosition?: Position;
 }
 
-export declare type BrandingInformation = typeof BrandingInformationSchema.Type;
+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";
 
-export declare const BrandingInformationSchema: S.Struct<{
-    readonly homepageUrl: S.String;
-    readonly imageUrl: S.optional<S.String>;
-}>;
+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;
+}
+
+export declare const buildTestRunner: <ChildRunnerError>(context: TestRunnerBuildContext, childProcessRunner: Effect.Effect<PooledTestRunner, ChildRunnerError, Scope.Scope | WorkerLauncher>) => Effect.Effect<PooledTestRunner, PooledTestRunnerError | ChildRunnerError, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Scope.Scope | WorkerLauncher>;
+
+export declare function buildVerdictEnvelope(report: MutationTestResult, mode: OutputMode, signal: ModeSignal, runId: string, basePath: string, pathService: Path.Path): VerdictEnvelope;
+
+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;
 
 export declare const calculateMetrics: (files: Readonly<Record<string, FileResult>>) => MetricsResult;
 
-export declare const causeText: (cause: unknown, depth: number) => string | undefined;
+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;
+}
 
-export declare class Checker extends Checker_base {}
+declare type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
 
-declare const Checker_base: Context.ServiceClass<Checker, "~@systemfsoftware/stryker-js/Checker", CheckerService>;
+declare interface ChainExpression$1 extends Span$1 {
+    type: "ChainExpression";
+    expression: ChainElement;
+    parent?: Node$1;
+}
 
-export declare class CheckerFailed extends CheckerFailed_base {}
+export declare class CheckerAnsweredUnrequested extends CheckerAnsweredUnrequested_base {}
 
-declare const CheckerFailed_base: S.Class<CheckerFailed, S.TaggedStruct<"CheckerFailed", {
-    readonly cause: S.String;
+declare const CheckerAnsweredUnrequested_base: S.Class<CheckerAnsweredUnrequested, S.TaggedStruct<"CheckerAnsweredUnrequested", {
     readonly checkerName: S.String;
-    readonly mutantIds: S.$Array<S.String>;
+    readonly phase: S.Literals<readonly ["check", "group"]>;
+    readonly unrequestedIds: S.$Array<S.String>;
+    readonly requestedIds: S.$Array<S.String>;
 }>, YieldableError>;
 
-export declare interface CheckerService {
-    readonly init: Effect.Effect<void, CheckerFailed>;
-    readonly check: (mutants: readonly Mutant[]) => Effect.Effect<HashMap.HashMap<string, CheckResult>, CheckerFailed>;
-    readonly group: (mutants: readonly Mutant[]) => Effect.Effect<readonly (readonly string[])[], CheckerFailed>;
+export declare type CheckerContractBroken = CheckerAnsweredUnrequested | CheckerSkippedRequested;
+
+export declare type CheckerCrash = ChildProcessCrashedError | OutOfMemoryError;
+
+/**
+ * A checker held by the pool.
+ *
+ * The pool must be able to interrupt a checker mid-call when the run is
+ * cancelled, so the port uses Effect, which can be interrupted, where a Promise
+ * cannot. The error channel names both crash variants rather than `unknown`,
+ * which lets the retry combinator prove it handles every one of them.
+ */
+export declare interface CheckerResourceService {
+    readonly check: (checkerName: string, mutants: readonly Mutant[]) => Effect.Effect<Record<string, CheckResult>, CheckerCrash>;
+    /**
+     * Partition mutants into groups that can be checked together.
+     *
+     * A checker with no grouping opinion returns one group per mutant — the
+     * identity partition — rather than leaving the member off, which is what
+     * every call site used to synthesise for itself.
+     */
+    readonly group: (checkerName: string, mutants: readonly Mutant[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash>;
 }
 
-export declare type CheckResult = FailedCheckResult | PassedCheckResult;
+export declare class CheckerSkippedRequested extends CheckerSkippedRequested_base {}
 
-export declare const CheckResultSchema: S.Union<readonly [S.Struct<{
-    readonly status: S.Literal<"passed">;
-}>, S.Struct<{
-    readonly status: S.Literal<"compileError">;
-    readonly reason: S.String;
-}>]>;
+declare const CheckerSkippedRequested_base: S.Class<CheckerSkippedRequested, S.TaggedStruct<"CheckerSkippedRequested", {
+    readonly checkerName: S.String;
+    readonly phase: S.Literals<readonly ["check", "group"]>;
+    readonly missingIds: S.$Array<S.String>;
+}>, YieldableError>;
+
+export declare const checkGroupedPlans: (checker: CheckerResourceService, checkerName: string, plans: readonly RunPlan[]) => Effect.Effect<readonly (readonly [RunPlan, CheckResult])[], CheckerCrash | CheckerContractBroken>;
 
-export declare const CheckStatus: S.Literals<readonly ["passed", "compileError"]>;
+export declare type CheckResult = FailedCheckResult | PassedCheckResult;
 
-export declare type CheckStatus = typeof CheckStatus.Type;
+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;
 
-export declare const classifyExit: (command: ClassifyExitCommand) => ClassifyExitDecision;
+/**
+ * The child process hosting a worker ended when it was not supposed to.
+ */
+export declare class ChildProcessCrashedError extends ChildProcessCrashedError_base {
+    readonly exitClass: 'InternalError';
+}
 
-export declare class ClassifyExitCommand extends ClassifyExitCommand_base {}
+declare const ChildProcessCrashedError_base: Schema.Class<ChildProcessCrashedError, Schema.TaggedStruct<"ChildProcessCrashedError", {
+    readonly pid: Schema.Int;
+    readonly exit: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literals<readonly ["Code"]>;
+        readonly code: Schema.Int;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literals<readonly ["Signal"]>;
+        readonly signal: Schema.String;
+    }>]>;
+    readonly cause: Schema.optional<Schema.String>;
+}>, YieldableError>;
 
-declare const ClassifyExitCommand_base: S.Class<ClassifyExitCommand, S.TaggedStruct<"ClassifyExitCommand", {
-    readonly pending: S.$Array<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
-    readonly signal: S.NullOr<S.Number>;
-    readonly score: S.NullOr<S.Number>;
-    readonly breakingThreshold: S.NullOr<S.Number>;
-}>, {}>;
+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;
+}
 
-export declare class ClassifyExitDecision extends ClassifyExitDecision_base {}
+declare interface ClassBody$1 extends Span$1 {
+    type: "ClassBody";
+    body: Array<ClassElement>;
+    parent?: Node$1;
+}
 
-declare const ClassifyExitDecision_base: S.Class<ClassifyExitDecision, S.TaggedStruct<"ClassifyExitDecision", {
-    readonly highestClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
-    readonly verdictClass: S.NullOr<S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>>;
-}>, {}>;
+declare type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
 
-export declare type CommandRunnerOptions = S.Schema.Type<typeof CommandRunnerOptionsSchema>;
+export declare const classifyWorkerExit: (pid: number, exitCode: number) => ChildProcessCrashedError | OutOfMemoryError;
 
-export declare const CommandRunnerOptionsSchema: S.StructWithRest<S.Struct<{
-    readonly command: S.withDecodingDefaultKey<S.String, never>;
-}>, readonly [S.$Record<S.String, S.Unknown>]>;
+declare type ClassType = "ClassDeclaration" | "ClassExpression";
+
+export declare interface CompiledTests {
+    readonly fileName: string;
+    readonly script: VmScript;
+}
 
 export declare interface CompleteDryRunResult {
     readonly tests: readonly TestResult[];
@@ -94,42 +388,117 @@ export declare interface CompleteDryRunResult {
     readonly status: 'complete';
 }
 
-export declare interface ComposedPlugins {
-    readonly layer: Option.Option<Layer.Layer<MergedPluginServices, never, PluginEnvironment>>;
-    readonly reporterFactories: readonly SelectedReporterFactory[];
-    readonly shadowings: readonly Shadowing[];
+declare interface ComputedMemberExpression extends Span$1 {
+    type: "MemberExpression";
+    object: Expression$1;
+    property: Expression$1;
+    optional: boolean;
+    computed: true;
+    parent?: Node$1;
 }
 
-export declare function composePlugins(contributions: readonly AnyPluginContribution[]): ComposedPlugins;
+declare interface ConditionalExpression$1 extends Span$1 {
+    type: "ConditionalExpression";
+    test: Expression$1;
+    consequent: Expression$1;
+    alternate: Expression$1;
+    parent?: Node$1;
+}
 
-export declare type ContributionOf<K extends PluginKind> = Extract<AnyPluginContribution, {
-    readonly kind: K;
-}>;
+export declare const CONFIG_SYNTAX_HELP: string;
 
-export declare const countMutants: (mutants: readonly MutantResult[]) => Metrics;
+export declare const ConfigDocumentSchema: S.$Record<S.String, S.Unknown>;
 
-export declare interface Coverage {
-    readonly static: CoverageData;
-    readonly perTest: CoveragePerTestId;
+export declare interface ConfigEnv {
+    readonly command: 'run' | 'merge-reports';
+    readonly isDryRun: boolean;
+    readonly mode: OutputMode;
+    readonly isCi: boolean;
 }
 
-export declare type CoverageAnalysis = 'off' | 'all' | 'perTest';
+export declare class ConfigError extends ConfigError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigError_base: S.Class<ConfigError, S.TaggedStruct<"ConfigError", {
+    readonly message: S.String;
+}>, YieldableError>;
+
+export declare class ConfigFileInvalidError extends ConfigFileInvalidError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigFileInvalidError_base: S.Class<ConfigFileInvalidError, S.TaggedStruct<"ConfigFileInvalidError", {
+    readonly file: S.String;
+    readonly cause: S.Unknown;
+}>, YieldableError>;
 
-declare const CoverageAnalysisMode: S.Literals<readonly ["off", "all", "perTest"]>;
+export declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigFileNotFoundError_base: S.Class<ConfigFileNotFoundError, S.TaggedStruct<"ConfigFileNotFoundError", {
+    readonly file: S.String;
+}>, YieldableError>;
+
+export declare class ConfigFileUnreadableError extends ConfigFileUnreadableError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigFileUnreadableError_base: S.Class<ConfigFileUnreadableError, S.TaggedStruct<"ConfigFileUnreadableError", {
+    readonly file: S.String;
+    readonly cause: S.Unknown;
+}>, YieldableError>;
+
+export declare class ConfigFileUnsupportedError extends ConfigFileUnsupportedError_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;
+}>, YieldableError>;
+
+export declare interface ConfigInvocation {
+    readonly command: 'run' | 'merge-reports';
+    readonly mode: OutputMode;
+}
+
+export declare const connectRetry: Schedule.Schedule<Duration_2, unknown, never, never>;
+
+declare interface ContinueStatement$1 extends Span$1 {
+    type: "ContinueStatement";
+    label: LabelIdentifier$1 | null;
+    parent?: Node$1;
+}
 
-declare type CoverageAnalysisMode = typeof CoverageAnalysisMode.Type;
-export { CoverageAnalysisMode }
-export { CoverageAnalysisMode as CoverageAnalysisModeType }
+export declare const countMutants: (mutants: readonly MutantResult[]) => Metrics;
 
-export declare const CoverageAnalysisSchema: S.Literals<readonly ["off", "all", "perTest"]>;
+export declare type CoverageAnalysis = 'off' | 'all' | 'perTest';
 
 export declare type CoverageData = Record<string, number>;
 
-export declare type CoveragePerTestId = Record<string, CoverageData>;
+export declare const createDefaultOptions: Effect.Effect<StrykerOptions>;
+
+export declare function createFileMatcher(pattern: boolean | string, pathService: Path.Path, allowHiddenFiles?: boolean): (fileName: string) => boolean;
+
+declare interface DebuggerStatement extends Span$1 {
+    type: "DebuggerStatement";
+    parent?: Node$1;
+}
+
+export declare const decideExtendsStep: (state: ExtendsStepState, document: PartialStrykerOptions, file: string, pathService: Path.Path) => ExtendsStepDecision;
 
-export declare function declarePlugin(kind: 'Reporter', name: string, make: ReporterFactory): PluginContribution<'Reporter'>;
+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;
+}
 
-export declare function declarePlugin<K extends PluginLayerKind>(kind: K, name: string, layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>): PluginContribution<K>;
+export declare function deepFreeze<T>(target: T): Immutable<T>;
 
 /**
  * Every option optional, all the way down, and mutable: this is the type a
@@ -138,9 +507,23 @@ export declare function declarePlugin<K extends PluginLayerKind>(kind: K, name:
  */
 export declare type DeepOptional<T> = { -readonly [P in keyof T]?: T[P] extends Record<string, unknown> ? DeepOptional<T[P]> | undefined : T[P]; };
 
-export declare type Dependencies = typeof DependenciesSchema.Type;
+export declare const defaultOptions: Effect.Effect<Immutable<StrykerOptions>, never, never>;
 
-export declare const DependenciesSchema: S.$Record<S.String, S.String>;
+export declare function describeErrors(error: S.SchemaError): string[];
+
+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;
+}
 
 export declare class DryRunCompleted extends DryRunCompleted_base {}
 
@@ -187,87 +570,26 @@ declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dry
     }>]>>;
 }>, {}>;
 
+export declare interface DryRunDone extends InstrumentDone {
+    readonly dryRunResult: CompleteDryRunResult;
+    readonly testCoverage: TestCoverage;
+    readonly timeOverhead: Duration.Duration;
+}
+
 export declare interface DryRunOptions extends RunOptions {
     readonly coverageAnalysis: CoverageAnalysis;
     readonly files?: readonly string[];
     readonly testFiles?: readonly string[];
 }
 
-export declare const DryRunOptionsSchema: S.Struct<{
-    readonly timeout: S.Finite;
-    readonly disableBail: S.Boolean;
-    readonly coverageAnalysis: S.Literals<readonly ["off", "all", "perTest"]>;
-    readonly files: S.optionalKey<S.$Array<S.String>>;
-    readonly testFiles: S.optionalKey<S.$Array<S.String>>;
-}>;
-
 export declare type DryRunResult = CompleteDryRunResult | ErrorDryRunResult | TimeoutDryRunResult;
 
-export declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
-    readonly status: S.Literal<"complete">;
-    readonly tests: S.$Array<S.Union<readonly [S.Struct<{
-        readonly id: S.String;
-        readonly name: S.String;
-        readonly timeSpentMs: S.Finite;
-        readonly fileName: S.optionalKey<S.String>;
-        readonly startPosition: S.optionalKey<S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>>;
-        readonly status: S.Literal<"failed">;
-        readonly failureMessage: S.String;
-    }>, S.Struct<{
-        readonly id: S.String;
-        readonly name: S.String;
-        readonly timeSpentMs: S.Finite;
-        readonly fileName: S.optionalKey<S.String>;
-        readonly startPosition: S.optionalKey<S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>>;
-        readonly status: S.Literal<"skipped">;
-    }>, S.Struct<{
-        readonly id: S.String;
-        readonly name: S.String;
-        readonly timeSpentMs: S.Finite;
-        readonly fileName: S.optionalKey<S.String>;
-        readonly startPosition: S.optionalKey<S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>>;
-        readonly status: S.Literal<"success">;
-    }>]>>;
-    readonly mutantCoverage: S.optionalKey<S.Struct<{
-        readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
-        readonly static: S.$Record<S.String, S.Finite>;
-    }>>;
-}>, S.Struct<{
-    readonly status: S.Literal<"timeout">;
-    readonly reason: S.optionalKey<S.String>;
-}>, S.Struct<{
-    readonly status: S.Literal<"error">;
-    readonly errorMessage: S.String;
-}>]>;
-
-export declare const DryRunStatus: S.Literals<readonly ["complete", "error", "timeout"]>;
-
-export declare type DryRunStatus = typeof DryRunStatus.Type;
-
-export declare interface EarlyResultPlan {
-    readonly plan: 'EarlyResult';
-    readonly mutant: Mutant;
-}
-
-export declare interface ErrnoException extends Error {
-    code?: string;
-    errno?: number;
-    path?: string;
-    syscall?: string;
+declare interface EmptyStatement$1 extends Span$1 {
+    type: "EmptyStatement";
+    parent?: Node$1;
 }
 
-export declare const ERROR_CODES: Readonly<{
-    NoSuchFileOrDirectory: 'ENOENT';
-}>;
+export declare type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | WorkerLauncher;
 
 export declare interface ErrorDryRunResult {
     readonly status: 'error';
@@ -279,27 +601,129 @@ export declare interface ErrorMutantRunResult {
     readonly errorMessage: string;
 }
 
-export declare function errorToString(error: unknown): string;
+export declare interface EvaluatorPluginDescriptor {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+}
+
+export declare interface EvaluatorPluginSource {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+    readonly modulePath: string;
+}
 
-export declare class Evaluator extends Evaluator_base {}
+export declare const EXIT_CODE: Record<ExitClass, number>;
 
-declare const Evaluator_base: Context.ServiceClass<Evaluator, "~@systemfsoftware/stryker-js/Evaluator", EvaluatorService>;
+export declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
 
-export declare class EvaluatorFailed extends EvaluatorFailed_base {}
+export declare type ExitClass = typeof ExitClass.Type;
 
-declare const EvaluatorFailed_base: S.Class<EvaluatorFailed, S.TaggedStruct<"EvaluatorFailed", {
-    readonly cause: S.Unknown;
-}>, YieldableError>;
+declare interface ExportAllDeclaration$1 extends Span$1 {
+    type: "ExportAllDeclaration";
+    exported: ModuleExportName | null;
+    source: StringLiteral$1;
+    attributes: Array<ImportAttribute$1>;
+    exportKind?: ImportOrExportKind;
+    parent?: Node$1;
+}
 
-export declare interface EvaluatorService {
-    readonly evaluate: (report: MutationTestResult) => Effect.Effect<ExitClass | null, EvaluatorFailed>;
+declare interface ExportDefaultDeclaration$1 extends Span$1 {
+    type: "ExportDefaultDeclaration";
+    declaration: ExportDefaultDeclarationKind;
+    exportKind?: "value";
+    parent?: Node$1;
 }
 
-export declare const EXIT_CODE: Record<ExitClass, number>;
+declare type ExportDefaultDeclarationKind = Function$1 | Class$1 | TSInterfaceDeclaration$1 | Expression$1;
 
-export declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
+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;
+}
 
-export declare type ExitClass = typeof ExitClass.Type;
+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 | MetaProperty$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 | 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;
+}
+
+export declare const extendsPropertySchema: S.optionalKey<S.String>;
+
+export declare type ExtendsRefusalReason = 'cycle' | 'non-string-extends';
+
+export declare type ExtendsStepDecision = ExtendsStepDone | ExtendsStepRead | ExtendsStepResolve | ExtendsStepRefused;
+
+export declare type ExtendsStepDocument = typeof ExtendsStepDocumentSchema.Type;
+
+export declare const ExtendsStepDocumentSchema: S.Struct<{
+    readonly path: S.String;
+    readonly options: S.$Record<S.String, S.Unknown>;
+}>;
+
+export declare class ExtendsStepDone extends ExtendsStepDone_base {}
+
+declare const ExtendsStepDone_base: S.Class<ExtendsStepDone, S.TaggedStruct<"done", {
+    readonly options: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+
+export declare class ExtendsStepRead extends ExtendsStepRead_base {}
+
+declare const ExtendsStepRead_base: S.Class<ExtendsStepRead, S.TaggedStruct<"read", {
+    readonly path: S.String;
+    readonly state: S.Struct<{
+        readonly visited: S.$Array<S.String>;
+        readonly documents: S.$Array<S.Struct<{
+            readonly path: S.String;
+            readonly options: S.$Record<S.String, S.Unknown>;
+        }>>;
+    }>;
+}>, {}>;
+
+export declare class ExtendsStepRefused extends ExtendsStepRefused_base {}
+
+declare const ExtendsStepRefused_base: S.Class<ExtendsStepRefused, S.TaggedStruct<"refused", {
+    readonly reason: S.Literals<readonly ["cycle", "non-string-extends"]>;
+    readonly file: S.String;
+}>, {}>;
+
+export declare class ExtendsStepResolve extends ExtendsStepResolve_base {}
+
+declare const ExtendsStepResolve_base: S.Class<ExtendsStepResolve, S.TaggedStruct<"resolve", {
+    readonly specifier: S.String;
+    readonly state: S.Struct<{
+        readonly visited: S.$Array<S.String>;
+        readonly documents: S.$Array<S.Struct<{
+            readonly path: S.String;
+            readonly options: S.$Record<S.String, S.Unknown>;
+        }>>;
+    }>;
+}>, {}>;
+
+export declare type ExtendsStepState = typeof ExtendsStepStateSchema.Type;
+
+export declare const ExtendsStepStateSchema: S.Struct<{
+    readonly visited: S.$Array<S.String>;
+    readonly documents: S.$Array<S.Struct<{
+        readonly path: S.String;
+        readonly options: S.$Record<S.String, S.Unknown>;
+    }>>;
+}>;
 
 export declare interface FailedCheckResult {
     readonly reason: string;
@@ -319,36 +743,6 @@ export declare type FileDescriptions = Record<string, FileDescription>;
 
 export declare type FileResult = typeof FileResultSchema.Type;
 
-export declare type FileResultDictionary = typeof FileResultDictionarySchema.Type;
-
-export declare const FileResultDictionarySchema: S.$Record<S.String, S.Struct<{
-    readonly language: S.String;
-    readonly source: S.String;
-    readonly mutants: S.$Array<S.Struct<{
-        readonly id: S.String;
-        readonly mutatorName: S.String;
-        readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-        readonly location: S.Struct<{
-            readonly start: S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>;
-            readonly end: S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>;
-        }>;
-        readonly replacement: S.optional<S.String>;
-        readonly description: S.optional<S.String>;
-        readonly statusReason: S.optional<S.String>;
-        readonly static: S.optional<S.Boolean>;
-        readonly coveredBy: S.optional<S.$Array<S.String>>;
-        readonly killedBy: S.optional<S.$Array<S.String>>;
-        readonly testsCompleted: S.optional<S.Finite>;
-        readonly duration: S.optional<S.Finite>;
-    }>>;
-}>>;
-
 export declare const FileResultSchema: S.Struct<{
     readonly language: S.String;
     readonly source: S.String;
@@ -377,25 +771,174 @@ export declare const FileResultSchema: S.Struct<{
     }>>;
 }>;
 
-export declare type FrameworkInformation = typeof FrameworkInformationSchema.Type;
+export declare function findUnserializables(thing: unknown): UnserializableDescription[] | undefined;
 
-export declare const FrameworkInformationSchema: S.Struct<{
-    readonly name: S.String;
-    readonly version: S.optional<S.String>;
-    readonly branding: S.optional<S.Struct<{
-        readonly homepageUrl: S.String;
-        readonly imageUrl: S.optional<S.String>;
-    }>>;
-    readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
-}>;
+declare interface ForInStatement$1 extends Span$1 {
+    type: "ForInStatement";
+    left: ForStatementLeft;
+    right: Expression$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
 
-export declare class Heartbeat extends Heartbeat_base {}
+export declare const forkCoreSchema: Record<string, unknown>;
 
-declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
-    readonly elapsedMs: S.Finite;
-    readonly completed: S.Finite;
-    readonly total: S.NullOr<S.Finite>;
-}>, {}>;
+export declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
+    readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly buildCommand: S.optional<S.String>;
+    readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
+        readonly plugin: S.String;
+        readonly nodeArgs: S.optional<S.$Array<S.String>>;
+        readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
+    }>>, never>;
+    readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly concurrency: S.optional<S.Union<readonly [S.Finite, S.String]>>;
+    readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+        readonly command: S.withDecodingDefaultKey<S.String, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+    readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
+    readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+        readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+    readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+    readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+    readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly mutator: S.withDecodingDefaultKey<S.Struct<{
+        readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    }>, never>;
+    readonly packageManager: S.optional<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+    readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
+        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+    }>, never>;
+    readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
+        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+    }>, never>;
+    readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
+    readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
+    readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
+    readonly testRunner: S.withDecodingDefaultKey<S.Union<readonly [S.String, S.Struct<{
+        readonly plugin: S.String;
+        readonly nodeArgs: S.optional<S.$Array<S.String>>;
+        readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
+    }>]>, never>;
+    readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
+        readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+    }>, never>;
+    readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
+        readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
+    readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly survivorsPriorReport: S.optionalKey<S.String>;
+    readonly extends: S.optionalKey<S.String>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+
+declare type FormalParameter = {
+    decorators?: Array<Decorator$1>;
+} & BindingPattern$1;
+
+declare interface FormalParameterRest extends Span$1 {
+    type: "RestElement";
+    argument: BindingPattern$1;
+    decorators?: [];
+    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";
+
+export declare function generateRunId(now: DateTime.Utc): string;
+
+declare interface Hashbang extends Span$1 {
+    type: "Hashbang";
+    value: string;
+    parent?: Node$1;
+}
+
+export declare class Heartbeat extends Heartbeat_base {}
+
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+    readonly elapsedMs: S.Finite;
+    readonly completed: S.Finite;
+    readonly total: S.NullOr<S.Finite>;
+}>, {}>;
 
 export declare class HelpRendered extends HelpRendered_base {}
 
@@ -407,35 +950,314 @@ declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
 
 export declare function highestExitClass(pending: Iterable<ExitClass>): ExitClass | null;
 
-export declare class Ignorer extends Ignorer_base {}
+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;
+}
+
+export declare class IdGenerator extends IdGenerator_base {}
+
+declare const IdGenerator_base: Context.ServiceClass<IdGenerator, "@systemfsoftware/stryker-js/Worker/IdGenerator", IdGeneratorShape>;
 
-declare const Ignorer_base: Context.ServiceClass<Ignorer, "~@systemfsoftware/stryker-js/Ignorer", IgnorerService>;
+export declare interface IdGeneratorShape {
+    readonly next: Effect.Effect<number>;
+}
+
+declare interface IfStatement$1 extends Span$1 {
+    type: "IfStatement";
+    test: Expression$1;
+    consequent: Statement$1;
+    alternate: Statement$1 | null;
+    parent?: Node$1;
+}
+
+export declare interface Ignorer {
+    readonly name: string;
+    shouldIgnore(node: Node_2, ancestors: readonly Node_2[]): string | undefined;
+}
+
+export declare type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ReadonlyArray<Immutable<U>> : T extends Map<infer K, infer V> ? ReadonlyMap<Immutable<K>, Immutable<V>> : T extends Set<infer M> ? ReadonlySet<Immutable<M>> : T extends RegExp ? Readonly<RegExp> : { readonly [K in keyof T]: Immutable<T[K]>; };
+
+export declare type ImmutablePrimitive = Primitive | ((...args: never[]) => unknown);
 
-export declare interface IgnorerService {
-    readonly shouldIgnore: (path: NodePath) => Option.Option<string>;
+declare interface ImportAttribute$1 extends Span$1 {
+    type: "ImportAttribute";
+    key: ImportAttributeKey;
+    value: StringLiteral$1;
+    parent?: Node$1;
 }
 
-export declare const INSTRUMENTER_CONSTANTS: Readonly<{
-    NAMESPACE: '__stryker__';
-    MUTATION_COVERAGE_OBJECT: 'mutantCoverage';
-    ACTIVE_MUTANT: 'activeMutant';
-    CURRENT_TEST_ID: 'currentTestId';
-    HIT_COUNT: 'hitCount';
-    HIT_LIMIT: 'hitLimit';
-    ACTIVE_MUTANT_ENV_VARIABLE: '__STRYKER_ACTIVE_MUTANT__';
+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;
+}
+
+export declare const ImportedModuleSchema: S.Struct<{
+    readonly default: S.optional<S.Unknown>;
 }>;
 
-export declare interface InstrumenterContext {
-    activeMutant?: string;
-    currentTestId?: string;
-    mutantCoverage?: MutantCoverage;
-    hitCount?: number;
-    hitLimit?: number;
+declare interface ImportExpression$1 extends Span$1 {
+    type: "ImportExpression";
+    source: Expression$1;
+    options: Expression$1 | null;
+    phase: ImportPhase | null;
+    parent?: Node$1;
+}
+
+export declare function importModule(moduleName: string): Effect.Effect<unknown, StrykerError>;
+
+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;
+}
+
+export declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
+    readonly schemaVersion: 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.Struct<{
+                readonly start: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+                readonly end: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+            }>;
+            readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "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 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.Struct<{
+                readonly start: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+                readonly end: S.optional<S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>>;
+            }>>;
+        }>>;
+    }>>>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+
+export declare const initialExtendsStepState: ExtendsStepState;
+
+export declare interface InstrumentDone extends PrepareDone {
+    readonly mutants: readonly Mutant[];
+    readonly sandbox: SandboxHandle;
+    readonly concurrency: {
+        readonly testRunners: number;
+        readonly checkers: number;
+    };
+}
+
+export declare function isActionableStatus(status: MutantStatus): boolean;
+
+/** Whether a configured runner name selects this runner. */
+export declare const isCommandRunner: (name: TestRunnerConfig) => name is 'command';
+
+export declare function isModuleSpecifier(value: string): boolean;
+
+export declare const isVmRunner: (name: TestRunnerConfig) => name is 'vm';
+
+export declare function isWarningEnabled(warningType: KnownKeys<WarningOptions>, warningOptions: WarningOptions | boolean): boolean;
+
+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;
 }
 
-export declare function isErrnoException(error: unknown): error is ErrnoException;
+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;
+}
 
-export declare const isMutant: (value: unknown) => value is Mutant;
+declare interface JSXText$1 extends Span$1 {
+    type: "JSXText";
+    value: string;
+    raw: string | null;
+    parent?: Node$1;
+}
 
 export declare interface KilledMutantRunResult {
     readonly status: 'killed';
@@ -444,12 +1266,34 @@ export declare interface KilledMutantRunResult {
     readonly nrOfTests: number;
 }
 
-/**
- * Known keys filters out the index signature from the keys of a type
- * @see https://stackoverflow.com/questions/51465182/typescript-remove-index-signature-using-mapped-types
- */
 export declare type KnownKeys<T> = keyof { [P in keyof T as string extends P ? never : number extends P ? never : P]: T[P]; };
 
+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;
+}
+
+export declare const loadConfigCell: typeof readConfig;
+
+export declare interface LoadedPlugins {
+    readonly schemaContributions: readonly Record<string, unknown>[];
+    readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
+    readonly pluginModulePaths: readonly string[];
+    readonly pluginSources: readonly PluginSource[];
+    readonly ignorers: readonly Ignorer[];
+}
+
 export declare type Location = typeof LocationSchema.Type;
 
 export declare const LocationSchema: S.Struct<{
@@ -463,14 +1307,63 @@ export declare const LocationSchema: S.Struct<{
     }>;
 }>;
 
-declare const LogLevel: S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>;
+declare interface LogicalExpression$1 extends Span$1 {
+    type: "LogicalExpression";
+    left: Expression$1;
+    operator: LogicalOperator;
+    right: Expression$1;
+    parent?: Node$1;
+}
+
+declare type LogicalOperator = "||" | "&&" | "??";
+
+export declare const makeRunLayer: (env: RunEnvironmentShape, events?: Queue.Queue<RunEvent, Cause.Done>) => Layer.Layer<RunStageServices, never, EnginePorts>;
+
+export declare const makeWorkerClient: <Rpcs extends Rpc.Any>(params: WorkerClientParams<Rpcs>) => Effect.Effect<RpcClient.RpcClient<Rpcs, RpcClientError>, WorkerBootError, Scope.Scope | WorkerLauncher>;
+
+export declare function matchesFile(pattern: boolean | string, fileName: string, pathService: Path.Path, allowHiddenFiles?: boolean): boolean;
+
+declare type MemberExpression$1 = ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression;
+
+export declare class MergeCommand extends MergeCommand_base {}
+
+declare const MergeCommand_base: S.Class<MergeCommand, S.TaggedStruct<"MergeCommand", {
+    readonly base: S.$Record<S.String, S.Unknown>;
+    readonly overrides: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+
+export declare function mergeConfigs(parent: PartialStrykerOptions, child: PartialStrykerOptions): PartialStrykerOptions;
+
+export declare class MergeResult extends MergeResult_base {}
+
+declare const MergeResult_base: S.Class<MergeResult, S.TaggedStruct<"MergeResult", {
+    readonly merged: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+
+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;
+}
 
-/** The generated module exported these as TypeScript types; consumers still name them that way. */
-declare type LogLevel = typeof LogLevel.Type;
-export { LogLevel }
-export { LogLevel as LogLevelType }
+declare type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
 
-export declare type MergedPluginServices = Checker & Ignorer & TestRunner;
+declare type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
 
 export declare type Metrics = typeof MetricsSchema.Type;
 
@@ -480,29 +1373,6 @@ export declare interface MetricsResult {
     readonly childResults: readonly MetricsResult[];
 }
 
-export declare const MetricsResultSchema: S.Struct<{
-    readonly name: S.String;
-    readonly metrics: S.Struct<{
-        readonly pending: S.Finite;
-        readonly killed: S.Finite;
-        readonly timeout: S.Finite;
-        readonly survived: S.Finite;
-        readonly noCoverage: S.Finite;
-        readonly runtimeErrors: S.Finite;
-        readonly compileErrors: S.Finite;
-        readonly ignored: S.Finite;
-        readonly totalDetected: S.Finite;
-        readonly totalUndetected: S.Finite;
-        readonly totalInvalid: S.Finite;
-        readonly totalValid: S.Finite;
-        readonly totalMutants: S.Finite;
-        readonly totalCovered: S.Finite;
-        readonly mutationScore: S.Finite;
-        readonly mutationScoreBasedOnCoveredCode: S.Finite;
-    }>;
-    readonly childResults: S.$Array<S.suspend<S.Codec<MetricsResult, MetricsResult, never, never>>>;
-}>;
-
 export declare const MetricsSchema: S.Struct<{
     readonly pending: S.Finite;
     readonly killed: S.Finite;
@@ -522,39 +1392,13 @@ export declare const MetricsSchema: S.Struct<{
     readonly mutationScoreBasedOnCoveredCode: S.Finite;
 }>;
 
-export declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+export declare type ModeSignal = 'flag' | 'env' | 'tty' | 'agent' | 'tool';
 
-export declare type ModeSignal = typeof ModeSignal.Type;
+declare type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
 
-/**
- * Port over the host module loader, shaped as the subset of `node:module`
- * feature code may use: `createRequire` and `isBuiltin`. Resolving a
- * specifier against a project directory, importing a plugin, and asking
- * whether a name is a builtin all go through this one tag; no feature module
- * touches the host module API. The Node implementation ships in the
- * composition-root package (`@systemfsoftware/stryker-js-cli`); tests that do
- * not need real plugin resolution substitute a layer returning fixed paths.
- *
- * @since 2.0.0
- */
-export declare class Module extends Module_base {}
+declare type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
 
-declare const Module_base: Context.ServiceClass<Module, "@systemfsoftware/stryker-js/Module", {
-    readonly createRequire: (filename: string | URL) => ModuleRequire;
-    readonly isBuiltin: (moduleName: string) => boolean;
-}>;
-
-/**
- * The subset of `node:module`'s `createRequire` result this port certifies: a
- * require function bound to one path, plus its resolution. Calling it loads
- * the specifier exactly as a module evaluated next to that path would.
- */
-export declare interface ModuleRequire {
-    (request: string): unknown;
-    resolve(request: string, options?: {
-        readonly paths?: readonly string[];
-    }): string;
-}
+declare type ModuleKind = "script" | "module" | "commonjs";
 
 export declare class Mutant extends Mutant_base {}
 
@@ -581,7 +1425,7 @@ declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
     readonly description: S.optional<S.String>;
 }>, {}>;
 
-export declare type MutantActivation = 'runtime' | 'static';
+export declare type MutantActivation = typeof MutantActivationSchema.Type;
 
 export declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
 
@@ -590,11 +1434,6 @@ export declare interface MutantCoverage {
     readonly static: Record<string, number>;
 }
 
-export declare const MutantCoverageSchema: S.Struct<{
-    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
-    readonly static: S.$Record<S.String, S.Finite>;
-}>;
-
 export declare type MutantResult = typeof MutantResultSchema.Type;
 
 export declare const MutantResultSchema: S.Struct<{
@@ -630,50 +1469,12 @@ export declare interface MutantRunOptions extends RunOptions {
     readonly reloadEnvironment: boolean;
 }
 
-export declare const MutantRunOptionsSchema: S.Struct<{
-    readonly timeout: S.Finite;
-    readonly disableBail: S.Boolean;
-    readonly activeMutant: typeof Mutant;
-    readonly sandboxFileName: S.String;
-    readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
-    readonly reloadEnvironment: S.Boolean;
-    readonly testFilter: S.optionalKey<S.$Array<S.String>>;
-    readonly hitLimit: S.optionalKey<S.Finite>;
-}>;
-
-export declare type MutantRunPlan = RunPlan;
-
 export declare type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
 
-export declare const MutantRunResultSchema: S.Union<readonly [S.Struct<{
-    readonly status: S.Literal<"killed">;
-    readonly killedBy: S.$Array<S.String>;
-    readonly failureMessage: S.String;
-    readonly nrOfTests: S.Finite;
-}>, S.Struct<{
-    readonly status: S.Literal<"survived">;
-    readonly nrOfTests: S.Finite;
-}>, S.Struct<{
-    readonly status: S.Literal<"timeout">;
-    readonly reason: S.optionalKey<S.String>;
-}>, S.Struct<{
-    readonly status: S.Literal<"error">;
-    readonly errorMessage: S.String;
-}>]>;
-
-export declare const MutantRunStatus: S.Literals<readonly ["killed", "survived", "timeout", "error"]>;
-
-export declare type MutantRunStatus = typeof MutantRunStatus.Type;
-
 export declare type MutantStatus = typeof MutantStatusSchema.Type;
 
 export declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
 
-export declare type MutantTestCoverage = Mutant & {
-    readonly coveredBy: ReadonlyArray<string> | undefined;
-    readonly static: boolean | undefined;
-};
-
 export declare class MutantTested extends MutantTested_base {}
 
 declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
@@ -703,25 +1504,12 @@ export declare interface MutationRange {
     readonly end: Position;
 }
 
-export declare interface MutationRunIo {
-    readonly read: (command: RunCommand) => Effect.Effect<unknown, S.SchemaError, RunIdentity>;
-    readonly write: (output: RunOutput) => Effect.Effect<void, S.SchemaError, RunIdentity>;
-}
-
-export declare class MutationRunPlan extends MutationRunPlan_base {}
-
-declare const MutationRunPlan_base: S.Class<MutationRunPlan, S.TaggedStruct<"MutationRunPlan", {
-    readonly mutatePatterns: S.$Array<S.String>;
-    readonly mutatorNames: S.$Array<S.String>;
-}>, {}>;
-
-export declare type MutationScoreThresholds = typeof MutationScoreThresholdsSchema.Type;
+export declare const mutationTestCell: Cell.Cell<PrepareExecutorArgs, MutationTestDone, StageError, StageServices>;
 
-export declare const MutationScoreThresholdsSchema: S.Struct<{
-    readonly high: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly low: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
-}>;
+export declare interface MutationTestDone {
+    readonly results: readonly RunMutantResult[];
+    readonly verdict: ExitClass | null;
+}
 
 export declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
 
@@ -824,739 +1612,1461 @@ declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.T
     }>;
 }>, {}>;
 
-export declare type MutationTestResult = typeof MutationTestResultSchema.Type;
+export declare type MutationTestResult = typeof MutationTestResultSchema.Type;
+
+export declare const MutationTestResultSchema: S.Struct<{
+    readonly schemaVersion: S.String;
+    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 status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+            readonly location: S.Struct<{
+                readonly start: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+                readonly end: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+            }>;
+            readonly replacement: S.optional<S.String>;
+            readonly description: S.optional<S.String>;
+            readonly statusReason: S.optional<S.String>;
+            readonly static: S.optional<S.Boolean>;
+            readonly coveredBy: S.optional<S.$Array<S.String>>;
+            readonly killedBy: S.optional<S.$Array<S.String>>;
+            readonly testsCompleted: S.optional<S.Finite>;
+            readonly duration: S.optional<S.Finite>;
+        }>>;
+    }>>;
+    readonly thresholds: S.Struct<{
+        readonly high: S.Finite;
+        readonly low: S.Finite;
+    }>;
+    readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
+    readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+        readonly source: S.optional<S.String>;
+        readonly tests: S.$Array<S.Struct<{
+            readonly id: S.String;
+            readonly name: S.String;
+            readonly location: S.optional<S.Struct<{
+                readonly start: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+                readonly end: S.optional<S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>>;
+            }>>;
+        }>>;
+    }>>>;
+    readonly projectRoot: S.optional<S.String>;
+    readonly framework: S.optional<S.Struct<{
+        readonly name: S.String;
+        readonly version: S.optional<S.String>;
+        readonly branding: S.optional<S.Struct<{
+            readonly homepageUrl: S.String;
+            readonly imageUrl: S.optional<S.String>;
+        }>>;
+        readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
+    }>>;
+}>;
+
+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;
+
+export declare const optionsPath: (...path: string[]) => string;
+
+export declare class OutOfMemoryError extends OutOfMemoryError_base {
+    readonly exitClass: 'RuntimeError';
+}
+
+declare const OutOfMemoryError_base: Schema.Class<OutOfMemoryError, Schema.TaggedStruct<"OutOfMemoryError", {
+    readonly pid: Schema.Int;
+    readonly exitCode: Schema.Int;
+}>, YieldableError>;
+
+/**
+ * Mode type vocabulary shared with the CLI package. Runtime resolution
+ * (`resolveMode`) and gate functions (`isProgressEnabled`, `isColorEnabled`)
+ * live in the CLI; the `ResolvedMode` fields (`mode`, `signal`,
+ * `stdoutIsTTY`) ride along in `VerdictEnvelope` (`verdict-envelope.ts`),
+ * so the types stay where the data does.
+ */
+export declare type OutputMode = 'human' | 'machine';
+
+declare type ParamPattern$1 = FormalParameter | TSParameterProperty | FormalParameterRest;
+
+declare interface ParenthesizedExpression extends Span$1 {
+    type: "ParenthesizedExpression";
+    expression: Expression$1;
+    parent?: Node$1;
+}
+
+/**
+ * The deep-partial input type: when configuring Stryker, every option is
+ * optional, including deep properties like `dashboard.project`.
+ */
+export declare type PartialStrykerOptions = DeepOptional<StrykerOptions>;
+
+export declare interface PassedCheckResult {
+    readonly status: 'passed';
+}
+
+export declare class PhaseEntered extends PhaseEntered_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;
+}>, {}>;
+
+export declare class PlanKnown extends PlanKnown_base {}
+
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+    readonly total: S.Finite;
+}>, {}>;
+
+export declare type PluginDescriptor<K extends PluginKind = PluginKind> = PluginDescriptorOf<K>;
+
+export declare type PluginDescriptorOf<K extends PluginKind> = Extract<AnyPluginDescriptor, {
+    readonly kind: K;
+}>;
+
+export declare type PluginKind = WorkerPluginKind | 'Evaluator';
+
+export declare type PluginSource = AnyWorkerPluginSource | EvaluatorPluginSource;
+
+/**
+ * A test runner in a child process, whose calls can fail the way a child process
+ * fails.
+ *
+ * Wider than `TestRunnerService` on purpose. That port's error channel is
+ * `TestRunnerFailed`, which is right for a runner living in this process — but
+ * folding a crash into it erases the tag a pool retires a worker on, so
+ * `Pool.invalidate` could never fire and a dead worker would be handed out again.
+ * A `WorkerMethodError` is the runner genuinely failing and does become a
+ * `TestRunnerFailed`; a crash or an OOM is the worker dying, and stays itself.
+ */
+export declare interface PooledTestRunner {
+    readonly capabilities: Effect.Effect<TestRunnerCapabilities, PooledTestRunnerError>;
+    readonly init: Effect.Effect<void, PooledTestRunnerError>;
+    readonly dryRun: (options: DryRunOptions) => Effect.Effect<DryRunResult, PooledTestRunnerError>;
+    readonly mutantRun: (options: MutantRunOptions) => Effect.Effect<MutantRunResult, PooledTestRunnerError>;
+}
+
+/** How a call on a pooled worker can fail. */
+export declare type PooledTestRunnerError = TestRunnerFailed | ChildProcessCrashedError | OutOfMemoryError;
+
+export declare type Position = typeof PositionSchema.Type;
+
+export declare const PositionSchema: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+}>;
+
+export declare interface PrepareDone {
+    readonly project: Project;
+    readonly loadedPlugins: LoadedPlugins;
+    readonly ignorers: readonly Ignorer[];
+    readonly options: StrykerOptions;
+    readonly temporaryDirectoryPath: string;
+    readonly reporterStage: ReporterStage;
+}
+
+export declare interface PrepareExecutorArgs {
+    cliOptions: PartialStrykerOptions;
+    targetMutatePatterns: string[] | undefined;
+}
+
+export declare type Primitive = boolean | number | string | null | undefined;
+
+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;
+}
+
+export declare interface Project {
+    readonly fileDescriptions: FileDescriptions;
+    readonly incrementalReport: MutationTestResult | undefined;
+    readonly testFiles: readonly string[];
+    readonly files: MutableHashMap.MutableHashMap<string, ProjectFile>;
+    readonly filesToMutate: MutableHashMap.MutableHashMap<string, ProjectFile>;
+}
+
+export declare interface ProjectFile extends FileDescription {
+    readonly name: string;
+    readonly mutate: MutateDescription;
+    readonly content: string | undefined;
+    readonly originalContent: string | undefined;
+}
+
+declare class PropagatedTrace extends PropagatedTrace_base {}
+
+declare const PropagatedTrace_base: Context.ServiceClass<PropagatedTrace, "@systemfsoftware/stryker-js-plugin-interface/TraceContextRpc/PropagatedTrace", Option.Option<TraceContextParts>>;
+
+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";
+
+export declare function readConfig(cliOptions: PartialStrykerOptions, invocation: ConfigInvocation): Effect.Effect<StrykerOptions, ConfigFileNotFoundError | ConfigFileUnreadableError | ConfigFileInvalidError | ConfigFileUnsupportedError, FileSystem.FileSystem | Path.Path>;
+
+export declare class ReadConfigCommand extends ReadConfigCommand_base {}
+
+declare const ReadConfigCommand_base: S.Class<ReadConfigCommand, S.TaggedStruct<"ReadConfigCommand", {
+    readonly cliOptions: S.$Record<S.String, S.Unknown>;
+    readonly basePath: S.String;
+}>, {}>;
+
+declare interface RegExpLiteral$1 extends Span$1 {
+    type: "Literal";
+    value: RegExp | null;
+    raw: string | null;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    parent?: Node$1;
+}
+
+export declare const REPORTER_EVENT_BATCH_BOUND = 128;
+
+export declare const ReporterAck: S.Void;
+
+export declare const ReporterDrained: S.Void;
+
+export declare type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
+
+export declare const ReporterEventBatch: S.$Array<S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>>;
+
+export declare type ReporterEventBatch = typeof ReporterEventBatch.Type;
+
+export declare type ReporterFactory = (options: StrykerOptions, init: ReporterInit) => (events: AsyncIterable<ReporterEvent>) => Effect.Effect<void, ReporterFailed>;
+
+export declare class ReporterFailed extends ReporterFailed_base {}
+
+declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {
+    readonly cause: S.String;
+    readonly event: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+    readonly reporterName: S.String;
+}>, YieldableError>;
+
+export declare interface ReporterInit {
+    readonly traceparent?: string | undefined;
+    readonly tracestate?: string | undefined;
+}
+
+export declare const ReporterInitOptions: S.Struct<{
+    readonly traceparent: S.optionalKey<S.String>;
+    readonly tracestate: S.optionalKey<S.String>;
+}>;
+
+export declare type ReporterInitOptions = typeof ReporterInitOptions.Type;
+
+export declare const ReporterRpcs: RpcGroup.RpcGroup<TracedRpc<'init', typeof ReporterInitOptions, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'onEventBatch', typeof ReporterEventBatch, typeof ReporterAck, typeof ReporterFailed> | TracedRpc<'flush', Schema.Void, typeof ReporterDrained, typeof ReporterFailed>>;
+
+/**
+ * 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`.
+ */
+export declare interface ReporterStage {
+    readonly [ReporterStageTypeId]: typeof ReporterStageTypeId;
+}
+
+declare const ReporterStageTypeId: unique symbol;
+
+export declare type ReporterWorkerClient = RpcClient.RpcClient<RpcGroup.Rpcs<typeof ReporterRpcs>, RpcClientError>;
+
+export declare const reporterWorkerFactory: (client: ReporterWorkerClient) => ReporterFactory;
+
+export declare interface ResolvedMode {
+    readonly mode: OutputMode;
+    readonly signal: ModeSignal;
+    readonly stdoutIsTTY: boolean;
+}
+
+export declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
+
+export declare function resolveExtends(configFile: string, document: PartialStrykerOptions, configEnv: ConfigEnv): Effect.Effect<PartialStrykerOptions, ConfigFileUnreadableError | ConfigFileInvalidError | ConfigFileUnsupportedError, Path.Path>;
+
+declare interface ReturnStatement$1 extends Span$1 {
+    type: "ReturnStatement";
+    argument: Expression$1 | null;
+    parent?: Node$1;
+}
+
+export declare const RUN_EVENTS_QUEUE_BOUND = 256;
+
+export declare class RunEnvironment extends RunEnvironment_base {}
+
+declare const RunEnvironment_base: Context.ServiceClass<RunEnvironment, "@systemfsoftware/stryker-js/run/RunEnvironment", RunEnvironmentShape>;
+
+export declare interface RunEnvironmentShape {
+    readonly runId: string;
+    readonly resolvedMode: ResolvedMode;
+    readonly runStartedAt: number;
+    readonly basePath: string;
+    readonly builtinReporters: Readonly<Record<string, ReporterFactory>>;
+    readonly allowConsoleColors: boolean;
+}
+
+export declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
+
+export declare type RunEvent = typeof RunEvent.Type;
+
+export declare class RunEvents extends RunEvents_base {}
+
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | PhaseEntered | PlanKnown | RunFailed | RunMutantTested | RunStarted | VerdictReached, Cause.Done<void>>>;
+
+export declare class RunFailed extends RunFailed_base {}
+
+declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
+    readonly schemaVersion: S.String;
+    readonly code: S.Finite;
+    readonly error: S.String;
+    readonly remediation: S.String;
+}>, {}>;
+
+export declare class RunIdentity extends RunIdentity_base {}
+
+declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "@systemfsoftware/stryker-js/RunEvents/RunIdentity", RunIdentityShape>;
+
+export declare interface RunIdentityShape {
+    readonly runId: string;
+    readonly basePath: string;
+}
+
+export declare type RunMutantResult = Mutant & {
+    readonly status: MutantStatus;
+    readonly statusReason?: string | undefined;
+    readonly testsCompleted?: number | undefined;
+    readonly killedBy?: readonly string[] | undefined;
+    readonly coveredBy?: readonly string[] | undefined;
+    readonly static?: boolean | undefined;
+};
+
+export declare class RunMutantTested extends RunMutantTested_base {}
+
+declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
+    readonly id: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    readonly file: S.String;
+    readonly location: S.Struct<{
+        readonly start: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+        }>;
+        readonly end: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+        }>;
+    }>;
+    readonly mutator: S.String;
+    readonly replacement: S.NullOr<S.String>;
+    readonly completed: S.Finite;
+    readonly total: S.Finite;
+}>, {}>;
+
+export declare interface RunOptions {
+    readonly timeout: number;
+    readonly disableBail: boolean;
+}
+
+export declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+
+export declare type RunPhase = typeof RunPhase.Type;
+
+export declare interface RunPlan {
+    readonly plan: 'Run';
+    readonly mutant: Mutant;
+    readonly runOptions: MutantRunOptions;
+    readonly netTime: number;
+}
+
+export declare type RunStageServices = RunEnvironment | RunEvents | IdGenerator | Scope.Scope;
+
+export declare class RunStarted extends RunStarted_base {}
+
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+    readonly schemaVersion: S.String;
+    readonly runId: S.String;
+    readonly mode: S.Literals<readonly ["human", "machine"]>;
+    readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>, {}>;
+
+export declare type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+
+export declare interface SandboxHandle {
+    readonly workingDirectory: string;
+    readonly sandboxFileFor: (fileName: string) => string;
+    readonly originalFileFor: (sandboxFileName: string) => string;
+}
+
+declare interface SequenceExpression$1 extends Span$1 {
+    type: "SequenceExpression";
+    expressions: Array<Expression$1>;
+    parent?: Node$1;
+}
+
+export declare const shouldKeepTempDir: (exit: Exit.Exit<unknown, unknown>, cleanTempDir: 'always' | boolean) => boolean;
+
+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]; } & {};
+
+export declare interface SkippedTestResult extends BaseTestResult {
+    readonly status: 'skipped';
+}
+
+declare interface Span$1 {
+    start: number;
+    end: number;
+    range?: [number, number];
+}
+
+export declare interface SpawnedSocketWorker {
+    readonly pid: number;
+    readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+    readonly exited: Effect.Effect<never, WorkerExit>;
+}
+
+export declare const spawnReporterWorker: (params: SpawnReporterWorkerParams) => Effect.Effect<ReporterWorkerClient, WorkerBootError, Scope.Scope | WorkerLauncher>;
+
+export declare interface SpawnReporterWorkerParams {
+    readonly entrypoint: string;
+    readonly projectBasePath: string;
+    readonly execArgv: readonly string[];
+    readonly options: StrykerOptions;
+    readonly tempDirPrefix: string;
+}
+
+declare interface SpreadElement$1 extends Span$1 {
+    type: "SpreadElement";
+    argument: Expression$1;
+    parent?: Node$1;
+}
+
+export declare class StageError extends StageError_base {
+    readonly [TypeId]: "~stryker/mutation-run/StageError";
+    get exitClass(): ExitClass;
+    get message(): string;
+}
+
+declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError", {
+    readonly stage: S.Literals<readonly ["prepare", "instrument", "dryRun", "dryRunNoTests", "mutationTest"]>;
+    readonly reason: S.String;
+    readonly cause: S.optional<S.Defect>;
+    readonly command: S.optional<S.String>;
+}>, YieldableError>;
+
+export declare type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | IdGenerator | Path.Path | RunEnvironment | RunEvents | Scope.Scope | Stdio.Stdio | WorkerLauncher;
+
+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;
+}
+
+export declare const strykerCell: (options: PartialStrykerOptions, targetMutatePatterns?: readonly string[]) => Effect.Effect<MutationTestDone, StageError | PlatformError, FileSystem.FileSystem | Path.Path | Stdio.Stdio>;
+
+export declare class StrykerError extends StrykerError_base {}
+
+declare const StrykerError_base: Schema.Class<StrykerError, Schema.TaggedStruct<"StrykerError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, YieldableError>;
+
+/** The decoded type: every defaulted option is present. */
+export declare type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;
+
+export declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
+    readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly buildCommand: S.optional<S.String>;
+    readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
+        readonly plugin: S.String;
+        readonly nodeArgs: S.optional<S.$Array<S.String>>;
+        readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
+    }>>, never>;
+    readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly concurrency: S.optional<S.Union<readonly [S.Finite, S.String]>>;
+    readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+        readonly command: S.withDecodingDefaultKey<S.String, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+    readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
+    readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+        readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+    readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+    readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+    readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly mutator: S.withDecodingDefaultKey<S.Struct<{
+        readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    }>, never>;
+    readonly packageManager: S.optional<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+    readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
+        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+    }>, never>;
+    readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
+        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+    }>, never>;
+    readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
+    readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
+    readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
+    readonly testRunner: S.withDecodingDefaultKey<S.Union<readonly [S.String, S.Struct<{
+        readonly plugin: S.String;
+        readonly nodeArgs: S.optional<S.$Array<S.String>>;
+        readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
+    }>]>, never>;
+    readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
+        readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+    }>, never>;
+    readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
+        readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
+    readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+
+export declare type StrykerRun = (options: PartialStrykerOptions, targetMutatePatterns?: string[]) => Effect.Effect<MutationTestDone, StageError, never>;
+
+export declare const strykerVersion: string;
+
+export declare interface SuccessTestResult extends BaseTestResult {
+    readonly status: 'success';
+}
+
+declare interface Super$1 extends Span$1 {
+    type: "Super";
+    parent?: Node$1;
+}
 
-export declare const MutationTestResultSchema: S.Struct<{
-    readonly schemaVersion: S.String;
-    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 status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-            readonly location: S.Struct<{
-                readonly start: S.Struct<{
-                    readonly line: S.Finite;
-                    readonly column: S.Finite;
-                }>;
-                readonly end: S.Struct<{
-                    readonly line: S.Finite;
-                    readonly column: S.Finite;
-                }>;
-            }>;
-            readonly replacement: S.optional<S.String>;
-            readonly description: S.optional<S.String>;
-            readonly statusReason: S.optional<S.String>;
-            readonly static: S.optional<S.Boolean>;
-            readonly coveredBy: S.optional<S.$Array<S.String>>;
-            readonly killedBy: S.optional<S.$Array<S.String>>;
-            readonly testsCompleted: S.optional<S.Finite>;
-            readonly duration: S.optional<S.Finite>;
-        }>>;
-    }>>;
-    readonly thresholds: S.Struct<{
-        readonly high: S.Finite;
-        readonly low: S.Finite;
-    }>;
-    readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
-    readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
-        readonly source: S.optional<S.String>;
-        readonly tests: S.$Array<S.Struct<{
-            readonly id: S.String;
-            readonly name: S.String;
-            readonly location: S.optional<S.Struct<{
-                readonly start: S.Struct<{
-                    readonly line: S.Finite;
-                    readonly column: S.Finite;
-                }>;
-                readonly end: S.optional<S.Struct<{
-                    readonly line: S.Finite;
-                    readonly column: S.Finite;
-                }>>;
-            }>>;
-        }>>;
-    }>>>;
-    readonly projectRoot: S.optional<S.String>;
-    readonly framework: S.optional<S.Struct<{
-        readonly name: S.String;
-        readonly version: S.optional<S.String>;
-        readonly branding: S.optional<S.Struct<{
-            readonly homepageUrl: S.String;
-            readonly imageUrl: S.optional<S.String>;
-        }>>;
-        readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
-    }>>;
-}>;
+export declare const SUPPORTED_CONFIG_FILE_NAMES: readonly string[];
 
-export declare interface NodePath {
-    readonly node: unknown;
-    readonly parentPath?: NodePath | null;
-    isObjectExpression(): boolean;
-    isCallExpression(): boolean;
-    isClassProperty(): boolean;
-    isClassPrivateProperty(): boolean;
-    isClassAccessorProperty(): boolean;
+export declare interface SurvivedMutantRunResult {
+    readonly status: 'survived';
+    readonly nrOfTests: number;
 }
 
-export declare function normalizeFileName(fileName: string): string;
+export declare const survivorsPriorReport: S.optionalKey<S.String>;
 
-export declare type OnlyObject<T> = Exclude<T, Primitive>;
+declare interface SwitchCase$1 extends Span$1 {
+    type: "SwitchCase";
+    test: Expression$1 | null;
+    consequent: Array<Statement$1>;
+    parent?: Node$1;
+}
 
-export declare type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+declare interface SwitchStatement$1 extends Span$1 {
+    type: "SwitchStatement";
+    discriminant: Expression$1;
+    cases: Array<SwitchCase$1>;
+    parent?: Node$1;
+}
 
-export declare const OpenEndLocationSchema: S.Struct<{
-    readonly start: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>;
-    readonly end: S.optional<S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>>;
-}>;
+declare interface TaggedTemplateExpression$1 extends Span$1 {
+    type: "TaggedTemplateExpression";
+    tag: Expression$1;
+    typeArguments?: TSTypeParameterInstantiation$1 | null;
+    quasi: TemplateLiteral$1;
+    parent?: Node$1;
+}
 
-export declare const OutputMode: S.Literals<readonly ["human", "machine"]>;
+declare interface TemplateElement$1 extends Span$1 {
+    type: "TemplateElement";
+    value: TemplateElementValue;
+    tail: boolean;
+    parent?: Node$1;
+}
 
-export declare type OutputMode = typeof OutputMode.Type;
+declare interface TemplateElementValue {
+    raw: string;
+    cooked: string | null;
+}
 
-declare const PackageManager: S.Literals<readonly ["npm", "yarn", "pnpm"]>;
+declare interface TemplateLiteral$1 extends Span$1 {
+    type: "TemplateLiteral";
+    quasis: Array<TemplateElement$1>;
+    expressions: Array<Expression$1>;
+    parent?: Node$1;
+}
 
-declare type PackageManager = typeof PackageManager.Type;
-export { PackageManager }
-export { PackageManager as PackageManagerType }
+export declare interface TestCoverage {
+    readonly testsByMutantId: MutableHashMap.MutableHashMap<string, MutableHashSet.MutableHashSet<TestResult>>;
+    readonly testsById: MutableHashMap.MutableHashMap<string, TestResult>;
+    readonly staticCoverage: CoverageData | undefined;
+    readonly hitsByMutantId: MutableHashMap.MutableHashMap<string, number>;
+}
 
-/**
- * The deep-partial input type: when configuring Stryker, every option is
- * optional, including deep properties like `dashboard.project`.
- */
-export declare type PartialStrykerOptions = DeepOptional<StrykerOptions>;
+export declare type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
 
-export declare interface PassedCheckResult {
-    readonly status: 'passed';
+/** What building a runner for this run needs. */
+export declare interface TestRunnerBuildContext {
+    readonly options: StrykerOptions;
+    readonly fileDescriptions: FileDescriptions;
+    readonly sandboxWorkingDirectory: string;
+    readonly idGenerator: IdGeneratorShape;
+    /**
+     * Retire this runner's worker. Supplied by whoever owns the worker's
+     * lifetime — the pool — so a combinator never restarts a process the pool
+     * still believes it owns.
+     */
+    readonly retire: Effect.Effect<void>;
+    readonly testFiles: readonly string[];
 }
 
-export declare class PhaseEntered extends PhaseEntered_base {}
+export declare interface TestRunnerCapabilities {
+    readonly reloadEnvironment: boolean;
+}
 
-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;
-}>, {}>;
+export declare type TestRunnerConfig = typeof TestRunnerConfigSchema.Type;
 
-export declare class PlanKnown extends PlanKnown_base {}
+export declare const TestRunnerConfigSchema: S.Union<readonly [S.String, S.Struct<{
+    readonly plugin: S.String;
+    readonly nodeArgs: S.optional<S.$Array<S.String>>;
+    readonly options: S.optional<S.$Record<S.String, S.Unknown>>;
+}>]>;
 
-declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
-    readonly total: S.Finite;
-}>, {}>;
+export declare class TestRunnerFailed extends TestRunnerFailed_base {}
+
+declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"TestRunnerFailed", {
+    readonly cause: S.String;
+    readonly phase: S.Literals<readonly ["capabilities", "dispose", "dryRun", "init", "mutantRun"]>;
+    readonly runnerName: S.String;
+}>, YieldableError>;
 
-export declare const planMutationRun: (command: PlanMutationRunCommand) => MutationRunPlan;
+declare interface ThisExpression$1 extends Span$1 {
+    type: "ThisExpression";
+    parent?: Node$1;
+}
 
-export declare class PlanMutationRunCommand extends PlanMutationRunCommand_base {}
+declare interface ThrowStatement$1 extends Span$1 {
+    type: "ThrowStatement";
+    argument: Expression$1;
+    parent?: Node$1;
+}
 
-declare const PlanMutationRunCommand_base: S.Class<PlanMutationRunCommand, S.TaggedStruct<"PlanMutationRunCommand", {
-    readonly configMutatePatterns: S.$Array<S.String>;
-    readonly configMutatorNames: S.$Array<S.String>;
-    readonly targetMutatePatterns: S.$Array<S.String>;
-    readonly availableMutators: S.$Array<S.String>;
-}>, {}>;
+export declare interface TimeoutDryRunResult {
+    readonly status: 'timeout';
+    readonly reason?: string;
+}
+
+export declare interface TimeoutMutantRunResult {
+    readonly status: 'timeout';
+    readonly reason?: string;
+}
+
+export declare const toRelativeNormalizedFileName: (fileName: string | undefined, basePath: string) => string;
+
+export declare class TraceContextMiddleware extends TraceContextMiddleware_base {}
 
-export declare type PluginContribution<K extends PluginKind = PluginKind> = K extends 'Reporter' ? PluginReporterContribution : PluginLayerContribution<Extract<K, PluginLayerKind>>;
+declare const TraceContextMiddleware_base: RpcMiddleware.ServiceClass<TraceContextMiddleware, "@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", typeof PropagatedTrace, Schema.Never, never, never, true>;
 
-export declare type PluginEnvironment = RunConfiguration | SandboxDirectory | FileSystem.FileSystem | Module | Path.Path;
+declare interface TraceContextParts {
+    readonly version: string;
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly traceFlags: number;
+    readonly traceState?: string | undefined;
+}
+
+export declare type TracedRpc<Tag extends string, Payload extends Schema.Top = Schema.Void, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never> = Rpc.Rpc<Tag, Payload, Success, Error, typeof TraceContextMiddleware, RpcMiddleware.ApplyServices<typeof TraceContextMiddleware['Identifier'], never>>;
 
-export declare interface PluginInterfaces {
-    Checker: Checker;
-    TestRunner: TestRunner;
-    Ignore: Ignorer;
-    Evaluator: Evaluator;
+declare interface TryStatement$1 extends Span$1 {
+    type: "TryStatement";
+    block: BlockStatement$1;
+    handler: CatchClause$1 | null;
+    finalizer: BlockStatement$1 | null;
+    parent?: Node$1;
 }
 
-export declare const PluginKind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
+declare type TSAccessibility = "private" | "protected" | "public";
 
-export declare type PluginKind = typeof PluginKind.Type;
+declare interface TSAnyKeyword extends Span$1 {
+    type: "TSAnyKeyword";
+    parent?: Node$1;
+}
 
-export declare class PluginLayerContribution<K extends PluginLayerKind = PluginLayerKind> extends PluginLayerContribution_base {
-    readonly kind: K;
-    readonly name: string;
-    readonly layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>;
+declare interface TSArrayType$1 extends Span$1 {
+    type: "TSArrayType";
+    elementType: TSType$1;
+    parent?: Node$1;
 }
 
-declare const PluginLayerContribution_base: S.Class<PluginLayerContribution<"Checker" | "Evaluator" | "Ignore" | "TestRunner">, S.TaggedStruct<"PluginContribution", {
-    readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Ignore", "Evaluator"]>;
-    readonly name: S.String;
-    readonly layer: S.Unknown;
-}>, {}>;
+declare interface TSAsExpression$1 extends Span$1 {
+    type: "TSAsExpression";
+    expression: Expression$1;
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
 
-export declare const PluginLayerKind: S.Literals<readonly ["Checker", "TestRunner", "Ignore", "Evaluator"]>;
+declare interface TSBigIntKeyword extends Span$1 {
+    type: "TSBigIntKeyword";
+    parent?: Node$1;
+}
 
-export declare type PluginLayerKind = typeof PluginLayerKind.Type;
+declare interface TSBooleanKeyword extends Span$1 {
+    type: "TSBooleanKeyword";
+    parent?: Node$1;
+}
 
-export declare class PluginReporterContribution extends PluginReporterContribution_base {
-    readonly kind: 'Reporter';
-    readonly name: string;
-    readonly make: ReporterFactory;
+declare interface TSCallSignatureDeclaration$1 extends Span$1 {
+    type: "TSCallSignatureDeclaration";
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
 }
 
-declare const PluginReporterContribution_base: S.Class<PluginReporterContribution, S.TaggedStruct<"PluginContribution", {
-    readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
-    readonly name: S.String;
-    readonly make: S.Unknown;
-}>, {}>;
+declare interface TSClassImplements extends Span$1 {
+    type: "TSClassImplements";
+    expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
 
-export declare type Position = typeof PositionSchema.Type;
+declare interface TSConditionalType$1 extends Span$1 {
+    type: "TSConditionalType";
+    checkType: TSType$1;
+    extendsType: TSType$1;
+    trueType: TSType$1;
+    falseType: TSType$1;
+    parent?: Node$1;
+}
 
-export declare const PositionSchema: S.Struct<{
-    readonly line: S.Finite;
-    readonly column: S.Finite;
-}>;
+declare interface TSConstructorType$1 extends Span$1 {
+    type: "TSConstructorType";
+    abstract: boolean;
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1;
+    parent?: Node$1;
+}
 
-export declare type Primitive = boolean | number | string | null | undefined;
+declare interface TSConstructSignatureDeclaration$1 extends Span$1 {
+    type: "TSConstructSignatureDeclaration";
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
 
-/**
- * Given a base type, allows type safe access to the name of a property.
- * @param prop - The property name
- */
-export declare function propertyPath<T>(): PropertyPathOverloads<T>;
+declare interface TSEnumBody extends Span$1 {
+    type: "TSEnumBody";
+    members: Array<TSEnumMember>;
+    parent?: Node$1;
+}
 
-export declare interface PropertyPathOverloads<T> {
-    (key: KnownKeys<T>): string;
-    <TProp1 extends KnownKeys<T>>(key: TProp1, key2: KnownKeys<OnlyObject<T[TProp1]>>): string;
-    <TProp1 extends KnownKeys<T>, TProp2 extends KnownKeys<OnlyObject<T[TProp1]>>>(key: TProp1, key2: TProp2, key3: KnownKeys<OnlyObject<OnlyObject<T[TProp1]>[TProp2]>>): string;
+declare interface TSEnumDeclaration$1 extends Span$1 {
+    type: "TSEnumDeclaration";
+    id: BindingIdentifier$1;
+    body: TSEnumBody;
+    const: boolean;
+    declare: boolean;
+    parent?: Node$1;
 }
 
-/**
- * The four option defaults a human reads about in help text.
- *
- * `Schema.schema.ts` declares every default, and a CLI that wants to
- * name one in a `--help` description must read it from here rather than type
- * the literal a second time: a restated default drifts the moment the schema
- * moves, and no gate compares a help string against a schema annotation.
- *
- * Only these four are here because only these four are rendered. A default
- * nobody prints has one declaration site already, which is the schema.
- */
-export declare const RENDERED_OPTION_DEFAULTS: {
-    readonly coverageAnalysis: 'perTest';
-    readonly fileLogLevel: 'off';
-    readonly logLevel: 'info';
-    readonly tempDirName: '.stryker-tmp';
-};
+declare interface TSEnumMember extends Span$1 {
+    type: "TSEnumMember";
+    id: TSEnumMemberName;
+    initializer: Expression$1 | null;
+    computed: boolean;
+    parent?: Node$1;
+}
 
-export declare type ReporterEvent = DryRunCompleted | MutationTestingPlanReady | MutantTested | MutationTestReportReady;
+declare type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
+
+declare interface TSExportAssignment$1 extends Span$1 {
+    type: "TSExportAssignment";
+    expression: Expression$1;
+    parent?: Node$1;
+}
 
-export declare const ReporterEventKind: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+declare interface TSExternalModuleReference extends Span$1 {
+    type: "TSExternalModuleReference";
+    expression: StringLiteral$1;
+    parent?: Node$1;
+}
 
-export declare type ReporterEventKind = typeof ReporterEventKind.Type;
+declare interface TSFunctionType$1 extends Span$1 {
+    type: "TSFunctionType";
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1;
+    parent?: Node$1;
+}
 
-export declare const ReporterEventSchema: StandardSchemaV1<unknown, ReporterEvent>;
+declare interface TSGlobalDeclaration extends Span$1 {
+    type: "TSModuleDeclaration";
+    id: IdentifierName$1;
+    body: TSModuleBlock$1;
+    kind: "global";
+    declare: boolean;
+    global: true;
+    parent?: Node$1;
+}
 
-export declare const ReporterEventUnion: S.Union<readonly [typeof DryRunCompleted, typeof MutationTestingPlanReady, typeof MutantTested, typeof MutationTestReportReady]>;
+declare interface TSImportEqualsDeclaration$1 extends Span$1 {
+    type: "TSImportEqualsDeclaration";
+    id: BindingIdentifier$1;
+    moduleReference: TSModuleReference;
+    importKind: ImportOrExportKind;
+    parent?: Node$1;
+}
 
-export declare type ReporterFactory = (options: StrykerOptions, init: ReporterInit) => (events: AsyncIterable<ReporterEvent>) => Promise<void>;
+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;
+}
 
-export declare class ReporterFailed extends ReporterFailed_base {}
+declare interface TSImportTypeQualifiedName extends Span$1 {
+    type: "TSQualifiedName";
+    left: TSImportTypeQualifier;
+    right: IdentifierName$1;
+    parent?: Node$1;
+}
 
-declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {
-    readonly cause: S.String;
-    readonly event: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
-    readonly reporterName: S.String;
-}>, YieldableError>;
+declare type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
 
-export declare interface ReporterInit {
-    readonly traceparent?: string | undefined;
-    readonly tracestate?: string | undefined;
+declare interface TSIndexedAccessType$1 extends Span$1 {
+    type: "TSIndexedAccessType";
+    objectType: TSType$1;
+    indexType: TSType$1;
+    parent?: Node$1;
 }
 
-export declare type ReporterPlanDescriptor = typeof ReporterPlanDescriptorSchema.Type;
+declare interface TSIndexSignature$1 extends Span$1 {
+    type: "TSIndexSignature";
+    parameters: Array<TSIndexSignatureName>;
+    typeAnnotation: TSTypeAnnotation$1;
+    readonly: boolean;
+    static: boolean;
+    accessibility: null;
+    parent?: Node$1;
+}
 
-export declare const ReporterPlanDescriptorSchema: S.Struct<{
-    readonly mutantId: S.String;
-    readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
-    readonly netTime: S.Finite;
-    readonly reloadEnvironment: S.Boolean;
-}>;
+declare interface TSIndexSignatureName extends Span$1 {
+    type: "Identifier";
+    decorators: [];
+    name: string;
+    optional: false;
+    typeAnnotation: TSTypeAnnotation$1;
+    parent?: Node$1;
+}
 
-export declare const ReporterPlanKind: S.Literals<readonly ["EarlyResult", "Run"]>;
+declare interface TSInferType$1 extends Span$1 {
+    type: "TSInferType";
+    typeParameter: TSTypeParameter;
+    parent?: Node$1;
+}
 
-export declare const ReportTypeType: S.Literals<readonly ["full", "mutationScore"]>;
+declare interface TSInstantiationExpression$1 extends Span$1 {
+    type: "TSInstantiationExpression";
+    expression: Expression$1;
+    typeArguments: TSTypeParameterInstantiation$1;
+    parent?: Node$1;
+}
 
-export declare type ReportTypeType = typeof ReportTypeType.Type;
+declare interface TSInterfaceBody$1 extends Span$1 {
+    type: "TSInterfaceBody";
+    body: Array<TSSignature>;
+    parent?: Node$1;
+}
 
-export declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
+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;
+}
 
-export declare class RunCommand extends RunCommand_base {}
+declare interface TSInterfaceHeritage extends Span$1 {
+    type: "TSInterfaceHeritage";
+    expression: Expression$1;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
 
-declare const RunCommand_base: S.Class<RunCommand, S.TaggedStruct<"RunCommand", {
-    readonly cliOptionsJson: S.String;
-    readonly targetMutatePatterns: S.$Array<S.String>;
-}>, {}>;
+declare interface TSIntersectionType$1 extends Span$1 {
+    type: "TSIntersectionType";
+    types: Array<TSType$1>;
+    parent?: Node$1;
+}
 
-export declare class RunConfiguration extends RunConfiguration_base {}
+declare interface TSIntrinsicKeyword extends Span$1 {
+    type: "TSIntrinsicKeyword";
+    parent?: Node$1;
+}
 
-declare const RunConfiguration_base: Context.ServiceClass<RunConfiguration, "~@systemfsoftware/stryker-js/RunConfiguration", {
-    readonly [x: string]: unknown;
-    readonly allowConsoleColors: boolean;
-    readonly buildCommand?: string | undefined;
-    readonly checkers: readonly string[];
-    readonly checkerNodeArgs: readonly string[];
-    readonly concurrency?: string | number | undefined;
-    readonly commandRunner: {
-        readonly [x: string]: unknown;
-        readonly command: string;
-    };
-    readonly coverageAnalysis: "all" | "off" | "perTest";
-    readonly clearTextReporter: {
-        readonly [x: string]: unknown;
-        readonly allowColor: boolean;
-        readonly allowEmojis: boolean;
-        readonly logTests: boolean;
-        readonly maxTestsToLog: number;
-        readonly reportTests: boolean;
-        readonly reportMutants: boolean;
-        readonly reportScoreTable: boolean;
-        readonly skipFull: boolean;
-    };
-    readonly dryRunOnly: boolean;
-    readonly ignorePatterns: readonly string[];
-    readonly ignoreStatic: boolean;
-    readonly incremental: boolean;
-    readonly incrementalFile: string;
-    readonly progressStreamFile: string;
-    readonly force: boolean;
-    readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
-    readonly inPlace: boolean;
-    readonly logLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
-    readonly maxConcurrentTestRunners: number;
-    readonly maxTestRunnerReuse: number;
-    readonly mutate: readonly string[];
-    readonly mutator: {
-        readonly excludedMutations: readonly string[];
-    };
-    readonly packageManager?: "npm" | "pnpm" | "yarn" | undefined;
-    readonly plugins: readonly string[];
-    readonly appendPlugins: readonly string[];
-    readonly reporters: readonly string[];
-    readonly htmlReporter: {
-        readonly fileName: string;
-    };
-    readonly jsonReporter: {
-        readonly fileName: string;
-    };
-    readonly disableTypeChecks: string | boolean;
-    readonly symlinkNodeModules: boolean;
-    readonly tempDirName: string;
-    readonly cleanTempDir: "always" | boolean;
-    readonly testRunner: string;
-    readonly testRunnerNodeArgs: readonly string[];
-    readonly thresholds: {
-        readonly high: number;
-        readonly low: number;
-        readonly break: number | null;
-    };
-    readonly timeoutFactor: number;
-    readonly timeoutMS: number;
-    readonly dryRunTimeoutMinutes: number;
-    readonly tsconfigFile: string;
-    readonly warnings: boolean | {
-        readonly [x: string]: unknown;
-        readonly unknownOptions: boolean;
-        readonly preprocessorErrors: boolean;
-        readonly unserializableOptions: boolean;
-        readonly slow: boolean;
-    };
-    readonly disableBail: boolean;
-    readonly allowEmpty: boolean;
-    readonly ignorers: readonly string[];
-    readonly testFiles: readonly string[];
-}>;
+declare type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
 
-declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
+declare interface TSLiteralType$1 extends Span$1 {
+    type: "TSLiteralType";
+    literal: TSLiteral;
+    parent?: Node$1;
+}
 
-declare type RunEvent = typeof RunEvent.Type;
-export { RunEvent }
-export { RunEvent as RunEventType }
+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;
+}
 
-export declare class RunEvents extends RunEvents_base {}
+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 const RunEvents_base: Context.ServiceClass<RunEvents, "~@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | PhaseEntered | PlanKnown | RunFailed | RunMutantTested | RunStarted | VerdictReached, Cause.Done<void>>>;
+declare type TSMethodSignatureKind = "method" | "get" | "set";
 
-export declare class RunFailed extends RunFailed_base {}
+declare interface TSModuleBlock$1 extends Span$1 {
+    type: "TSModuleBlock";
+    body: Array<Directive | Statement$1>;
+    parent?: Node$1;
+}
 
-declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
-    readonly schemaVersion: S.String;
-    readonly code: S.Finite;
-    readonly error: S.String;
-    readonly remediation: S.String;
-}>, {}>;
+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;
+}
 
-export declare class RunIdentity extends RunIdentity_base {}
+declare type TSModuleDeclarationKind = "module" | "namespace";
 
-declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "~@systemfsoftware/stryker-js/RunIdentity", RunIdentityShape>;
+declare type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
 
-export declare interface RunIdentityShape {
-    readonly runId: string;
-    readonly basePath: string;
+declare interface TSNamedTupleMember$1 extends Span$1 {
+    type: "TSNamedTupleMember";
+    label: IdentifierName$1;
+    elementType: TSTupleElement;
+    optional: boolean;
+    parent?: Node$1;
 }
 
-export declare type RunMutantResult = Mutant & {
-    readonly status: MutantStatus;
-    readonly statusReason?: string | undefined;
-    readonly testsCompleted?: number | undefined;
-    readonly killedBy?: readonly string[] | undefined;
-    readonly coveredBy?: readonly string[] | undefined;
-    readonly static?: boolean | undefined;
-};
+declare interface TSNamespaceExportDeclaration$1 extends Span$1 {
+    type: "TSNamespaceExportDeclaration";
+    id: IdentifierName$1;
+    parent?: Node$1;
+}
 
-export declare class RunMutantTested extends RunMutantTested_base {}
+declare interface TSNeverKeyword extends Span$1 {
+    type: "TSNeverKeyword";
+    parent?: Node$1;
+}
 
-declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
-    readonly id: S.String;
-    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-    readonly file: S.String;
-    readonly location: S.Struct<{
-        readonly start: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-        readonly end: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-    }>;
-    readonly mutator: S.String;
-    readonly replacement: S.NullOr<S.String>;
-    readonly completed: S.Finite;
-    readonly total: S.Finite;
-}>, {}>;
+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;
+}
 
-export declare const runMutationTest: (io: MutationRunIo, command: RunCommand) => Effect.Effect<void, S.SchemaError, RunIdentity>;
+declare interface TSNumberKeyword extends Span$1 {
+    type: "TSNumberKeyword";
+    parent?: Node$1;
+}
 
-export declare interface RunOptions {
-    readonly timeout: number;
-    readonly disableBail: boolean;
+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;
 }
 
-export declare class RunOutput extends RunOutput_base {}
+declare interface TSParenthesizedType$1 extends Span$1 {
+    type: "TSParenthesizedType";
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
 
-declare const RunOutput_base: S.Class<RunOutput, S.TaggedStruct<"RunOutput", {
-    readonly verdictJson: S.String;
-    readonly exitCode: S.Finite;
-}>, {}>;
+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;
+}
 
-export declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+declare interface TSQualifiedName$1 extends Span$1 {
+    type: "TSQualifiedName";
+    left: TSTypeName;
+    right: IdentifierName$1;
+    parent?: Node$1;
+}
 
-export declare type RunPhase = typeof RunPhase.Type;
+declare interface TSRestType$1 extends Span$1 {
+    type: "TSRestType";
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
 
-export declare interface RunPlan {
-    readonly plan: 'Run';
-    readonly mutant: Mutant;
-    readonly runOptions: MutantRunOptions;
-    readonly netTime: number;
+declare interface TSSatisfiesExpression$1 extends Span$1 {
+    type: "TSSatisfiesExpression";
+    expression: Expression$1;
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
 }
 
-export declare class RunStarted extends RunStarted_base {}
+declare type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
 
-declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
-    readonly schemaVersion: S.String;
-    readonly runId: S.String;
-    readonly mode: S.Literals<readonly ["human", "machine"]>;
-    readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
-}>, {}>;
+declare interface TSStringKeyword extends Span$1 {
+    type: "TSStringKeyword";
+    parent?: Node$1;
+}
 
-export declare type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+declare interface TSSymbolKeyword extends Span$1 {
+    type: "TSSymbolKeyword";
+    parent?: Node$1;
+}
 
-export declare type RunTiming = typeof RunTimingSchema.Type;
+declare interface TSTemplateLiteralType$1 extends Span$1 {
+    type: "TSTemplateLiteralType";
+    quasis: Array<TemplateElement$1>;
+    types: Array<TSType$1>;
+    parent?: Node$1;
+}
 
-export declare const RunTimingSchema: S.Struct<{
-    readonly net: S.Finite;
-    readonly overhead: S.Finite;
-}>;
+declare interface TSThisParameter extends Span$1 {
+    type: "Identifier";
+    decorators: [];
+    name: "this";
+    optional: false;
+    typeAnnotation: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
 
-export declare class SandboxDirectory extends SandboxDirectory_base {}
+declare interface TSThisType extends Span$1 {
+    type: "TSThisType";
+    parent?: Node$1;
+}
 
-declare const SandboxDirectory_base: Context.ServiceClass<SandboxDirectory, "~@systemfsoftware/stryker-js/SandboxDirectory", string>;
+declare type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
 
-export declare interface SelectedReporterFactory {
-    readonly name: string;
-    readonly make: ReporterFactory;
+declare interface TSTupleType$1 extends Span$1 {
+    type: "TSTupleType";
+    elementTypes: Array<TSTupleElement>;
+    parent?: Node$1;
 }
 
-export declare class Shadowing extends Shadowing_base {}
+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 const Shadowing_base: S.Class<Shadowing, S.TaggedStruct<"Shadowing", {
-    readonly kind: S.String;
-    readonly name: S.String;
-    readonly shadowedIndex: S.Finite;
-    readonly winnerIndex: S.Finite;
-}>, {}>;
+declare interface TSTypeAliasDeclaration$1 extends Span$1 {
+    type: "TSTypeAliasDeclaration";
+    id: BindingIdentifier$1;
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    typeAnnotation: TSType$1;
+    declare: boolean;
+    parent?: Node$1;
+}
 
-export declare const shouldKeepTempDir: (exit: Exit.Exit<void, unknown>, cleanTempDir: 'always' | boolean) => boolean;
+declare interface TSTypeAnnotation$1 extends Span$1 {
+    type: "TSTypeAnnotation";
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
 
-export declare interface SkippedTestResult extends BaseTestResult {
-    readonly status: 'skipped';
+declare interface TSTypeAssertion$1 extends Span$1 {
+    type: "TSTypeAssertion";
+    typeAnnotation: TSType$1;
+    expression: Expression$1;
+    parent?: Node$1;
 }
 
-/**
- * The JSON Schema document derived from `StrykerOptionsSchema`, self-contained.
- *
- * It lives beside the schema module rather than inside it because it is a *use*
- * of that schema, not a declaration of one: `S.toJsonSchemaDocument` consumes a
- * schema and returns a plain document. Keeping uses out of a `*.schema.ts` is
- * what lets a tool read every exported schema in a package and trust that each
- * one is a schema - the generated law suite does exactly that, and a document
- * handed to `toEncoded` takes the whole suite down with it.
- */
-export declare const strykerCoreSchema: Record<string, unknown>;
+declare interface TSTypeLiteral extends Span$1 {
+    type: "TSTypeLiteral";
+    members: Array<TSSignature>;
+    parent?: Node$1;
+}
 
-/** The decoded type: every defaulted option is present. */
-export declare type StrykerOptions = S.Schema.Type<typeof StrykerOptionsSchema>;
+declare type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
 
-export declare const StrykerOptionsSchema: S.StructWithRest<S.Struct<{
-    readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly buildCommand: S.optional<S.String>;
-    readonly checkers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly concurrency: S.optional<S.Union<readonly [S.Finite, S.String]>>;
-    readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
-        readonly command: S.withDecodingDefaultKey<S.String, never>;
-    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
-    readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
-    readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
-        readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
-        readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
-    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
-    readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
-    readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
-    readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
-    readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
-    readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly mutator: S.withDecodingDefaultKey<S.Struct<{
-        readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    }>, never>;
-    readonly packageManager: S.optional<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
-    readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
-        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
-    }>, never>;
-    readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
-        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
-    }>, never>;
-    readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
-    readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
-    readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
-    readonly testRunner: S.withDecodingDefaultKey<S.String, never>;
-    readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
-        readonly high: S.withDecodingDefaultKey<S.Finite, never>;
-        readonly low: S.withDecodingDefaultKey<S.Finite, never>;
-        readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
-    }>, never>;
-    readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
-    readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
-    readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
-        readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
-        readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
-    }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
-    readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
-    readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-    readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
-}>, readonly [S.$Record<S.String, S.Unknown>]>;
+declare interface TSTypeOperator$1 extends Span$1 {
+    type: "TSTypeOperator";
+    operator: TSTypeOperatorOperator;
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
 
-/**
- * Creates a URL to the page where a consumer can report a bug against this
- * project.
- *
- * The tracker is ours. The ported original addressed the upstream StrykerJS
- * repository, along with its label and issue-template parameters, so every bug
- * a consumer filed from a Stryker run arrived at a project that does not own
- * this code (`REPO-O1`) and prefilled a template that does not exist here.
- *
- * @param titleSuggestion - The title to be prefilled in.
- */
-export declare function strykerReportBugUrl(titleSuggestion: string): string;
+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;
+}
 
-export declare interface SuccessTestResult extends BaseTestResult {
-    readonly status: 'success';
+declare interface TSTypeParameterDeclaration$1 extends Span$1 {
+    type: "TSTypeParameterDeclaration";
+    params: Array<TSTypeParameter>;
+    parent?: Node$1;
 }
 
-export declare interface SurvivedMutantRunResult {
-    readonly status: 'survived';
-    readonly nrOfTests: number;
+declare interface TSTypeParameterInstantiation$1 extends Span$1 {
+    type: "TSTypeParameterInstantiation";
+    params: Array<TSType$1>;
+    parent?: Node$1;
 }
 
-export declare type TestDefinition = typeof TestDefinitionSchema.Type;
+declare interface TSTypePredicate$1 extends Span$1 {
+    type: "TSTypePredicate";
+    parameterName: TSTypePredicateName;
+    asserts: boolean;
+    typeAnnotation: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
 
-export declare const TestDefinitionSchema: S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly location: S.optional<S.Struct<{
-        readonly start: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-        readonly end: S.optional<S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>>;
-    }>>;
-}>;
+declare type TSTypePredicateName = IdentifierName$1 | TSThisType;
 
-export declare type TestFile = typeof TestFileSchema.Type;
+declare interface TSTypeQuery$1 extends Span$1 {
+    type: "TSTypeQuery";
+    exprName: TSTypeQueryExprName;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
 
-export declare type TestFileDefinitionDictionary = typeof TestFileDefinitionDictionarySchema.Type;
+declare type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
 
-export declare const TestFileDefinitionDictionarySchema: S.$Record<S.String, S.Struct<{
-    readonly source: S.optional<S.String>;
-    readonly tests: S.$Array<S.Struct<{
-        readonly id: S.String;
-        readonly name: S.String;
-        readonly location: S.optional<S.Struct<{
-            readonly start: S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>;
-            readonly end: S.optional<S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>>;
-        }>>;
-    }>>;
-}>>;
+declare interface TSTypeReference$1 extends Span$1 {
+    type: "TSTypeReference";
+    typeName: TSTypeName;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
 
-export declare const TestFileSchema: 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.Struct<{
-            readonly start: S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>;
-            readonly end: S.optional<S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>>;
-        }>>;
-    }>>;
-}>;
+declare interface TSUndefinedKeyword extends Span$1 {
+    type: "TSUndefinedKeyword";
+    parent?: Node$1;
+}
 
-export declare function testFilesProvided(options: {
-    readonly testFiles?: readonly string[];
-}): boolean;
+declare interface TSUnionType$1 extends Span$1 {
+    type: "TSUnionType";
+    types: Array<TSType$1>;
+    parent?: Node$1;
+}
 
-export declare type TestPlan = EarlyResultPlan | RunPlan;
+declare interface TSUnknownKeyword extends Span$1 {
+    type: "TSUnknownKeyword";
+    parent?: Node$1;
+}
 
-export declare type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
+declare interface TSVoidKeyword extends Span$1 {
+    type: "TSVoidKeyword";
+    parent?: Node$1;
+}
 
-export declare const TestResultSchema: S.Union<readonly [S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"failed">;
-    readonly failureMessage: S.String;
-}>, S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"skipped">;
-}>, S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"success">;
-}>]>;
+declare const TypeId: '~stryker/mutation-run/StageError';
 
-export declare class TestRunner extends TestRunner_base {}
+declare interface UnaryExpression$1 extends Span$1 {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    argument: Expression$1;
+    prefix: true;
+    parent?: Node$1;
+}
 
-declare const TestRunner_base: Context.ServiceClass<TestRunner, "~@systemfsoftware/stryker-js/TestRunner", TestRunnerService>;
+declare type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
 
-export declare interface TestRunnerCapabilities {
-    readonly reloadEnvironment: boolean;
+export declare interface UnserializableDescription {
+    path: string[];
+    reason: string;
 }
 
-export declare const TestRunnerCapabilitiesSchema: S.Struct<{
-    readonly reloadEnvironment: S.Boolean;
-}>;
-
-export declare class TestRunnerFailed extends TestRunnerFailed_base {}
+declare interface UpdateExpression$1 extends Span$1 {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    prefix: boolean;
+    argument: SimpleAssignmentTarget$1;
+    parent?: Node$1;
+}
 
-declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"TestRunnerFailed", {
-    readonly cause: S.String;
-    readonly phase: S.Literals<readonly ["capabilities", "dispose", "dryRun", "init", "mutantRun"]>;
-    readonly runnerName: S.String;
-}>, YieldableError>;
+declare type UpdateOperator = "++" | "--";
 
-export declare interface TestRunnerService {
-    readonly capabilities: Effect.Effect<TestRunnerCapabilities, TestRunnerFailed>;
-    readonly init: Effect.Effect<void, TestRunnerFailed>;
-    readonly dryRun: (options: DryRunOptions) => Effect.Effect<DryRunResult, TestRunnerFailed>;
-    readonly mutantRun: (options: MutantRunOptions) => Effect.Effect<MutantRunResult, TestRunnerFailed>;
-    readonly dispose: Effect.Effect<void, TestRunnerFailed>;
+declare interface V8IntrinsicExpression extends Span$1 {
+    type: "V8IntrinsicExpression";
+    name: IdentifierName$1;
+    arguments: Array<Argument$1>;
+    parent?: Node$1;
 }
 
-export declare const TestStatus: S.Literals<readonly ["success", "failed", "skipped"]>;
+export declare function validateOptions(options: Record<string, unknown>, schema: ValidationSchemaDocument): Effect.Effect<StrykerOptions, ConfigError>;
 
-export declare type TestStatus = typeof TestStatus.Type;
+export declare type ValidationSchemaDocument = {
+    readonly properties?: unknown;
+    readonly [key: string]: unknown;
+};
 
-export declare type Thresholds = typeof ThresholdsSchema.Type;
+declare interface VariableDeclaration$1 extends Span$1 {
+    type: "VariableDeclaration";
+    kind: VariableDeclarationKind;
+    declarations: Array<VariableDeclarator$1>;
+    declare?: boolean;
+    parent?: Node$1;
+}
 
-export declare const ThresholdsSchema: S.Struct<{
-    readonly high: S.Finite;
-    readonly low: S.Finite;
-}>;
+declare type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
 
-export declare interface TimeoutDryRunResult {
-    readonly status: 'timeout';
-    readonly reason?: string;
+declare interface VariableDeclarator$1 extends Span$1 {
+    type: "VariableDeclarator";
+    id: BindingPattern$1;
+    init: Expression$1 | null;
+    definite?: boolean;
+    parent?: Node$1;
 }
 
-export declare interface TimeoutMutantRunResult {
-    readonly status: 'timeout';
-    readonly reason?: string;
+export declare const VERDICT_ENVELOPE_SCHEMA_VERSION = "1.1";
+
+export declare interface VerdictCounts {
+    readonly killed: number;
+    readonly timeout: number;
+    readonly survived: number;
+    readonly noCoverage: number;
+    readonly runtimeErrors: number;
+    readonly compileErrors: number;
+    readonly ignored: number;
+    readonly pending: number;
 }
 
-export declare function toMutantRunResult(dryRunResult: DryRunResult, reportAllKillers: boolean): MutantRunResult;
+export declare interface VerdictEnvelope {
+    readonly schemaVersion: string;
+    readonly runId: string;
+    readonly mode: OutputMode;
+    readonly signal: ModeSignal;
+    readonly score: number | null;
+    readonly thresholds: VerdictThresholds;
+    readonly counts: VerdictCounts;
+    readonly reportFile: string | null;
+    readonly mutants: readonly VerdictMutant[];
+}
 
 export declare function verdictExitClass(score: number | null, breakingThreshold: number | null): ExitClass | null;
 
+export declare interface VerdictMutant {
+    readonly id: string;
+    readonly file: string;
+    readonly location: Location;
+    readonly mutator: string;
+    readonly replacement: string | null;
+    readonly status: MutantStatus;
+}
+
 export declare class VerdictReached extends VerdictReached_base {}
 
 declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
@@ -1600,4 +3110,126 @@ declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdi
     }>>;
 }>, {}>;
 
+export declare interface VerdictThresholds {
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+}
+
+export declare interface VmModule {
+    readonly createContext: (sandbox: object) => object;
+    readonly Script: new (code: string, options?: {
+        readonly filename?: string;
+    }) => VmScript;
+}
+
+export declare interface VmModuleBuiltin {
+    readonly createRequire: (fileName: string | URL) => VmRequire;
+    readonly stripTypeScriptTypes: (source: string, options?: {
+        readonly mode?: 'strip' | 'transform';
+    }) => string;
+}
+
+export declare interface VmPlatform {
+    readonly module: VmModuleBuiltin;
+    readonly vm: VmModule;
+}
+
+export declare type VmRequire = (specifier: string) => unknown;
+
+export declare class VmRunner extends VmRunner_base {}
+
+declare const VmRunner_base: Context.ServiceClass<VmRunner, "@systemfsoftware/stryker-js/VmRunner", VmPlatform>;
+
+export declare const vmRunnerCapabilities: {
+    readonly reloadEnvironment: true;
+};
+
+export declare const vmRunnerName = "vm";
+
+export declare interface VmScript {
+    readonly runInContext: (context: object) => unknown;
+}
+
+export declare const vmTestRunner: (config: VmTestRunnerConfig) => Effect.Effect<PooledTestRunner, TestRunnerFailed, FileSystem.FileSystem | VmRunner>;
+
+export declare interface VmTestRunnerConfig {
+    readonly testFiles: readonly string[];
+}
+
+export declare type WarningOptions = Exclude<StrykerOptions['warnings'], boolean>;
+
+declare interface WhileStatement$1 extends Span$1 {
+    type: "WhileStatement";
+    test: Expression$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+export declare type WiredRunLayer = Layer.Layer<RunStageServices | EnginePorts, never, never>;
+
+declare interface WithStatement$1 extends Span$1 {
+    type: "WithStatement";
+    object: Expression$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+export declare type WorkerBootError = WorkerExit | WorkerBootTimeoutError;
+
+export declare class WorkerBootTimeoutError extends WorkerBootTimeoutError_base {
+    readonly exitClass: 'InternalError';
+}
+
+declare const WorkerBootTimeoutError_base: Schema.Class<WorkerBootTimeoutError, Schema.TaggedStruct<"WorkerBootTimeoutError", {
+    readonly pid: Schema.Int;
+}>, YieldableError>;
+
+export declare interface WorkerClientParams<Rpcs extends Rpc.Any> extends WorkerSpawnParams {
+    readonly rpcs: RpcGroup.RpcGroup<Rpcs>;
+}
+
+export declare type WorkerExit = ChildProcessCrashedError | OutOfMemoryError;
+
+export declare class WorkerLauncher extends WorkerLauncher_base {}
+
+declare const WorkerLauncher_base: Context.ServiceClass<WorkerLauncher, "@systemfsoftware/stryker-js/WorkerLauncher", WorkerLauncherShape>;
+
+export declare interface WorkerLauncherShape {
+    readonly spawn: (params: WorkerSpawnParams) => Effect.Effect<SpawnedSocketWorker, ChildProcessCrashedError, Scope.Scope>;
+}
+
+export declare interface WorkerPluginDescriptor<K extends WorkerPluginKind = WorkerPluginKind> {
+    readonly kind: K;
+    readonly name: string;
+    readonly workerEntry: string;
+}
+
+export declare const WorkerPluginKind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
+
+export declare type WorkerPluginKind = typeof WorkerPluginKind.Type;
+
+export declare interface WorkerPluginSource<K extends WorkerPluginKind = WorkerPluginKind> {
+    readonly kind: K;
+    readonly name: string;
+    readonly modulePath: string;
+    readonly workerEntry: string;
+}
+
+export declare 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;
+}
+
+declare interface YieldExpression$1 extends Span$1 {
+    type: "YieldExpression";
+    delegate: boolean;
+    argument: Expression$1 | null;
+    parent?: Node$1;
+}
+
 export { }