@systemfsoftware/stryker-js 10.1.2 → 11.0.0

package/dist/index.d.mts

@@ -1,3319 +1,1084 @@
-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 { Duration } from 'effect/Duration';
-import * as Effect from 'effect/Effect';
-import * as EffectDuration from 'effect/Duration';
-import * as Exit from 'effect/Exit';
-import * as FileSystem from 'effect/FileSystem';
-import { HarnessModuleBuiltin } from '@systemfsoftware/stryker-vm-harness';
-import * as HashMap from 'effect/HashMap';
-import { JsonSchema } from 'effect/JsonSchema';
-import * as Layer from 'effect/Layer';
-import * as Metric from 'effect/Metric';
-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 * 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 * as Stream from 'effect/Stream';
-import { YieldableError } from 'effect/Cause';
-
-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;
-    readonly name: string;
-    readonly timeSpentMs: number;
-    readonly fileName?: string;
-    readonly startPosition?: Position;
-}
-
-declare interface BigIntLiteral$1 extends Span$1 {
-    type: "Literal";
-    value: bigint;
-    raw: string | null;
-    bigint: string;
-    parent?: Node$1;
-}
-
-declare interface BinaryExpression$1 extends Span$1 {
-    type: "BinaryExpression";
-    left: Expression$1;
-    operator: BinaryOperator;
-    right: Expression$1;
-    parent?: Node$1;
-}
-
-declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
-
-declare interface BindingIdentifier$1 extends Span$1 {
-    type: "Identifier";
-    decorators?: [];
-    name: string;
-    optional?: false;
-    typeAnnotation?: TSTypeAnnotation$1 | null;
-    parent?: Node$1;
-}
-
-declare type BindingPattern$1 = BindingIdentifier$1 | ObjectPattern | ArrayPattern$1 | AssignmentPattern$1;
-
-declare interface BindingProperty$1 extends Span$1 {
-    type: "Property";
-    kind: "init";
-    key: PropertyKey_2;
-    value: BindingPattern$1;
-    method: false;
-    shorthand: boolean;
-    computed: boolean;
-    optional?: false;
-    parent?: Node$1;
-}
-
-declare interface BindingRestElement$1 extends Span$1 {
-    type: "RestElement";
-    decorators?: [];
-    argument: BindingPattern$1;
-    optional?: false;
-    typeAnnotation?: TSTypeAnnotation$1 | null;
-    value?: null;
-    parent?: Node$1;
-}
-
-declare interface BlockStatement$1 extends Span$1 {
-    type: "BlockStatement";
-    body: Array<Statement$1>;
-    parent?: Node$1;
-}
-
-declare interface BooleanLiteral$1 extends Span$1 {
-    type: "Literal";
-    value: boolean;
-    raw: string | null;
-    parent?: Node$1;
-}
-
-declare interface BreakStatement$1 extends Span$1 {
-    type: "BreakStatement";
-    label: LabelIdentifier$1 | null;
-    parent?: Node$1;
-}
-
-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;
-
-declare interface CallExpression$1 extends Span$1 {
-    type: "CallExpression";
-    callee: Expression$1;
-    typeArguments?: TSTypeParameterInstantiation$1 | null;
-    arguments: Array<Argument$1>;
-    optional: boolean;
-    parent?: Node$1;
-}
-
-declare interface CatchClause$1 extends Span$1 {
-    type: "CatchClause";
-    param: BindingPattern$1 | null;
-    body: BlockStatement$1;
-    parent?: Node$1;
-}
-
-declare type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
-
-declare interface ChainExpression$1 extends Span$1 {
-    type: "ChainExpression";
-    expression: ChainElement;
-    parent?: Node$1;
-}
-
-export declare class CheckerAnsweredUnrequested extends CheckerAnsweredUnrequested_base {}
-
-declare const CheckerAnsweredUnrequested_base: S.Class<CheckerAnsweredUnrequested, S.TaggedStruct<"CheckerAnsweredUnrequested", {
-    readonly checkerName: S.String;
-    readonly phase: S.Literals<readonly ["check", "group"]>;
-    readonly unrequestedIds: S.$Array<S.String>;
-    readonly requestedIds: S.$Array<S.String>;
-}>, YieldableError>;
-
-export declare const CheckerCheckResult: S.$Record<S.String, S.Union<readonly [S.Struct<{
-    readonly status: S.Literal<"passed">;
-}>, S.Struct<{
-    readonly status: S.Literal<"compileError">;
-    readonly reason: S.String;
-}>]>>;
-
-export declare type CheckerContractBroken = CheckerAnsweredUnrequested | CheckerSkippedRequested;
-
-export declare type CheckerCrash = ChildProcessCrashedError | OutOfMemoryError;
-
-export declare const checkerDuration: Metric.Histogram<Duration>;
-
-export declare class CheckerFailed extends CheckerFailed_base {}
-
-declare const CheckerFailed_base: S.Class<CheckerFailed, S.TaggedStruct<"CheckerFailed", {
-    readonly cause: S.String;
-    readonly checkerName: S.String;
-    readonly mutantIds: S.$Array<S.String>;
-}>, YieldableError>;
-
-export declare const CheckerGroupResult: S.$Array<S.$Array<S.String>>;
-
-export declare const checkerMutantsChecked: Metric.Counter<number>;
-
-export declare const checkerMutantsSkipped: Metric.Counter<number>;
-
-export declare const CheckerMutantWire: S.Struct<{
-    readonly id: S.NonEmptyString;
-    readonly fileName: S.NonEmptyString;
-    readonly mutatorName: S.NonEmptyString;
-    readonly replacement: S.String;
-    readonly location: S.Struct<{
-        readonly start: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-        readonly end: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-    }>;
-}>;
-
-export declare type CheckerMutantWire = typeof CheckerMutantWire.Type;
-
-export declare const checkerProcessCrashes: Metric.Counter<number>;
-
-export declare const CheckerRequest: S.Struct<{
-    readonly checkerName: S.String;
-    readonly mutants: S.$Array<S.Struct<{
-        readonly id: S.NonEmptyString;
-        readonly fileName: S.NonEmptyString;
-        readonly mutatorName: S.NonEmptyString;
-        readonly replacement: S.String;
-        readonly location: S.Struct<{
-            readonly start: S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>;
-            readonly end: S.Struct<{
-                readonly line: S.Finite;
-                readonly column: S.Finite;
-            }>;
-        }>;
-    }>>;
-}>;
-
-export declare type CheckerRequest = typeof CheckerRequest.Type;
-
-/**
- * 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 CheckerMutantWire[]) => Effect.Effect<Record<string, CheckResult>, CheckerCrash | CheckerFailed>;
-    readonly group: (checkerName: string, mutants: readonly CheckerMutantWire[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash | CheckerFailed>;
-}
-
-export declare const checkerRpcFailures: Metric.Counter<number>;
-
-export declare const CheckerRpcs: RpcGroup.RpcGroup<TracedRpc<'check', typeof CheckerRequest, typeof CheckerCheckResult, typeof CheckerFailed> | TracedRpc<'group', typeof CheckerRequest, typeof CheckerGroupResult, typeof CheckerFailed>>;
-
-export declare class CheckerSkippedRequested extends CheckerSkippedRequested_base {}
-
-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 | CheckerFailed | CheckerContractBroken>;
-
-export declare type CheckResult = FailedCheckResult | PassedCheckResult;
-
-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;
-
-/**
- * The child process hosting a worker ended when it was not supposed to.
- */
-export declare class ChildProcessCrashedError extends ChildProcessCrashedError_base {
-    readonly exitClass: 'InternalError';
-}
-
-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 interface Class$1 extends Span$1 {
-    type: ClassType;
-    decorators: Array<Decorator$1>;
-    id: BindingIdentifier$1 | null;
-    typeParameters?: TSTypeParameterDeclaration$1 | null;
-    superClass: Expression$1 | null;
-    superTypeArguments?: TSTypeParameterInstantiation$1 | null;
-    implements?: Array<TSClassImplements>;
-    body: ClassBody$1;
-    abstract?: boolean;
-    declare?: boolean;
-    parent?: Node$1;
-}
-
-declare interface ClassBody$1 extends Span$1 {
-    type: "ClassBody";
-    body: Array<ClassElement>;
-    parent?: Node$1;
-}
-
-declare type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
-
-export declare const classifyWorkerExit: (pid: number, exitCode: number) => ChildProcessCrashedError | OutOfMemoryError;
-
-declare type ClassType = "ClassDeclaration" | "ClassExpression";
-
-export declare interface CompleteDryRunResult {
-    readonly tests: readonly TestResult[];
-    readonly mutantCoverage?: MutantCoverage;
-    readonly status: 'complete';
-}
-
-declare interface ComputedMemberExpression extends Span$1 {
-    type: "MemberExpression";
-    object: Expression$1;
-    property: Expression$1;
-    optional: boolean;
-    computed: true;
-    parent?: Node$1;
-}
-
-declare interface ConditionalExpression$1 extends Span$1 {
-    type: "ConditionalExpression";
-    test: Expression$1;
-    consequent: Expression$1;
-    alternate: Expression$1;
-    parent?: Node$1;
-}
-
-export declare const CONFIG_SYNTAX_HELP: string;
-
-export declare const ConfigDocumentSchema: S.$Record<S.String, S.Unknown>;
-
-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>;
-
-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, unknown, never, never>;
-
-declare interface ContinueStatement$1 extends Span$1 {
-    type: "ContinueStatement";
-    label: LabelIdentifier$1 | null;
-    parent?: Node$1;
-}
-
-export declare const countMutants: (mutants: readonly MutantResult[]) => Metrics;
-
-export declare type CoverageAnalysis = 'off' | 'all' | 'perTest';
-
-export declare type CoverageData = Record<string, number>;
-
-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;
-
-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 deepFreeze<T>(target: T): Immutable<T>;
-
-/**
- * Every option optional, all the way down, and mutable: this is the type a
- * caller CONSTRUCTS by assignment, so `readonly` is stripped. The decoded
- * `StrykerOptions` keeps it - that side is read, never built.
- */
-export declare type DeepOptional<T, V = unknown> = { -readonly [P in keyof T]?: T[P] extends Record<string, V> ? DeepOptional<T[P], V> | undefined : T[P]; };
-
-export declare const defaultOptions: Effect.Effect<Immutable<StrykerOptions>, never, never>;
-
-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 {}
-
-declare const DryRunCompleted_base: S.Class<DryRunCompleted, S.TaggedStruct<"dryRunCompleted", {
-    readonly timing: S.Struct<{
-        readonly net: S.Finite;
-        readonly overhead: S.Finite;
-    }>;
-    readonly capabilities: S.Struct<{
-        readonly reloadEnvironment: S.Boolean;
-    }>;
-    readonly testCount: S.Int;
-    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">;
-    }>]>>;
-}>, {}>;
-
-export declare interface DryRunDone extends InstrumentDone {
-    readonly dryRunResult: CompleteDryRunResult;
-    readonly testCoverage: TestCoverage;
-    readonly timeOverhead: EffectDuration.Duration;
-}
-
-export declare interface DryRunOptions extends RunOptions {
-    readonly coverageAnalysis: CoverageAnalysis;
-    readonly files?: readonly string[];
-    readonly testFiles?: readonly string[];
-}
-
-export declare type DryRunResult = CompleteDryRunResult | ErrorDryRunResult | TimeoutDryRunResult;
-
-declare interface EmptyStatement$1 extends Span$1 {
-    type: "EmptyStatement";
-    parent?: Node$1;
-}
-
-export declare type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | WorkerLauncher;
-
-export declare interface ErrorDryRunResult {
-    readonly status: 'error';
-    readonly errorMessage: string;
-}
-
-export declare interface ErrorMutantRunResult {
-    readonly status: 'error';
-    readonly errorMessage: 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 const EXIT_CODE: Record<ExitClass, number>;
-
-export declare const ExitClass: S.Literals<readonly ["VerdictFail", "ConfigError", "RuntimeError", "InternalError"]>;
-
-export declare type ExitClass = typeof ExitClass.Type;
-
-declare interface ExportAllDeclaration$1 extends Span$1 {
-    type: "ExportAllDeclaration";
-    exported: ModuleExportName | null;
-    source: StringLiteral$1;
-    attributes: Array<ImportAttribute$1>;
-    exportKind?: ImportOrExportKind;
-    parent?: Node$1;
-}
-
-declare interface ExportDefaultDeclaration$1 extends Span$1 {
-    type: "ExportDefaultDeclaration";
-    declaration: ExportDefaultDeclarationKind;
-    exportKind?: "value";
-    parent?: Node$1;
-}
-
-declare type ExportDefaultDeclarationKind = Function$1 | Class$1 | TSInterfaceDeclaration$1 | Expression$1;
-
-declare interface ExportNamedDeclaration$1 extends Span$1 {
-    type: "ExportNamedDeclaration";
-    declaration: Declaration | null;
-    specifiers: Array<ExportSpecifier>;
-    source: StringLiteral$1 | null;
-    exportKind?: ImportOrExportKind;
-    attributes: Array<ImportAttribute$1>;
-    parent?: Node$1;
-}
-
-declare interface ExportSpecifier extends Span$1 {
-    type: "ExportSpecifier";
-    local: ModuleExportName;
-    exported: ModuleExportName;
-    exportKind?: ImportOrExportKind;
-    parent?: Node$1;
-}
-
-declare type Expression$1 = BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | IdentifierReference$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | MetaProperty$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
-
-declare interface ExpressionStatement$1 extends Span$1 {
-    type: "ExpressionStatement";
-    expression: Expression$1;
-    directive?: string | null;
-    parent?: Node$1;
-}
-
-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;
-    readonly status: 'compileError';
-}
-
-export declare interface FailedTestResult extends BaseTestResult {
-    readonly status: 'failed';
-    readonly failureMessage: string;
-}
-
-export declare interface FileDescription {
-    readonly mutate: MutateDescription;
-}
-
-export declare type FileDescriptions = Record<string, FileDescription>;
-
-export declare type FileResult = typeof FileResultSchema.Type;
-
-export declare const FileResultSchema: 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.Int>;
-        readonly duration: S.optional<S.Finite>;
-    }>>;
-}>;
-
-export declare function findUnserializables<A = unknown>(thing: A): UnserializableDescription[] | undefined;
-
-declare interface ForInStatement$1 extends Span$1 {
-    type: "ForInStatement";
-    left: ForStatementLeft;
-    right: Expression$1;
-    body: Statement$1;
-    parent?: Node$1;
-}
-
-export declare const forkCoreSchema: JsonSchema;
-
-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.decodeTo<S.declare<{
-        readonly high: number;
-        readonly low: number;
-        readonly break: number | null;
-    }, {
-        readonly high: number;
-        readonly low: number;
-        readonly break: number | null;
-    }>, 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, 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?: Array<Decorator$1>;
-    optional?: boolean;
-    typeAnnotation?: TSTypeAnnotation$1 | null;
-    value?: null;
-    parent?: Node$1;
-}
-
-declare interface ForOfStatement$1 extends Span$1 {
-    type: "ForOfStatement";
-    await: boolean;
-    left: ForStatementLeft;
-    right: Expression$1;
-    body: Statement$1;
-    parent?: Node$1;
-}
-
-declare interface ForStatement$1 extends Span$1 {
-    type: "ForStatement";
-    init: ForStatementInit | null;
-    test: Expression$1 | null;
-    update: Expression$1 | null;
-    body: Statement$1;
-    parent?: Node$1;
-}
-
-declare type ForStatementInit = VariableDeclaration$1 | Expression$1;
-
-declare type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
-
-declare type FramedDrain = (framed: Stream.Stream<string, never, never>) => Effect.Effect<void, never, never>;
-
-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.Int;
-    readonly total: S.NullOr<S.Int>;
-}>, {}>;
-
-export declare class HelpRendered extends HelpRendered_base {}
-
-declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
-    readonly schemaVersion: S.String;
-    readonly code: S.Literals<readonly [0]>;
-    readonly help: S.String;
-}>, {}>;
-
-export declare function highestExitClass(pending: Iterable<ExitClass>): ExitClass | null;
-
-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>;
-
-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[]) => void);
-
-declare interface ImportAttribute$1 extends Span$1 {
-    type: "ImportAttribute";
-    key: ImportAttributeKey;
-    value: StringLiteral$1;
-    parent?: Node$1;
-}
-
-declare type ImportAttributeKey = IdentifierName$1 | StringLiteral$1;
-
-declare interface ImportDeclaration$1 extends Span$1 {
-    type: "ImportDeclaration";
-    specifiers: Array<ImportDeclarationSpecifier>;
-    source: StringLiteral$1;
-    phase: ImportPhase | null;
-    attributes: Array<ImportAttribute$1>;
-    importKind?: ImportOrExportKind;
-    parent?: Node$1;
-}
-
-declare type ImportDeclarationSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
-
-declare interface ImportDefaultSpecifier extends Span$1 {
-    type: "ImportDefaultSpecifier";
-    local: BindingIdentifier$1;
-    parent?: Node$1;
-}
-
-export declare const ImportedModuleSchema: S.Struct<{
-    readonly default: S.optional<S.Unknown>;
-}>;
-
-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<A = unknown>(moduleName: string): Effect.Effect<A, 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 incrementalVersion: S.String;
-    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;
-}
-
-declare interface JSXOpeningElement$1 extends Span$1 {
-    type: "JSXOpeningElement";
-    name: JSXElementName;
-    typeArguments?: TSTypeParameterInstantiation$1 | null;
-    attributes: Array<JSXAttributeItem>;
-    selfClosing: boolean;
-    parent?: Node$1;
-}
-
-declare interface JSXOpeningFragment extends Span$1 {
-    type: "JSXOpeningFragment";
-    attributes?: [];
-    selfClosing?: false;
-    parent?: Node$1;
-}
-
-declare interface JSXSpreadAttribute$1 extends Span$1 {
-    type: "JSXSpreadAttribute";
-    argument: Expression$1;
-    parent?: Node$1;
-}
-
-declare interface JSXSpreadChild$1 extends Span$1 {
-    type: "JSXSpreadChild";
-    expression: Expression$1;
-    parent?: Node$1;
-}
-
-declare interface JSXText$1 extends Span$1 {
-    type: "JSXText";
-    value: string;
-    raw: string | null;
-    parent?: Node$1;
-}
-
-export declare interface KilledMutantRunResult {
-    readonly status: 'killed';
-    readonly killedBy: readonly string[];
-    readonly failureMessage: string;
-    readonly nrOfTests: number;
-}
-
-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<A = unknown> {
-    readonly schemaContributions: readonly Record<string, A>[];
-    readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
-    readonly pluginModulePaths: readonly string[];
-    readonly pluginSources: readonly PluginSource[];
-    readonly ignorers: readonly Ignorer[];
-}
-
-export declare type Location = typeof LocationSchema.Type;
-
-export declare const LocationSchema: S.Struct<{
-    readonly start: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>;
-    readonly end: S.Struct<{
-        readonly line: S.Finite;
-        readonly column: S.Finite;
-    }>;
-}>;
-
-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 makeRunEventStream: (resolved: ResolvedModeInput) => Effect.Effect<RunEventStream, never, Stdio.Stdio | RunEventDrain>;
-
-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;
-}
-
-declare type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
-
-declare type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
-
-export declare class Metrics extends Metrics_base {
-    get totalDetected(): number;
-    get totalUndetected(): number;
-    get totalCovered(): number;
-    get totalValid(): number;
-    get totalInvalid(): number;
-    get totalMutants(): number;
-    get mutationScore(): number;
-    get mutationScoreBasedOnCoveredCode(): number;
-    static fromMutants(mutants: readonly {
-        readonly status: string;
-    }[]): Metrics;
-}
-
-declare const Metrics_base: S.Class<Metrics, S.Struct<{
-    readonly pending: S.Int;
-    readonly killed: S.Int;
-    readonly timeout: S.Int;
-    readonly survived: S.Int;
-    readonly noCoverage: S.Int;
-    readonly runtimeErrors: S.Int;
-    readonly compileErrors: S.Int;
-    readonly ignored: S.Int;
-}>, {}>;
-
-export declare interface MetricsResult {
-    readonly name: string;
-    readonly metrics: Metrics;
-    readonly childResults: readonly MetricsResult[];
-}
-
-declare interface MetricsResultEncoded {
-    readonly name: string;
-    readonly metrics: typeof Metrics.Encoded;
-    readonly childResults: readonly MetricsResultEncoded[];
-}
-
-export declare const MetricsSchema: typeof Metrics;
-
-export declare type ModeSignal = 'flag' | 'env' | 'tty' | 'agent' | 'tool';
-
-declare type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
-
-declare type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
-
-declare type ModuleKind = "script" | "module" | "commonjs";
-
-export declare class Mutant extends Mutant_base {}
-
-declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
-    readonly id: S.NonEmptyString;
-    readonly fileName: S.NonEmptyString;
-    readonly mutatorName: S.NonEmptyString;
-    readonly replacement: S.String;
-    readonly location: S.Struct<{
-        readonly start: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-        readonly end: S.Struct<{
-            readonly line: S.Finite;
-            readonly column: S.Finite;
-        }>;
-    }>;
-    readonly status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
-    readonly statusReason: S.optional<S.String>;
-    readonly coveredBy: S.optional<S.$Array<S.String>>;
-    readonly static: S.optional<S.Boolean>;
-    readonly testsCompleted: S.optional<S.Finite>;
-    readonly description: S.optional<S.String>;
-}>, {}>;
-
-export declare type MutantActivation = typeof MutantActivationSchema.Type;
-
-export declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
-
-export declare interface MutantCoverage {
-    readonly perTest: Record<string, Record<string, number>>;
-    readonly static: Record<string, number>;
-}
-
-export declare type MutantResult = typeof MutantResultSchema.Type;
-
-export declare const MutantResultSchema: 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.Int>;
-    readonly duration: S.optional<S.Finite>;
-}>;
-
-export declare interface MutantRunOptions extends RunOptions {
-    readonly testFilter?: readonly string[];
-    readonly hitLimit?: number;
-    readonly activeMutant: Mutant;
-    readonly sandboxFileName: string;
-    readonly mutantActivation: MutantActivation;
-    readonly reloadEnvironment: boolean;
-}
-
-export declare type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
-
-export declare type MutantStatus = typeof MutantStatusSchema.Type;
-
-export declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-
-export declare class MutantTested extends MutantTested_base {}
-
-declare const MutantTested_base: S.Class<MutantTested, S.TaggedStruct<"mutantTested", {
-    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.Int;
-    readonly total: S.Int;
-}>, {}>;
-
-export declare type MutateDescription = ReadonlyArray<MutationRange> | boolean;
-
-export declare interface MutationRange {
-    readonly start: Position;
-    readonly end: Position;
-}
-
-export declare const mutationTestCell: Cell.Cell<PrepareExecutorArgs, MutationTestDone, StageError, StageServices>;
-
-export declare interface MutationTestDone {
-    readonly results: readonly RunMutantResult[];
-    readonly verdict: ExitClass | null;
-}
-
-export declare class MutationTestingPlanReady extends MutationTestingPlanReady_base {}
-
-declare const MutationTestingPlanReady_base: S.Class<MutationTestingPlanReady, S.TaggedStruct<"mutationTestingPlanReady", {
-    readonly total: S.Int;
-    readonly plans: S.$Array<S.Struct<{
-        readonly mutantId: S.String;
-        readonly plan: S.Literals<readonly ["EarlyResult", "Run"]>;
-        readonly netTime: S.Finite;
-        readonly reloadEnvironment: S.Boolean;
-    }>>;
-}>, {}>;
-
-export declare class MutationTestReportReady extends MutationTestReportReady_base {}
-
-declare const MutationTestReportReady_base: S.Class<MutationTestReportReady, S.TaggedStruct<"mutationTestReportReady", {
-    readonly report: 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.Int>;
-                readonly duration: S.optional<S.Finite>;
-            }>>;
-        }>>;
-        readonly thresholds: S.decodeTo<S.declare<{
-            readonly high: number;
-            readonly low: number;
-        }, {
-            readonly high: number;
-            readonly low: number;
-        }>, S.Struct<{
-            readonly high: S.Finite;
-            readonly low: S.Finite;
-        }>, never, never>;
-        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>>;
-        }>>;
-    }>;
-    readonly metrics: S.Codec<MetricsResult, MetricsResultEncoded, never, never>;
-}>, {}>;
-
-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.Int>;
-            readonly duration: S.optional<S.Finite>;
-        }>>;
-    }>>;
-    readonly thresholds: S.decodeTo<S.declare<{
-        readonly high: number;
-        readonly low: number;
-    }, {
-        readonly high: number;
-        readonly low: number;
-    }>, S.Struct<{
-        readonly high: S.Finite;
-        readonly low: S.Finite;
-    }>, never, never>;
-    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.Int;
-}>, {}>;
-
-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 interface ResolvedModeInput {
-    readonly mode: 'machine' | 'human';
-    readonly signal: 'flag' | 'env' | 'tty' | 'agent' | 'tool';
-}
-
-export declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
-
-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 RunEventDrain extends RunEventDrain_base {}
-
-declare const RunEventDrain_base: Context.ServiceClass<RunEventDrain, "@systemfsoftware/stryker-js/run-event-stream/RunEventDrain", RunEventDrainShape>;
-
-export declare const RunEventDrainLive: Layer.Layer<RunEventDrain, never, Stdio.Stdio>;
-
-declare interface RunEventDrainShape {
-    readonly drainFramed: FramedDrain;
-    readonly setProgressStreamFile: (fileName: string) => Effect.Effect<void, never, never>;
-}
-
-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 interface RunEventStream {
-    readonly queue: Queue.Queue<RunEvent, Cause.Done>;
-    readonly runId: string;
-    readonly startedAt: number;
-    readonly isOpen: Effect.Effect<boolean, never, never>;
-    readonly ensureOpen: (openResolved: ResolvedModeInput) => Effect.Effect<void, never, never>;
-    readonly open: Effect.Effect<void, never, never>;
-    readonly closeAndDrain: Effect.Effect<void, never, never>;
-}
-
-export declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>>, S.String, never, never>;
-
-export declare type RunEventWireLine = typeof RunEventWireLine.Type;
-
-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.Int;
-    readonly total: S.Int;
-}>, {}>;
-
-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 { S }
-
-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: <A = unknown, E = unknown>(exit: Exit.Exit<A, E>, 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.decodeTo<S.declare<{
-        readonly high: number;
-        readonly low: number;
-        readonly break: number | null;
-    }, {
-        readonly high: number;
-        readonly low: number;
-        readonly break: number | null;
-    }>, 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, 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 SUPPORTED_CONFIG_FILE_NAMES: readonly string[];
-
-export declare interface SurvivedMutantRunResult {
-    readonly status: 'survived';
-    readonly nrOfTests: number;
-}
-
-export declare const survivorsPriorReport: S.optionalKey<S.String>;
-
-declare interface SwitchCase$1 extends Span$1 {
-    type: "SwitchCase";
-    test: Expression$1 | null;
-    consequent: Array<Statement$1>;
-    parent?: Node$1;
-}
-
-declare interface SwitchStatement$1 extends Span$1 {
-    type: "SwitchStatement";
-    discriminant: Expression$1;
-    cases: Array<SwitchCase$1>;
-    parent?: Node$1;
-}
-
-declare interface TaggedTemplateExpression$1 extends Span$1 {
-    type: "TaggedTemplateExpression";
-    tag: Expression$1;
-    typeArguments?: TSTypeParameterInstantiation$1 | null;
-    quasi: TemplateLiteral$1;
-    parent?: Node$1;
-}
-
-declare interface TemplateElement$1 extends Span$1 {
-    type: "TemplateElement";
-    value: TemplateElementValue;
-    tail: boolean;
-    parent?: Node$1;
-}
-
-declare interface TemplateElementValue {
-    raw: string;
-    cooked: string | null;
-}
-
-declare interface TemplateLiteral$1 extends Span$1 {
-    type: "TemplateLiteral";
-    quasis: Array<TemplateElement$1>;
-    expressions: Array<Expression$1>;
-    parent?: Node$1;
-}
-
-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>;
-}
-
-export declare type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
-
-/** 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 interface TestRunnerCapabilities {
-    readonly reloadEnvironment: boolean;
-}
-
-export declare type TestRunnerConfig = typeof TestRunnerConfigSchema.Type;
-
-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>>;
-}>]>;
-
-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>;
-
-declare interface ThisExpression$1 extends Span$1 {
-    type: "ThisExpression";
-    parent?: Node$1;
-}
-
-declare interface ThrowStatement$1 extends Span$1 {
-    type: "ThrowStatement";
-    argument: Expression$1;
-    parent?: Node$1;
-}
-
-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 {}
-
-declare const TraceContextMiddleware_base: RpcMiddleware.ServiceClass<TraceContextMiddleware, "@systemfsoftware/stryker-js-plugin-interface/TraceContextMiddleware", typeof PropagatedTrace, Schema.Never, never, never, true>;
-
-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>>;
-
-declare interface TryStatement$1 extends Span$1 {
-    type: "TryStatement";
-    block: BlockStatement$1;
-    handler: CatchClause$1 | null;
-    finalizer: BlockStatement$1 | null;
-    parent?: Node$1;
-}
-
-declare type TSAccessibility = "private" | "protected" | "public";
-
-declare interface TSAnyKeyword extends Span$1 {
-    type: "TSAnyKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSArrayType$1 extends Span$1 {
-    type: "TSArrayType";
-    elementType: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSAsExpression$1 extends Span$1 {
-    type: "TSAsExpression";
-    expression: Expression$1;
-    typeAnnotation: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSBigIntKeyword extends Span$1 {
-    type: "TSBigIntKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSBooleanKeyword extends Span$1 {
-    type: "TSBooleanKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSCallSignatureDeclaration$1 extends Span$1 {
-    type: "TSCallSignatureDeclaration";
-    typeParameters: TSTypeParameterDeclaration$1 | null;
-    params: ParamPattern$1[];
-    returnType: TSTypeAnnotation$1 | null;
-    parent?: Node$1;
-}
-
-declare interface TSClassImplements extends Span$1 {
-    type: "TSClassImplements";
-    expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
-    typeArguments: TSTypeParameterInstantiation$1 | null;
-    parent?: Node$1;
-}
-
-declare interface TSConditionalType$1 extends Span$1 {
-    type: "TSConditionalType";
-    checkType: TSType$1;
-    extendsType: TSType$1;
-    trueType: TSType$1;
-    falseType: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSConstructorType$1 extends Span$1 {
-    type: "TSConstructorType";
-    abstract: boolean;
-    typeParameters: TSTypeParameterDeclaration$1 | null;
-    params: ParamPattern$1[];
-    returnType: TSTypeAnnotation$1;
-    parent?: Node$1;
-}
-
-declare interface TSConstructSignatureDeclaration$1 extends Span$1 {
-    type: "TSConstructSignatureDeclaration";
-    typeParameters: TSTypeParameterDeclaration$1 | null;
-    params: ParamPattern$1[];
-    returnType: TSTypeAnnotation$1 | null;
-    parent?: Node$1;
-}
-
-declare interface TSEnumBody extends Span$1 {
-    type: "TSEnumBody";
-    members: Array<TSEnumMember>;
-    parent?: Node$1;
-}
-
-declare interface TSEnumDeclaration$1 extends Span$1 {
-    type: "TSEnumDeclaration";
-    id: BindingIdentifier$1;
-    body: TSEnumBody;
-    const: boolean;
-    declare: boolean;
-    parent?: Node$1;
-}
-
-declare interface TSEnumMember extends Span$1 {
-    type: "TSEnumMember";
-    id: TSEnumMemberName;
-    initializer: Expression$1 | null;
-    computed: boolean;
-    parent?: Node$1;
-}
-
-declare type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
-
-declare interface TSExportAssignment$1 extends Span$1 {
-    type: "TSExportAssignment";
-    expression: Expression$1;
-    parent?: Node$1;
-}
-
-declare interface TSExternalModuleReference extends Span$1 {
-    type: "TSExternalModuleReference";
-    expression: StringLiteral$1;
-    parent?: Node$1;
-}
-
-declare interface TSFunctionType$1 extends Span$1 {
-    type: "TSFunctionType";
-    typeParameters: TSTypeParameterDeclaration$1 | null;
-    params: ParamPattern$1[];
-    returnType: TSTypeAnnotation$1;
-    parent?: Node$1;
-}
-
-declare interface TSGlobalDeclaration extends Span$1 {
-    type: "TSModuleDeclaration";
-    id: IdentifierName$1;
-    body: TSModuleBlock$1;
-    kind: "global";
-    declare: boolean;
-    global: true;
-    parent?: Node$1;
-}
-
-declare interface TSImportEqualsDeclaration$1 extends Span$1 {
-    type: "TSImportEqualsDeclaration";
-    id: BindingIdentifier$1;
-    moduleReference: TSModuleReference;
-    importKind: ImportOrExportKind;
-    parent?: Node$1;
-}
-
-declare interface TSImportType$1 extends Span$1 {
-    type: "TSImportType";
-    source: StringLiteral$1;
-    options: ObjectExpression$1 | null;
-    qualifier: TSImportTypeQualifier | null;
-    typeArguments: TSTypeParameterInstantiation$1 | null;
-    parent?: Node$1;
-}
-
-declare interface TSImportTypeQualifiedName extends Span$1 {
-    type: "TSQualifiedName";
-    left: TSImportTypeQualifier;
-    right: IdentifierName$1;
-    parent?: Node$1;
-}
-
-declare type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
-
-declare interface TSIndexedAccessType$1 extends Span$1 {
-    type: "TSIndexedAccessType";
-    objectType: TSType$1;
-    indexType: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSIndexSignature$1 extends Span$1 {
-    type: "TSIndexSignature";
-    parameters: Array<TSIndexSignatureName>;
-    typeAnnotation: TSTypeAnnotation$1;
-    readonly: boolean;
-    static: boolean;
-    accessibility: null;
-    parent?: Node$1;
-}
-
-declare interface TSIndexSignatureName extends Span$1 {
-    type: "Identifier";
-    decorators: [];
-    name: string;
-    optional: false;
-    typeAnnotation: TSTypeAnnotation$1;
-    parent?: Node$1;
-}
-
-declare interface TSInferType$1 extends Span$1 {
-    type: "TSInferType";
-    typeParameter: TSTypeParameter;
-    parent?: Node$1;
-}
-
-declare interface TSInstantiationExpression$1 extends Span$1 {
-    type: "TSInstantiationExpression";
-    expression: Expression$1;
-    typeArguments: TSTypeParameterInstantiation$1;
-    parent?: Node$1;
-}
-
-declare interface TSInterfaceBody$1 extends Span$1 {
-    type: "TSInterfaceBody";
-    body: Array<TSSignature>;
-    parent?: Node$1;
-}
-
-declare interface TSInterfaceDeclaration$1 extends Span$1 {
-    type: "TSInterfaceDeclaration";
-    id: BindingIdentifier$1;
-    typeParameters: TSTypeParameterDeclaration$1 | null;
-    extends: Array<TSInterfaceHeritage>;
-    body: TSInterfaceBody$1;
-    declare: boolean;
-    parent?: Node$1;
-}
-
-declare interface TSInterfaceHeritage extends Span$1 {
-    type: "TSInterfaceHeritage";
-    expression: Expression$1;
-    typeArguments: TSTypeParameterInstantiation$1 | null;
-    parent?: Node$1;
-}
-
-declare interface TSIntersectionType$1 extends Span$1 {
-    type: "TSIntersectionType";
-    types: Array<TSType$1>;
-    parent?: Node$1;
-}
-
-declare interface TSIntrinsicKeyword extends Span$1 {
-    type: "TSIntrinsicKeyword";
-    parent?: Node$1;
-}
-
-declare type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
-
-declare interface TSLiteralType$1 extends Span$1 {
-    type: "TSLiteralType";
-    literal: TSLiteral;
-    parent?: Node$1;
-}
-
-declare interface TSMappedType$1 extends Span$1 {
-    type: "TSMappedType";
-    key: BindingIdentifier$1;
-    constraint: TSType$1;
-    nameType: TSType$1 | null;
-    typeAnnotation: TSType$1 | null;
-    optional: TSMappedTypeModifierOperator | false;
-    readonly: TSMappedTypeModifierOperator | null;
-    parent?: Node$1;
-}
-
-declare type TSMappedTypeModifierOperator = true | "+" | "-";
-
-declare interface TSMethodSignature$1 extends Span$1 {
-    type: "TSMethodSignature";
-    key: PropertyKey_2;
-    computed: boolean;
-    optional: boolean;
-    kind: TSMethodSignatureKind;
-    typeParameters: TSTypeParameterDeclaration$1 | null;
-    params: ParamPattern$1[];
-    returnType: TSTypeAnnotation$1 | null;
-    accessibility: null;
-    readonly: false;
-    static: false;
-    parent?: Node$1;
-}
-
-declare type TSMethodSignatureKind = "method" | "get" | "set";
-
-declare interface TSModuleBlock$1 extends Span$1 {
-    type: "TSModuleBlock";
-    body: Array<Directive | Statement$1>;
-    parent?: Node$1;
-}
-
-declare interface TSModuleDeclaration$1 extends Span$1 {
-    type: "TSModuleDeclaration";
-    id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
-    body: TSModuleBlock$1 | null;
-    kind: TSModuleDeclarationKind;
-    declare: boolean;
-    global: false;
-    parent?: Node$1;
-}
-
-declare type TSModuleDeclarationKind = "module" | "namespace";
-
-declare type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
-
-declare interface TSNamedTupleMember$1 extends Span$1 {
-    type: "TSNamedTupleMember";
-    label: IdentifierName$1;
-    elementType: TSTupleElement;
-    optional: boolean;
-    parent?: Node$1;
-}
-
-declare interface TSNamespaceExportDeclaration$1 extends Span$1 {
-    type: "TSNamespaceExportDeclaration";
-    id: IdentifierName$1;
-    parent?: Node$1;
-}
-
-declare interface TSNeverKeyword extends Span$1 {
-    type: "TSNeverKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSNonNullExpression$1 extends Span$1 {
-    type: "TSNonNullExpression";
-    expression: Expression$1;
-    parent?: Node$1;
-}
-
-declare interface TSNullKeyword extends Span$1 {
-    type: "TSNullKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSNumberKeyword extends Span$1 {
-    type: "TSNumberKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSObjectKeyword extends Span$1 {
-    type: "TSObjectKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSOptionalType$1 extends Span$1 {
-    type: "TSOptionalType";
-    typeAnnotation: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSParameterProperty extends Span$1 {
-    type: "TSParameterProperty";
-    accessibility: TSAccessibility | null;
-    decorators: Array<Decorator$1>;
-    override: boolean;
-    parameter: FormalParameter;
-    readonly: boolean;
-    static: boolean;
-    parent?: Node$1;
-}
-
-declare interface TSParenthesizedType$1 extends Span$1 {
-    type: "TSParenthesizedType";
-    typeAnnotation: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSPropertySignature$1 extends Span$1 {
-    type: "TSPropertySignature";
-    computed: boolean;
-    optional: boolean;
-    readonly: boolean;
-    key: PropertyKey_2;
-    typeAnnotation: TSTypeAnnotation$1 | null;
-    accessibility: null;
-    static: false;
-    parent?: Node$1;
-}
-
-declare interface TSQualifiedName$1 extends Span$1 {
-    type: "TSQualifiedName";
-    left: TSTypeName;
-    right: IdentifierName$1;
-    parent?: Node$1;
-}
-
-declare interface TSRestType$1 extends Span$1 {
-    type: "TSRestType";
-    typeAnnotation: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSSatisfiesExpression$1 extends Span$1 {
-    type: "TSSatisfiesExpression";
-    expression: Expression$1;
-    typeAnnotation: TSType$1;
-    parent?: Node$1;
-}
-
-declare type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
-
-declare interface TSStringKeyword extends Span$1 {
-    type: "TSStringKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSSymbolKeyword extends Span$1 {
-    type: "TSSymbolKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSTemplateLiteralType$1 extends Span$1 {
-    type: "TSTemplateLiteralType";
-    quasis: Array<TemplateElement$1>;
-    types: Array<TSType$1>;
-    parent?: Node$1;
-}
-
-declare interface TSThisParameter extends Span$1 {
-    type: "Identifier";
-    decorators: [];
-    name: "this";
-    optional: false;
-    typeAnnotation: TSTypeAnnotation$1 | null;
-    parent?: Node$1;
-}
-
-declare interface TSThisType extends Span$1 {
-    type: "TSThisType";
-    parent?: Node$1;
-}
-
-declare type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
-
-declare interface TSTupleType$1 extends Span$1 {
-    type: "TSTupleType";
-    elementTypes: Array<TSTupleElement>;
-    parent?: Node$1;
-}
-
-declare type TSType$1 = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType$1 | TSConditionalType$1 | TSConstructorType$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSTemplateLiteralType$1 | TSThisType | TSTupleType$1 | TSTypeLiteral | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUnionType$1 | TSParenthesizedType$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType;
-
-declare interface TSTypeAliasDeclaration$1 extends Span$1 {
-    type: "TSTypeAliasDeclaration";
-    id: BindingIdentifier$1;
-    typeParameters: TSTypeParameterDeclaration$1 | null;
-    typeAnnotation: TSType$1;
-    declare: boolean;
-    parent?: Node$1;
-}
-
-declare interface TSTypeAnnotation$1 extends Span$1 {
-    type: "TSTypeAnnotation";
-    typeAnnotation: TSType$1;
-    parent?: Node$1;
-}
-
-declare interface TSTypeAssertion$1 extends Span$1 {
-    type: "TSTypeAssertion";
-    typeAnnotation: TSType$1;
-    expression: Expression$1;
-    parent?: Node$1;
-}
-
-declare interface TSTypeLiteral extends Span$1 {
-    type: "TSTypeLiteral";
-    members: Array<TSSignature>;
-    parent?: Node$1;
-}
-
-declare type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
-
-declare interface TSTypeOperator$1 extends Span$1 {
-    type: "TSTypeOperator";
-    operator: TSTypeOperatorOperator;
-    typeAnnotation: TSType$1;
-    parent?: Node$1;
-}
-
-declare type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
-
-declare interface TSTypeParameter extends Span$1 {
-    type: "TSTypeParameter";
-    name: BindingIdentifier$1;
-    constraint: TSType$1 | null;
-    default: TSType$1 | null;
-    in: boolean;
-    out: boolean;
-    const: boolean;
-    parent?: Node$1;
-}
-
-declare interface TSTypeParameterDeclaration$1 extends Span$1 {
-    type: "TSTypeParameterDeclaration";
-    params: Array<TSTypeParameter>;
-    parent?: Node$1;
-}
-
-declare interface TSTypeParameterInstantiation$1 extends Span$1 {
-    type: "TSTypeParameterInstantiation";
-    params: Array<TSType$1>;
-    parent?: Node$1;
-}
-
-declare interface TSTypePredicate$1 extends Span$1 {
-    type: "TSTypePredicate";
-    parameterName: TSTypePredicateName;
-    asserts: boolean;
-    typeAnnotation: TSTypeAnnotation$1 | null;
-    parent?: Node$1;
-}
-
-declare type TSTypePredicateName = IdentifierName$1 | TSThisType;
-
-declare interface TSTypeQuery$1 extends Span$1 {
-    type: "TSTypeQuery";
-    exprName: TSTypeQueryExprName;
-    typeArguments: TSTypeParameterInstantiation$1 | null;
-    parent?: Node$1;
-}
-
-declare type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
-
-declare interface TSTypeReference$1 extends Span$1 {
-    type: "TSTypeReference";
-    typeName: TSTypeName;
-    typeArguments: TSTypeParameterInstantiation$1 | null;
-    parent?: Node$1;
-}
-
-declare interface TSUndefinedKeyword extends Span$1 {
-    type: "TSUndefinedKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSUnionType$1 extends Span$1 {
-    type: "TSUnionType";
-    types: Array<TSType$1>;
-    parent?: Node$1;
-}
-
-declare interface TSUnknownKeyword extends Span$1 {
-    type: "TSUnknownKeyword";
-    parent?: Node$1;
-}
-
-declare interface TSVoidKeyword extends Span$1 {
-    type: "TSVoidKeyword";
-    parent?: Node$1;
-}
-
-declare const TypeId: '~stryker/mutation-run/StageError';
-
-declare interface UnaryExpression$1 extends Span$1 {
-    type: "UnaryExpression";
-    operator: UnaryOperator;
-    argument: Expression$1;
-    prefix: true;
-    parent?: Node$1;
-}
-
-declare type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
-
-export declare interface UnserializableDescription {
-    path: string[];
-    reason: string;
-}
-
-declare interface UpdateExpression$1 extends Span$1 {
-    type: "UpdateExpression";
-    operator: UpdateOperator;
-    prefix: boolean;
-    argument: SimpleAssignmentTarget$1;
-    parent?: Node$1;
-}
-
-declare type UpdateOperator = "++" | "--";
-
-declare interface V8IntrinsicExpression extends Span$1 {
-    type: "V8IntrinsicExpression";
-    name: IdentifierName$1;
-    arguments: Array<Argument$1>;
-    parent?: Node$1;
-}
-
-export declare function validateOptions<A = unknown>(options: Record<string, A>, schema: ValidationSchemaDocument): Effect.Effect<StrykerOptions, ConfigError>;
-
-export declare type ValidationSchemaDocument<A = unknown> = {
-    readonly properties?: A;
-    readonly [key: string]: A;
-};
-
-declare interface VariableDeclaration$1 extends Span$1 {
-    type: "VariableDeclaration";
-    kind: VariableDeclarationKind;
-    declarations: Array<VariableDeclarator$1>;
-    declare?: boolean;
-    parent?: Node$1;
-}
-
-declare type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
-
-declare interface VariableDeclarator$1 extends Span$1 {
-    type: "VariableDeclarator";
-    id: BindingPattern$1;
-    init: Expression$1 | null;
-    definite?: boolean;
-    parent?: Node$1;
-}
-
-export declare const VERDICT_ENVELOPE_SCHEMA_VERSION = "1.1";
-
-export declare type VerdictCounts = Metrics;
-
-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: Metrics;
-    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", {
-    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"]>;
-    readonly score: S.NullOr<S.Finite>;
-    readonly thresholds: S.decodeTo<S.declare<{
-        readonly high: number;
-        readonly low: number;
-        readonly break: number | null;
-    }, {
-        readonly high: number;
-        readonly low: number;
-        readonly break: number | null;
-    }>, S.Struct<{
-        readonly high: S.Finite;
-        readonly low: S.Finite;
-        readonly break: S.NullOr<S.Finite>;
-    }>, never, never>;
-    readonly reportFile: S.NullOr<S.String>;
-    readonly counts: typeof Metrics;
-    readonly mutants: S.$Array<S.Struct<{
-        readonly id: S.String;
-        readonly file: S.String;
-        readonly location: S.Struct<{
-            readonly start: S.Struct<{
-                readonly line: S.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 status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
-    }>>;
-}>, {}>;
-
-export declare interface VerdictThresholds {
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
-}
-
-declare interface VmFileUrl {
-    readonly href: string;
-}
-
-export declare interface VmPlatform {
-    readonly moduleBuiltin: HarnessModuleBuiltin;
-    readonly pathToFileURL: (path: string) => VmFileUrl;
-}
-
-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 const vmTestRunner: (config: VmTestRunnerConfig) => Effect.Effect<PooledTestRunner, TestRunnerFailed, VmRunner>;
-
-export declare interface VmTestRunnerConfig {
-    readonly testFiles: readonly string[];
-    readonly sandboxWorkingDirectory?: 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 { }
+import { c as mod_d_exports$2$2, d as Ignorer, f as Node_2, i as mod_d_exports$4$1, l as mod_d_exports$3$1, n as mod_d_exports$2$1, o as mod_d_exports$6$1, t as mod_d_exports$6, u as Framework } from "./index-CMCCQdTd.mjs";
+import { a as StrykerConfig, i as Primitive, n as Immutable, r as ImmutablePrimitive } from "./stryker-config.schema-lr7GMjpY.mjs";
+import { A as VerdictReached, D as SkippedReported, E as SkippedFileRow, S as RunPhase, T as RunTerminalEvent, _ as PluginsReported, a as FormatRegistryRow, b as RunFailed, c as Heartbeat, f as OutputMode, g as PluginFailureReason, i as FormatRegistryResolved, l as HelpRendered, m as PlanKnown, n as StageError, o as FrameworkContributionRow, p as PhaseEntered, r as FormatClaimShadowingRow, s as FrameworkModuleRow, u as ModeSignal, w as RunStarted, x as RunMutantTested, y as RunEvent } from "./Run.schema-CUpTIyrj.mjs";
+import { $ as ConfigError, A as ReporterWorkerClient, B as ProjectFile, C as WorkerPluginSource, D as TestCoverage, E as IdGeneratorShape, F as WorkerLauncherShape, G as ResolvedModeInput, H as RunEventDrainLive, I as WorkerSpawnParams, J as OutputMode$1, K as StrykerError, L as SpawnedSocketWorker, M as reporterWorkerFactory, N as spawnReporterWorker, O as REPORTER_EVENT_BATCH_BOUND, P as WorkerLauncher, Q as RunIdentityShape, R as make, S as WorkerPluginDescriptor, T as IdGenerator, U as RunEventStream, V as RunEventDrain, W as makeRunEventStream, X as RunEvents, Y as ResolvedMode, Z as RunIdentity, _ as LoadedPlugins, a as StageServices, at as OutOfMemoryError, b as PluginKind, c as DryRunDone, ct as WorkerExit, d as PrepareExecutorArgs, et as ConfigFileInvalidError, f as AnyPluginDescriptor, g as EvaluatorPluginSource, h as EvaluatorPluginDescriptor, i as RunStageServices, it as ChildProcessCrashedError, j as SpawnReporterWorkerParams, k as ReporterStage, l as InstrumentDone, m as AnyWorkerPluginSource, n as RunEnvironmentShape, nt as ConfigFileUnreadableError, o as WiredRunLayer, ot as WorkerBootError, p as AnyWorkerPluginDescriptor, q as ModeSignal$1, r as EnginePorts, rt as ConfigFileUnsupportedError, s as MutationTestDone, st as WorkerBootTimeoutError, t as RunEnvironment, tt as ConfigFileNotFoundError, u as PrepareDone, v as PluginDescriptor, w as SandboxHandle, x as PluginSource, y as PluginDescriptorOf, z as Project } from "./RunEnvironment.service-zgwzyXpO.mjs";
+import { Cell, Sandwich, Workflow } from "@systemfsoftware/effect-cell-types";
+import * as S from "effect/Schema";
+import * as Effect from "effect/Effect";
+import { Pipeable } from "effect/Pipeable";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import "effect/Cause";
+import * as Path from "effect/Path";
+import * as FileSystem from "effect/FileSystem";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import * as Layer from "effect/Layer";
+import "effect/Queue";
+import * as Scope from "effect/Scope";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import "effect/DateTime";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as Socket from "effect/unstable/socket/Socket";
+import { PlatformError } from "effect/PlatformError";
+//#region src/admit-checker-answer.workflow.d.ts
+declare const CheckerAnsweredUnrequested_base: S.Class<CheckerAnsweredUnrequested, S.TaggedStruct<"CheckerAnsweredUnrequested", {
+  readonly checkerName: S.String;
+  readonly phase: S.Literals<readonly ["check", "group"]>;
+  readonly unrequestedIds: S.$Array<S.String>;
+  readonly requestedIds: S.$Array<S.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class CheckerAnsweredUnrequested extends CheckerAnsweredUnrequested_base {}
+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>;
+}>, import("effect/Cause").YieldableError>;
+declare class CheckerSkippedRequested extends CheckerSkippedRequested_base {}
+type CheckerContractBroken = CheckerAnsweredUnrequested | CheckerSkippedRequested;
+//#endregion
+//#region src/Checker/Checker.handle.d.ts
+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.
+ */
+interface CheckerResourceService {
+  readonly check: (checkerName: string, mutants: readonly mod_d_exports$6.CheckerMutantWire[]) => Effect.Effect<Record<string, mod_d_exports$6.CheckResult>, CheckerCrash | mod_d_exports$6.CheckerFailed>;
+  readonly group: (checkerName: string, mutants: readonly mod_d_exports$6.CheckerMutantWire[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash | mod_d_exports$6.CheckerFailed>;
+}
+//#endregion
+//#region src/Checker/Checker.cell.d.ts
+declare const checkGroupedPlans: {
+  (checker: CheckerResourceService, checkerName: string, plans: readonly mod_d_exports$3$1.RunPlan[]): Effect.Effect<readonly (readonly [mod_d_exports$3$1.RunPlan, mod_d_exports$6.CheckResult])[], CheckerCrash | mod_d_exports$6.CheckerFailed | CheckerContractBroken>;
+  (checkerName: string, plans: readonly mod_d_exports$3$1.RunPlan[]): (checker: CheckerResourceService) => Effect.Effect<readonly (readonly [mod_d_exports$3$1.RunPlan, mod_d_exports$6.CheckResult])[], CheckerCrash | mod_d_exports$6.CheckerFailed | CheckerContractBroken>;
+};
+declare namespace mod_d_exports {
+  export { CheckerAnsweredUnrequested, CheckerContractBroken, CheckerCrash, CheckerResourceService, CheckerSkippedRequested, checkGroupedPlans };
+}
+//#endregion
+//#region src/Config.schema.d.ts
+declare const ConfigDocumentSchema: S.$Record<S.String, S.Unknown>;
+declare const ImportedModuleSchema: S.Struct<{
+  readonly default: S.optional<S.Unknown>;
+}>;
+declare const ReadConfigCommand_base: S.Class<ReadConfigCommand, S.TaggedStruct<"ReadConfigCommand", {
+  readonly cliOptions: S.$Record<S.String, S.Unknown>;
+  readonly basePath: S.String;
+}>, {}>;
+declare class ReadConfigCommand extends ReadConfigCommand_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>;
+}>, {}>;
+declare class MergeCommand extends MergeCommand_base {}
+declare const MergeResult_base: S.Class<MergeResult, S.TaggedStruct<"MergeResult", {
+  readonly merged: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+declare class MergeResult extends MergeResult_base {}
+declare const ExtendsStepDocumentSchema: S.Struct<{
+  readonly path: S.String;
+  readonly options: S.$Record<S.String, S.Unknown>;
+}>;
+type ExtendsStepDocument = typeof ExtendsStepDocumentSchema.Type;
+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>;
+  }>>;
+}>;
+type ExtendsStepState = typeof ExtendsStepStateSchema.Type;
+type ExtendsRefusalReason = 'cycle' | 'non-string-extends';
+declare const ExtendsStepDone_base: S.Class<ExtendsStepDone, S.TaggedStruct<"done", {
+  readonly options: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+declare class ExtendsStepDone extends ExtendsStepDone_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>;
+    }>>;
+  }>;
+}>, {}>;
+declare class ExtendsStepRead extends ExtendsStepRead_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>;
+    }>>;
+  }>;
+}>, {}>;
+declare class ExtendsStepResolve extends ExtendsStepResolve_base {}
+declare const ExtendsStepRefused_base: S.Class<ExtendsStepRefused, S.TaggedStruct<"refused", {
+  readonly reason: S.Literals<readonly ["cycle", "non-string-extends"]>;
+  readonly file: S.String;
+}>, {}>;
+declare class ExtendsStepRefused extends ExtendsStepRefused_base {}
+type ExtendsStepDecision = ExtendsStepDone | ExtendsStepRead | ExtendsStepResolve | ExtendsStepRefused;
+declare const survivorsPriorReport: S.optionalKey<S.String>;
+declare const extendsPropertySchema: S.optionalKey<S.String>;
+declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
+  readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+  readonly buildCommand: S.optionalKey<S.String>;
+  readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
+    readonly plugin: S.declare<string, string>;
+    readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+    readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+  }>>, never>;
+  readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly concurrency: S.optionalKey<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>;
+    readonly optInMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  }>, never>;
+  readonly packageManager: S.optionalKey<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+  readonly plugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
+  readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, 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.declare<string, string>;
+    readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+    readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+  }>]>, never>;
+  readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  readonly thresholds: S.withDecodingDefaultKey<S.decodeTo<S.declare<{
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+  }, {
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+  }>, 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, 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.declare<string, 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>]>;
+//#endregion
+//#region src/matching.schema.d.ts
+declare const FileMatcher_base: S.Class<FileMatcher, S.Struct<{
+  readonly pattern: S.Union<readonly [S.Boolean, S.String]>;
+  readonly allowHiddenFiles: S.Boolean;
+}>, {}>;
+declare class FileMatcher extends FileMatcher_base {
+  matches(pathService: Path.Path, fileName: string): boolean;
+}
+//#endregion
+//#region src/run/resolve-config.workflow.d.ts
+declare const LoadConfigDecisionTypeId: unique symbol;
+type LoadConfigDecisionTypeId = typeof LoadConfigDecisionTypeId;
+declare const ConfigFromFile_base: S.Class<ConfigFromFile, S.TaggedStruct<"ConfigFromFile", {
+  readonly options: S.toType<S.StructWithRest<S.Struct<{
+    readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly buildCommand: S.optionalKey<S.String>;
+    readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
+      readonly plugin: S.declare<string, string>;
+      readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+      readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+    }>>, never>;
+    readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly concurrency: S.optionalKey<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>;
+      readonly optInMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    }>, never>;
+    readonly packageManager: S.optionalKey<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+    readonly plugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
+    readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, 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.declare<string, string>;
+      readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+      readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+    }>]>, never>;
+    readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly thresholds: S.withDecodingDefaultKey<S.decodeTo<S.declare<{
+      readonly high: number;
+      readonly low: number;
+      readonly break: number | null;
+    }, {
+      readonly high: number;
+      readonly low: number;
+      readonly break: number | null;
+    }>, 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, 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.declare<string, string>>, never>;
+    readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>>;
+}>, {}>;
+declare class ConfigFromFile extends ConfigFromFile_base {
+  readonly [LoadConfigDecisionTypeId]: symbol;
+  static readonly [Workflow.InstrumentationBrand]: {};
+}
+declare const ConfigFromDefaults_base: S.Class<ConfigFromDefaults, S.TaggedStruct<"ConfigFromDefaults", {
+  readonly options: S.toType<S.StructWithRest<S.Struct<{
+    readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly buildCommand: S.optionalKey<S.String>;
+    readonly checkers: S.withDecodingDefaultKey<S.$Array<S.Struct<{
+      readonly plugin: S.declare<string, string>;
+      readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+      readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+    }>>, never>;
+    readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly concurrency: S.optionalKey<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>;
+      readonly optInMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    }>, never>;
+    readonly packageManager: S.optionalKey<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+    readonly plugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, string>>, never>;
+    readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.declare<string, 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.declare<string, string>;
+      readonly nodeArgs: S.optionalKey<S.$Array<S.String>>;
+      readonly options: S.optionalKey<S.$Record<S.String, S.Unknown>>;
+    }>]>, never>;
+    readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly thresholds: S.withDecodingDefaultKey<S.decodeTo<S.declare<{
+      readonly high: number;
+      readonly low: number;
+      readonly break: number | null;
+    }, {
+      readonly high: number;
+      readonly low: number;
+      readonly break: number | null;
+    }>, 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, 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.declare<string, string>>, never>;
+    readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+  }>, readonly [S.$Record<S.String, S.Unknown>]>>;
+}>, {}>;
+declare class ConfigFromDefaults extends ConfigFromDefaults_base {
+  readonly [LoadConfigDecisionTypeId]: symbol;
+  static readonly [Workflow.InstrumentationBrand]: {};
+}
+declare const LoadConfigCommand_base: S.Class<LoadConfigCommand, S.TaggedStruct<"LoadConfigCommand", {
+  readonly document: S.$Record<S.String, S.Unknown>;
+  readonly fileFound: S.Boolean;
+}>, {}>;
+declare class LoadConfigCommand extends LoadConfigCommand_base {
+  static readonly [Workflow.InstrumentationBrand]: {};
+}
+//#endregion
+//#region src/run/load-config.cell.d.ts
+declare function describeErrors(error: S.SchemaError): readonly string[];
+declare function importModule<A = unknown>(moduleName: string): Effect.Effect<A, StrykerError>;
+declare const initialExtendsStepState: ExtendsStepState;
+declare const mergeConfigs: ((child: mod_d_exports$2$1.PartialStrykerOptions) => (parent: mod_d_exports$2$1.PartialStrykerOptions) => mod_d_exports$2$1.PartialStrykerOptions) & ((parent: mod_d_exports$2$1.PartialStrykerOptions, child: mod_d_exports$2$1.PartialStrykerOptions) => mod_d_exports$2$1.PartialStrykerOptions);
+declare const decideExtendsStep: ((document: mod_d_exports$2$1.PartialStrykerOptions, file: string, pathService: Path.Path) => (state: ExtendsStepState) => ExtendsStepDecision) & ((state: ExtendsStepState, document: mod_d_exports$2$1.PartialStrykerOptions, file: string, pathService: Path.Path) => ExtendsStepDecision);
+type ValidationSchemaDocument<A = unknown> = {
+  readonly properties?: A;
+  readonly [key: string]: A;
+};
+declare const forkCoreSchema: import("effect/JsonSchema").JsonSchema;
+declare const validateOptions: (<A = unknown>(schema: ValidationSchemaDocument) => (options: Record<string, A>) => Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigError>) & (<A = unknown>(options: Record<string, A>, schema: ValidationSchemaDocument) => Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigError>);
+interface ConfigInvocation {
+  readonly command: 'run' | 'merge-reports';
+  readonly mode: OutputMode$1;
+}
+declare const readConfig: {
+  (invocation: ConfigInvocation): (cliOptions: mod_d_exports$2$1.PartialStrykerOptions) => Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigFileNotFoundError | ConfigFileUnreadableError | ConfigFileInvalidError | ConfigFileUnsupportedError, FileSystem.FileSystem | Path.Path>;
+  (cliOptions: mod_d_exports$2$1.PartialStrykerOptions, invocation: ConfigInvocation): Effect.Effect<mod_d_exports$2$1.StrykerOptions, ConfigFileNotFoundError | ConfigFileUnreadableError | ConfigFileInvalidError | ConfigFileUnsupportedError, FileSystem.FileSystem | Path.Path>;
+};
+declare const loadConfigCell: Sandwich.WrittenFrom<{
+  readonly cliOptions: mod_d_exports$2$1.PartialStrykerOptions;
+  readonly targetMutatePatterns: readonly string[] | undefined;
+}, ConfigFileInvalidError | ConfigFileNotFoundError | ConfigFileUnreadableError | ConfigFileUnsupportedError, FileSystem.FileSystem | Path.Path | RunEnvironment | RunEvents, S.Union<readonly [typeof ConfigFromFile, typeof ConfigFromDefaults]>, {
+  ConfigFromFile: ({ options }: {
+    readonly _tag: "ConfigFromFile";
+    readonly options: {
+      readonly [x: string]: unknown;
+      readonly allowConsoleColors: boolean;
+      readonly buildCommand?: string;
+      readonly checkers: readonly {
+        readonly plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      }[];
+      readonly checkerNodeArgs: readonly string[];
+      readonly concurrency?: string | number;
+      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 optInMutations: readonly string[];
+      };
+      readonly packageManager?: "npm" | "pnpm" | "yarn";
+      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 plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      };
+      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[];
+    };
+  }, raw: LoadConfigCommand & {
+    targetMutatePatterns: readonly string[] | undefined;
+    basePath: string;
+  }) => Effect.Effect<{
+    options: {
+      readonly [x: string]: unknown;
+      readonly allowConsoleColors: boolean;
+      readonly buildCommand?: string;
+      readonly checkers: readonly {
+        readonly plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      }[];
+      readonly checkerNodeArgs: readonly string[];
+      readonly concurrency?: string | number;
+      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 optInMutations: readonly string[];
+      };
+      readonly packageManager?: "npm" | "pnpm" | "yarn";
+      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 plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      };
+      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[];
+    };
+    targetMutatePatterns: readonly string[] | undefined;
+    basePath: string;
+  }, never, never>;
+  ConfigFromDefaults: ({ options }: {
+    readonly _tag: "ConfigFromDefaults";
+    readonly options: {
+      readonly [x: string]: unknown;
+      readonly allowConsoleColors: boolean;
+      readonly buildCommand?: string;
+      readonly checkers: readonly {
+        readonly plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      }[];
+      readonly checkerNodeArgs: readonly string[];
+      readonly concurrency?: string | number;
+      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 optInMutations: readonly string[];
+      };
+      readonly packageManager?: "npm" | "pnpm" | "yarn";
+      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 plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      };
+      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[];
+    };
+  }, raw: LoadConfigCommand & {
+    targetMutatePatterns: readonly string[] | undefined;
+    basePath: string;
+  }) => Effect.Effect<{
+    options: {
+      readonly [x: string]: unknown;
+      readonly allowConsoleColors: boolean;
+      readonly buildCommand?: string;
+      readonly checkers: readonly {
+        readonly plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      }[];
+      readonly checkerNodeArgs: readonly string[];
+      readonly concurrency?: string | number;
+      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 optInMutations: readonly string[];
+      };
+      readonly packageManager?: "npm" | "pnpm" | "yarn";
+      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 plugin: string;
+        readonly nodeArgs?: readonly string[];
+        readonly options?: {
+          readonly [x: string]: unknown;
+        };
+      };
+      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[];
+    };
+    targetMutatePatterns: readonly string[] | undefined;
+    basePath: string;
+  }, never, never>;
+  ConfigOptionsRefused: ({ message }: {
+    readonly _tag: "ConfigOptionsRefused";
+    readonly message: string;
+  }) => Effect.Effect<never, ConfigError, RunEnvironment | RunEvents>;
+  CommandRejected: ({ issue }: Sandwich.CommandRejected) => Effect.Effect<never, ConfigError, RunEnvironment | RunEvents>;
+}>;
+declare namespace mod_d_exports$1 {
+  export { ConfigDocumentSchema, ConfigError, ConfigFileInvalidError, ConfigFileNotFoundError, ConfigFileUnreadableError, ConfigFileUnsupportedError, ConfigInvocation, ExtendsRefusalReason, ExtendsStepDecision, ExtendsStepDocument, ExtendsStepDocumentSchema, ExtendsStepDone, ExtendsStepRead, ExtendsStepRefused, ExtendsStepResolve, ExtendsStepState, ExtendsStepStateSchema, FileMatcher, Immutable, ImmutablePrimitive, ImportedModuleSchema, MergeCommand, MergeResult, Primitive, ReadConfigCommand, StrykerConfig, ValidationSchemaDocument, decideExtendsStep, describeErrors, extendsPropertySchema, forkCoreSchema, forkOptionsSchema, importModule, initialExtendsStepState, loadConfigCell, mergeConfigs, readConfig, survivorsPriorReport, validateOptions };
+}
+//#endregion
+//#region src/drivers/node.d.ts
+declare const nodePlatformLayer: Layer.Layer<EnginePorts>;
+//#endregion
+//#region src/IncrementalReport.schema.d.ts
+declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
+  readonly incrementalVersion: S.String;
+  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 formatIdentity: S.optional<S.Struct<{
+      readonly formatId: S.String;
+      readonly ownerModule: S.String;
+      readonly ownerVersion: S.String;
+    }>>;
+  }>>;
+  readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+    readonly source: S.optional<S.String>;
+    readonly tests: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly name: S.String;
+      readonly location: S.optional<S.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>]>;
+//#endregion
+//#region src/run/host.service.d.ts
+type StrykerRun = (options: mod_d_exports$2$1.PartialStrykerOptions, targetMutatePatterns?: string[]) => Effect.Effect<MutationTestDone, StageError, never>;
+//#endregion
+//#region src/run/run-stages.cell.d.ts
+declare const mutationTestCell: Cell.Cell<PrepareExecutorArgs, MutationTestDone, StageError, StageServices>;
+declare const strykerCell: {
+  (options: mod_d_exports$2$1.PartialStrykerOptions, targetMutatePatterns?: readonly string[]): Effect.Effect<MutationTestDone, StageError | PlatformError, EnginePorts>;
+  (targetMutatePatterns?: readonly string[]): (options: mod_d_exports$2$1.PartialStrykerOptions) => Effect.Effect<MutationTestDone, StageError | PlatformError, EnginePorts>;
+};
+declare namespace mod_d_exports$2 {
+  export { DryRunDone, EnginePorts, IdGenerator, IdGeneratorShape, IncrementalReportSchema, InstrumentDone, MutationTestDone, PrepareDone, PrepareExecutorArgs, Project, ProjectFile, RunEnvironment, RunEnvironmentShape, RunStageServices, SandboxHandle, StageError, StageServices, StrykerError, StrykerRun, TestCoverage, WiredRunLayer, mutationTestCell, nodePlatformLayer, strykerCell };
+}
+//#endregion
+//#region src/TestRunner.schema.d.ts
+type PooledTestRunnerError = mod_d_exports$6$1.TestRunnerFailed | ChildProcessCrashedError | OutOfMemoryError;
+//#endregion
+//#region src/pooled-test-runner.handle.d.ts
+declare const TypeId: unique symbol;
+type TypeId = typeof TypeId;
+interface PooledTestRunner extends Pipeable {
+  readonly [TypeId]: typeof TypeId;
+  readonly capabilities: Effect.Effect<mod_d_exports$6$1.TestRunnerCapabilities, PooledTestRunnerError>;
+  readonly init: Effect.Effect<void, PooledTestRunnerError>;
+  readonly dryRun: (options: mod_d_exports$6$1.DryRunOptions) => Effect.Effect<mod_d_exports$6$1.DryRunResult, PooledTestRunnerError>;
+  readonly mutantRun: (options: mod_d_exports$3$1.MutantRunOptions) => Effect.Effect<mod_d_exports$6$1.MutantRunResult, PooledTestRunnerError>;
+}
+//#endregion
+//#region src/command-runner.resource.d.ts
+declare const isCommandRunner: (name: mod_d_exports$2$1.TestRunnerConfig) => name is 'command';
+//#endregion
+//#region src/TestRunner.resource.d.ts
+interface TestRunnerBuildContext {
+  readonly options: mod_d_exports$2$1.StrykerOptions;
+  readonly fileDescriptions: mod_d_exports$2$2.FileDescriptions;
+  readonly sandboxWorkingDirectory: string;
+  readonly idGenerator: IdGeneratorShape;
+  readonly retire: Effect.Effect<void>;
+  readonly testFiles: readonly string[];
+}
+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>;
+  <ChildRunnerError>(childProcessRunner: Effect.Effect<PooledTestRunner, ChildRunnerError, Scope.Scope | WorkerLauncher>): (context: TestRunnerBuildContext) => Effect.Effect<PooledTestRunner, PooledTestRunnerError | ChildRunnerError, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Scope.Scope | WorkerLauncher>;
+};
+//#endregion
+//#region src/VmRunner.resource.d.ts
+declare const isVmRunner: (name: mod_d_exports$2$1.TestRunnerConfig) => name is 'vm';
+interface VmTestRunnerConfig {
+  readonly testFiles: readonly string[];
+  readonly sandboxWorkingDirectory: string;
+}
+declare const vmTestRunner: (config: VmTestRunnerConfig) => Effect.Effect<PooledTestRunner, mod_d_exports$6$1.TestRunnerFailed, Scope.Scope>;
+declare namespace mod_d_exports$3 {
+  export { AnyPluginDescriptor, AnyWorkerPluginDescriptor, AnyWorkerPluginSource, EvaluatorPluginDescriptor, EvaluatorPluginSource, Framework, Ignorer, LoadedPlugins, Node_2 as Node, PluginDescriptor, PluginDescriptorOf, PluginKind, PluginSource, PooledTestRunner, PooledTestRunnerError, REPORTER_EVENT_BATCH_BOUND, ReporterStage, ReporterWorkerClient, SpawnReporterWorkerParams, TestRunnerBuildContext, VmTestRunnerConfig, WorkerPluginDescriptor, WorkerPluginSource, buildTestRunner, isCommandRunner, isVmRunner, reporterWorkerFactory, spawnReporterWorker, vmTestRunner };
+}
+//#endregion
+//#region src/reporting/metrics-from-report.schema.d.ts
+type Files = Readonly<Record<string, mod_d_exports$4$1.FileResult>>;
+declare const MetricsResultFromReport_base: S.Class<MetricsResultFromReport, S.Struct<{
+  readonly name: S.String;
+  readonly metrics: typeof mod_d_exports$4$1.Metrics;
+  readonly childResults: S.$Array<S.suspend<S.Codec<mod_d_exports$4$1.MetricsResult, mod_d_exports$4$1.MetricsResultEncoded, never, never>>>;
+}>, mod_d_exports$4$1.MetricsResultEncoded>;
+declare class MetricsResultFromReport extends MetricsResultFromReport_base {
+  static readonly fromFiles: (files: Files) => MetricsResultFromReport;
+}
+//#endregion
+//#region src/reporting/verdict-envelope.schema.d.ts
+declare const VerdictMutant: S.Struct<{
+  readonly id: S.String;
+  readonly file: S.String;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+  }>;
+  readonly mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+}>;
+type VerdictMutant = typeof VerdictMutant.Type;
+declare const VerdictThresholds: S.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+  readonly break: S.NullOr<S.Finite>;
+}>;
+type VerdictThresholds = typeof VerdictThresholds.Type;
+type VerdictCounts = typeof mod_d_exports$4$1.MetricsSchema.Type;
+declare const VerdictEnvelope_base: S.Class<VerdictEnvelope, S.Struct<{
+  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"]>;
+  readonly score: S.NullOr<S.Finite>;
+  readonly thresholds: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+    readonly break: S.NullOr<S.Finite>;
+  }>;
+  readonly counts: typeof mod_d_exports$4$1.Metrics;
+  readonly reportFile: S.NullOr<S.String>;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly file: S.String;
+    readonly location: S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
+    }>;
+    readonly mutator: S.String;
+    readonly replacement: S.NullOr<S.String>;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  }>>;
+}>, {}>;
+declare class VerdictEnvelope extends VerdictEnvelope_base {
+  static readonly build: ((mode: OutputMode, signal: ModeSignal, runId: string, basePath: string, pathService: Path.Path) => (report: mod_d_exports$4$1.MutationTestResult) => VerdictEnvelope) & ((report: mod_d_exports$4$1.MutationTestResult, mode: OutputMode, signal: ModeSignal, runId: string, basePath: string, pathService: Path.Path) => VerdictEnvelope);
+}
+//#endregion
+//#region src/run-event-wire.schema.d.ts
+declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+  QUEUE_BOUND: number;
+}>, S.String, never, never>;
+type RunEventWireLine = typeof RunEventWireLine.Type;
+declare namespace mod_d_exports$4 {
+  export { FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, MetricsResultFromReport, ModeSignal$1 as ModeSignal, OutputMode$1 as OutputMode, PhaseEntered, PlanKnown, PluginFailureReason, PluginsReported, ResolvedMode, ResolvedModeInput, RunEvent, RunEventDrain, RunEventDrainLive, RunEventStream, RunEventWireLine, RunEvents, RunFailed, RunIdentity, RunIdentityShape, RunMutantTested, RunPhase, RunStarted, RunTerminalEvent, SkippedFileRow, SkippedReported, VerdictCounts, VerdictEnvelope, VerdictMutant, VerdictReached, VerdictThresholds, makeRunEventStream };
+}
+//#endregion
+//#region src/classify-worker-exit.workflow.d.ts
+declare const WorkerExitTypeId: unique symbol;
+type WorkerExitTypeId = typeof WorkerExitTypeId;
+declare const ClassifyWorkerExitCommand_base: S.Class<ClassifyWorkerExitCommand, S.TaggedStruct<"ClassifyWorkerExitCommand", {
+  readonly pid: S.Int;
+  readonly exitCode: S.Int;
+}>, {}>;
+declare class ClassifyWorkerExitCommand extends ClassifyWorkerExitCommand_base {
+  static readonly [Workflow.InstrumentationBrand]: {};
+}
+declare const WorkerOutOfMemory_base: S.Class<WorkerOutOfMemory, S.TaggedStruct<"WorkerOutOfMemory", {
+  readonly pid: S.Int;
+  readonly exitCode: S.Int;
+}>, {}>;
+declare class WorkerOutOfMemory extends WorkerOutOfMemory_base {
+  readonly [WorkerExitTypeId]: symbol;
+}
+declare const WorkerCrashed_base: S.Class<WorkerCrashed, S.TaggedStruct<"WorkerCrashed", {
+  readonly pid: S.Int;
+  readonly exitCode: S.Int;
+}>, {}>;
+declare class WorkerCrashed extends WorkerCrashed_base {
+  readonly [WorkerExitTypeId]: symbol;
+}
+declare const ClassifyWorkerExitDecision: S.Union<readonly [typeof WorkerOutOfMemory, typeof WorkerCrashed]>;
+type ClassifyWorkerExitDecision = typeof ClassifyWorkerExitDecision.Type;
+declare const classifyWorkerExit: Workflow.MadeWorkflow<typeof ClassifyWorkerExitCommand, S.Union<readonly [typeof WorkerOutOfMemory, typeof WorkerCrashed]>, S.Never>;
+//#endregion
+//#region src/worker-client.resource.d.ts
+interface WorkerClientParams<Rpcs extends Rpc.Any> {
+  readonly rpcs: RpcGroup.RpcGroup<Rpcs>;
+  readonly options: mod_d_exports$2$1.StrykerOptions;
+  readonly entrypoint: string;
+  readonly workingDirectory: string;
+  readonly execArgv: readonly string[];
+  readonly tempDirPrefix: string;
+  readonly env?: Readonly<Record<string, string>> | undefined;
+}
+declare const makeWorkerClient: <Rpcs extends Rpc.Any>(params: WorkerClientParams<Rpcs>) => Effect.Effect<RpcClient.RpcClient<Rpcs, RpcClientError>, WorkerBootError, Scope.Scope | WorkerLauncher>;
+//#endregion
+//#region src/worker-protocol.resource.d.ts
+declare const layerWorkerProtocol: (socket: Layer.Layer<Socket.Socket, Socket.SocketError>) => Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+declare namespace mod_d_exports$5 {
+  export { ChildProcessCrashedError, ClassifyWorkerExitCommand, ClassifyWorkerExitDecision, OutOfMemoryError, SpawnedSocketWorker, WorkerBootError, WorkerBootTimeoutError, WorkerClientParams, WorkerExit, WorkerLauncher, WorkerLauncherShape, WorkerSpawnParams, classifyWorkerExit, layerWorkerProtocol, make as makeSpawnedSocketWorker, makeWorkerClient };
+}
+//#endregion
+export { mod_d_exports as Checker, mod_d_exports$1 as Configuration, mod_d_exports$2 as Engine, mod_d_exports$3 as Plugin, mod_d_exports$4 as RunEvent, mod_d_exports$5 as Worker };