@systemfsoftware/stryker-js 4.0.0 → 6.0.0

package/dist/plugin-loader.d.mts

@@ -0,0 +1,1673 @@
+import * as Effect from 'effect/Effect';
+import * as HashMap from 'effect/HashMap';
+import * as Path from 'effect/Path';
+import * as S from 'effect/Schema';
+import { Schema } from 'effect';
+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 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;
+}
+
+declare interface BigIntLiteral$1 extends Span$1 {
+    type: "Literal";
+    value: bigint;
+    raw: string | null;
+    bigint: string;
+    parent?: Node$1;
+}
+
+declare interface BinaryExpression$1 extends Span$1 {
+    type: "BinaryExpression";
+    left: Expression$1;
+    operator: BinaryOperator;
+    right: Expression$1;
+    parent?: Node$1;
+}
+
+declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | ">>>" | "|" | "^" | "&" | "in" | "instanceof";
+
+declare interface BindingIdentifier$1 extends Span$1 {
+    type: "Identifier";
+    decorators?: [];
+    name: string;
+    optional?: false;
+    typeAnnotation?: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
+
+declare type BindingPattern$1 = BindingIdentifier$1 | ObjectPattern | ArrayPattern$1 | AssignmentPattern$1;
+
+declare interface BindingProperty$1 extends Span$1 {
+    type: "Property";
+    kind: "init";
+    key: PropertyKey_2;
+    value: BindingPattern$1;
+    method: false;
+    shorthand: boolean;
+    computed: boolean;
+    optional?: false;
+    parent?: Node$1;
+}
+
+declare interface BindingRestElement$1 extends Span$1 {
+    type: "RestElement";
+    decorators?: [];
+    argument: BindingPattern$1;
+    optional?: false;
+    typeAnnotation?: TSTypeAnnotation$1 | null;
+    value?: null;
+    parent?: Node$1;
+}
+
+declare interface BlockStatement$1 extends Span$1 {
+    type: "BlockStatement";
+    body: Array<Statement$1>;
+    parent?: Node$1;
+}
+
+declare interface BooleanLiteral$1 extends Span$1 {
+    type: "Literal";
+    value: boolean;
+    raw: string | null;
+    parent?: Node$1;
+}
+
+declare interface BreakStatement$1 extends Span$1 {
+    type: "BreakStatement";
+    label: LabelIdentifier$1 | null;
+    parent?: Node$1;
+}
+
+declare type Built<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Built<T[number]>> : T) : T extends Span$1 ? { [K in keyof T as K extends keyof Span$1 ? never : K]: Child<T[K]>; } & Partial<Pick<T, keyof Span$1>> : T;
+
+declare interface CallExpression$1 extends Span$1 {
+    type: "CallExpression";
+    callee: Expression$1;
+    typeArguments?: TSTypeParameterInstantiation$1 | null;
+    arguments: Array<Argument$1>;
+    optional: boolean;
+    parent?: Node$1;
+}
+
+declare interface CatchClause$1 extends Span$1 {
+    type: "CatchClause";
+    param: BindingPattern$1 | null;
+    body: BlockStatement$1;
+    parent?: Node$1;
+}
+
+declare type ChainElement = CallExpression$1 | TSNonNullExpression$1 | MemberExpression$1;
+
+declare interface ChainExpression$1 extends Span$1 {
+    type: "ChainExpression";
+    expression: ChainElement;
+    parent?: Node$1;
+}
+
+declare type Child<T> = T extends null | undefined ? T : T extends readonly unknown[] ? (number extends T['length'] ? Array<Child<T[number]>> : T) : T extends Span$1 ? Built<T> | T : T;
+
+declare interface Class$1 extends Span$1 {
+    type: ClassType;
+    decorators: Array<Decorator$1>;
+    id: BindingIdentifier$1 | null;
+    typeParameters?: TSTypeParameterDeclaration$1 | null;
+    superClass: Expression$1 | null;
+    superTypeArguments?: TSTypeParameterInstantiation$1 | null;
+    implements?: Array<TSClassImplements>;
+    body: ClassBody$1;
+    abstract?: boolean;
+    declare?: boolean;
+    parent?: Node$1;
+}
+
+declare interface ClassBody$1 extends Span$1 {
+    type: "ClassBody";
+    body: Array<ClassElement>;
+    parent?: Node$1;
+}
+
+declare type ClassElement = StaticBlock$1 | MethodDefinition$1 | PropertyDefinition$1 | AccessorProperty$1 | TSIndexSignature$1;
+
+declare type ClassType = "ClassDeclaration" | "ClassExpression";
+
+declare interface ComputedMemberExpression extends Span$1 {
+    type: "MemberExpression";
+    object: Expression$1;
+    property: Expression$1;
+    optional: boolean;
+    computed: true;
+    parent?: Node$1;
+}
+
+declare interface ConditionalExpression$1 extends Span$1 {
+    type: "ConditionalExpression";
+    test: Expression$1;
+    consequent: Expression$1;
+    alternate: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface ContinueStatement$1 extends Span$1 {
+    type: "ContinueStatement";
+    label: LabelIdentifier$1 | null;
+    parent?: Node$1;
+}
+
+export declare function create<K extends PluginKind>(pluginsByKind: HashMap.HashMap<PluginKind, readonly AnyPluginDescriptor[]>, kind: K, name: string): Effect.Effect<PluginDescriptorOf<K>, PluginNotFoundError>;
+
+export declare function createAll<K extends PluginKind>(pluginsByKind: HashMap.HashMap<PluginKind, readonly AnyPluginDescriptor[]>, kind: K): Effect.Effect<readonly PluginDescriptorOf<K>[]>;
+
+declare interface DebuggerStatement extends Span$1 {
+    type: "DebuggerStatement";
+    parent?: Node$1;
+}
+
+declare type Declaration = VariableDeclaration$1 | Function$1 | Class$1 | TSTypeAliasDeclaration$1 | TSInterfaceDeclaration$1 | TSEnumDeclaration$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSImportEqualsDeclaration$1;
+
+declare interface Decorator$1 extends Span$1 {
+    type: "Decorator";
+    expression: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface Directive extends Span$1 {
+    type: "ExpressionStatement";
+    expression: StringLiteral$1;
+    directive: string;
+    parent?: Node$1;
+}
+
+declare interface DoWhileStatement$1 extends Span$1 {
+    type: "DoWhileStatement";
+    body: Statement$1;
+    test: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface EmptyStatement$1 extends Span$1 {
+    type: "EmptyStatement";
+    parent?: Node$1;
+}
+
+export declare interface EvaluatorPluginDescriptor {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+}
+
+export declare interface EvaluatorPluginSource {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+    readonly modulePath: string;
+}
+
+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 | MetaProperty$1 | Super$1 | ArrayExpression$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | Class$1 | ConditionalExpression$1 | Function$1 | ImportExpression$1 | LogicalExpression$1 | NewExpression$1 | ObjectExpression$1 | ParenthesizedExpression | SequenceExpression$1 | TaggedTemplateExpression$1 | ThisExpression$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1 | PrivateInExpression$1 | JSXElement$1 | JSXFragment$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSNonNullExpression$1 | TSInstantiationExpression$1 | V8IntrinsicExpression | MemberExpression$1;
+
+declare interface ExpressionStatement$1 extends Span$1 {
+    type: "ExpressionStatement";
+    expression: Expression$1;
+    directive?: string | null;
+    parent?: Node$1;
+}
+
+declare interface ForInStatement$1 extends Span$1 {
+    type: "ForInStatement";
+    left: ForStatementLeft;
+    right: Expression$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+declare type FormalParameter = {
+    decorators?: Array<Decorator$1>;
+} & BindingPattern$1;
+
+declare interface FormalParameterRest extends Span$1 {
+    type: "RestElement";
+    argument: BindingPattern$1;
+    decorators?: [];
+    optional?: boolean;
+    typeAnnotation?: TSTypeAnnotation$1 | null;
+    value?: null;
+    parent?: Node$1;
+}
+
+declare interface ForOfStatement$1 extends Span$1 {
+    type: "ForOfStatement";
+    await: boolean;
+    left: ForStatementLeft;
+    right: Expression$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+declare interface ForStatement$1 extends Span$1 {
+    type: "ForStatement";
+    init: ForStatementInit | null;
+    test: Expression$1 | null;
+    update: Expression$1 | null;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+declare type ForStatementInit = VariableDeclaration$1 | Expression$1;
+
+declare type ForStatementLeft = VariableDeclaration$1 | AssignmentTarget;
+
+declare interface Function$1 extends Span$1 {
+    type: FunctionType;
+    id: BindingIdentifier$1 | null;
+    generator: boolean;
+    async: boolean;
+    declare?: boolean;
+    typeParameters?: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType?: TSTypeAnnotation$1 | null;
+    body: FunctionBody | null;
+    expression: false;
+    parent?: Node$1;
+}
+
+declare interface FunctionBody extends Span$1 {
+    type: "BlockStatement";
+    body: Array<Directive | Statement$1>;
+    parent?: Node$1;
+}
+
+declare type FunctionType = "FunctionDeclaration" | "FunctionExpression" | "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
+
+declare interface Hashbang extends Span$1 {
+    type: "Hashbang";
+    value: string;
+    parent?: Node$1;
+}
+
+declare interface IdentifierName$1 extends Span$1 {
+    type: "Identifier";
+    decorators?: [];
+    name: string;
+    optional?: false;
+    typeAnnotation?: null;
+    parent?: Node$1;
+}
+
+declare interface IdentifierReference$1 extends Span$1 {
+    type: "Identifier";
+    decorators?: [];
+    name: string;
+    optional?: false;
+    typeAnnotation?: null;
+    parent?: Node$1;
+}
+
+declare interface IfStatement$1 extends Span$1 {
+    type: "IfStatement";
+    test: Expression$1;
+    consequent: Statement$1;
+    alternate: Statement$1 | null;
+    parent?: Node$1;
+}
+
+export declare interface Ignorer {
+    readonly name: string;
+    shouldIgnore(node: Node_2, ancestors: readonly Node_2[]): string | undefined;
+}
+
+declare interface ImportAttribute$1 extends Span$1 {
+    type: "ImportAttribute";
+    key: ImportAttributeKey;
+    value: StringLiteral$1;
+    parent?: Node$1;
+}
+
+declare type ImportAttributeKey = IdentifierName$1 | StringLiteral$1;
+
+declare interface ImportDeclaration$1 extends Span$1 {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportDeclarationSpecifier>;
+    source: StringLiteral$1;
+    phase: ImportPhase | null;
+    attributes: Array<ImportAttribute$1>;
+    importKind?: ImportOrExportKind;
+    parent?: Node$1;
+}
+
+declare type ImportDeclarationSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
+
+declare interface ImportDefaultSpecifier extends Span$1 {
+    type: "ImportDefaultSpecifier";
+    local: BindingIdentifier$1;
+    parent?: Node$1;
+}
+
+declare interface ImportExpression$1 extends Span$1 {
+    type: "ImportExpression";
+    source: Expression$1;
+    options: Expression$1 | null;
+    phase: ImportPhase | null;
+    parent?: Node$1;
+}
+
+declare interface ImportNamespaceSpecifier extends Span$1 {
+    type: "ImportNamespaceSpecifier";
+    local: BindingIdentifier$1;
+    parent?: Node$1;
+}
+
+declare type ImportOrExportKind = "value" | "type";
+
+declare type ImportPhase = "source" | "defer";
+
+declare interface ImportSpecifier extends Span$1 {
+    type: "ImportSpecifier";
+    imported: ModuleExportName;
+    local: BindingIdentifier$1;
+    importKind?: ImportOrExportKind;
+    parent?: Node$1;
+}
+
+declare interface JSDocNonNullableType$1 extends Span$1 {
+    type: "TSJSDocNonNullableType";
+    typeAnnotation: TSType$1;
+    postfix: boolean;
+    parent?: Node$1;
+}
+
+declare interface JSDocNullableType$1 extends Span$1 {
+    type: "TSJSDocNullableType";
+    typeAnnotation: TSType$1;
+    postfix: boolean;
+    parent?: Node$1;
+}
+
+declare interface JSDocUnknownType extends Span$1 {
+    type: "TSJSDocUnknownType";
+    parent?: Node$1;
+}
+
+declare interface JSXAttribute$1 extends Span$1 {
+    type: "JSXAttribute";
+    name: JSXAttributeName;
+    value: JSXAttributeValue | null;
+    parent?: Node$1;
+}
+
+declare type JSXAttributeItem = JSXAttribute$1 | JSXSpreadAttribute$1;
+
+declare type JSXAttributeName = JSXIdentifier$1 | JSXNamespacedName$1;
+
+declare type JSXAttributeValue = StringLiteral$1 | JSXExpressionContainer$1 | JSXElement$1 | JSXFragment$1;
+
+declare type JSXChild = JSXText$1 | JSXElement$1 | JSXFragment$1 | JSXExpressionContainer$1 | JSXSpreadChild$1;
+
+declare interface JSXClosingElement extends Span$1 {
+    type: "JSXClosingElement";
+    name: JSXElementName;
+    parent?: Node$1;
+}
+
+declare interface JSXClosingFragment extends Span$1 {
+    type: "JSXClosingFragment";
+    parent?: Node$1;
+}
+
+declare interface JSXElement$1 extends Span$1 {
+    type: "JSXElement";
+    openingElement: JSXOpeningElement$1;
+    children: Array<JSXChild>;
+    closingElement: JSXClosingElement | null;
+    parent?: Node$1;
+}
+
+declare type JSXElementName = JSXIdentifier$1 | JSXNamespacedName$1 | JSXMemberExpression$1;
+
+declare interface JSXEmptyExpression extends Span$1 {
+    type: "JSXEmptyExpression";
+    parent?: Node$1;
+}
+
+declare type JSXExpression = JSXEmptyExpression | Expression$1;
+
+declare interface JSXExpressionContainer$1 extends Span$1 {
+    type: "JSXExpressionContainer";
+    expression: JSXExpression;
+    parent?: Node$1;
+}
+
+declare interface JSXFragment$1 extends Span$1 {
+    type: "JSXFragment";
+    openingFragment: JSXOpeningFragment;
+    children: Array<JSXChild>;
+    closingFragment: JSXClosingFragment;
+    parent?: Node$1;
+}
+
+declare interface JSXIdentifier$1 extends Span$1 {
+    type: "JSXIdentifier";
+    name: string;
+    parent?: Node$1;
+}
+
+declare interface JSXMemberExpression$1 extends Span$1 {
+    type: "JSXMemberExpression";
+    object: JSXMemberExpressionObject;
+    property: JSXIdentifier$1;
+    parent?: Node$1;
+}
+
+declare type JSXMemberExpressionObject = JSXIdentifier$1 | JSXMemberExpression$1;
+
+declare interface JSXNamespacedName$1 extends Span$1 {
+    type: "JSXNamespacedName";
+    namespace: JSXIdentifier$1;
+    name: JSXIdentifier$1;
+    parent?: Node$1;
+}
+
+declare interface JSXOpeningElement$1 extends Span$1 {
+    type: "JSXOpeningElement";
+    name: JSXElementName;
+    typeArguments?: TSTypeParameterInstantiation$1 | null;
+    attributes: Array<JSXAttributeItem>;
+    selfClosing: boolean;
+    parent?: Node$1;
+}
+
+declare interface JSXOpeningFragment extends Span$1 {
+    type: "JSXOpeningFragment";
+    attributes?: [];
+    selfClosing?: false;
+    parent?: Node$1;
+}
+
+declare interface JSXSpreadAttribute$1 extends Span$1 {
+    type: "JSXSpreadAttribute";
+    argument: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface JSXSpreadChild$1 extends Span$1 {
+    type: "JSXSpreadChild";
+    expression: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface JSXText$1 extends Span$1 {
+    type: "JSXText";
+    value: string;
+    raw: string | null;
+    parent?: Node$1;
+}
+
+declare interface LabeledStatement$1 extends Span$1 {
+    type: "LabeledStatement";
+    label: LabelIdentifier$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+declare interface LabelIdentifier$1 extends Span$1 {
+    type: "Identifier";
+    decorators?: [];
+    name: string;
+    optional?: false;
+    typeAnnotation?: null;
+    parent?: Node$1;
+}
+
+export declare interface LoadedPlugins {
+    readonly schemaContributions: readonly Record<string, unknown>[];
+    readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
+    readonly pluginModulePaths: readonly string[];
+    readonly pluginSources: readonly PluginSource[];
+    readonly ignorers: readonly Ignorer[];
+}
+
+export declare function loadPlugins(pluginDescriptors: readonly string[]): Effect.Effect<LoadedPlugins, PluginLoadFailedError, Path.Path>;
+
+declare interface LogicalExpression$1 extends Span$1 {
+    type: "LogicalExpression";
+    left: Expression$1;
+    operator: LogicalOperator;
+    right: Expression$1;
+    parent?: Node$1;
+}
+
+declare type LogicalOperator = "||" | "&&" | "??";
+
+declare type MemberExpression$1 = ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression;
+
+declare interface MetaProperty$1 extends Span$1 {
+    type: "MetaProperty";
+    meta: IdentifierName$1;
+    property: IdentifierName$1;
+    parent?: Node$1;
+}
+
+declare interface MethodDefinition$1 extends Span$1 {
+    type: MethodDefinitionType;
+    decorators: Array<Decorator$1>;
+    key: PropertyKey_2;
+    value: Function$1;
+    kind: MethodDefinitionKind;
+    computed: boolean;
+    static: boolean;
+    override?: boolean;
+    optional?: boolean;
+    accessibility?: TSAccessibility | null;
+    parent?: Node$1;
+}
+
+declare type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
+
+declare type MethodDefinitionType = "MethodDefinition" | "TSAbstractMethodDefinition";
+
+declare type ModuleDeclaration = ImportDeclaration$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1;
+
+declare type ModuleExportName = IdentifierName$1 | IdentifierReference$1 | StringLiteral$1;
+
+declare type ModuleKind = "script" | "module" | "commonjs";
+
+declare interface NewExpression$1 extends Span$1 {
+    type: "NewExpression";
+    callee: Expression$1;
+    typeArguments?: TSTypeParameterInstantiation$1 | null;
+    arguments: Array<Argument$1>;
+    parent?: Node$1;
+}
+
+declare type Node$1 = Program$1 | IdentifierName$1 | IdentifierReference$1 | BindingIdentifier$1 | LabelIdentifier$1 | ThisExpression$1 | ArrayExpression$1 | ObjectExpression$1 | ObjectProperty$1 | TemplateLiteral$1 | TaggedTemplateExpression$1 | TemplateElement$1 | ComputedMemberExpression | StaticMemberExpression$1 | PrivateFieldExpression | CallExpression$1 | NewExpression$1 | MetaProperty$1 | SpreadElement$1 | UpdateExpression$1 | UnaryExpression$1 | BinaryExpression$1 | PrivateInExpression$1 | LogicalExpression$1 | ConditionalExpression$1 | AssignmentExpression$1 | ArrayAssignmentTarget | ObjectAssignmentTarget | AssignmentTargetRest | AssignmentTargetWithDefault | AssignmentTargetPropertyIdentifier | AssignmentTargetPropertyProperty | SequenceExpression$1 | Super$1 | AwaitExpression | ChainExpression$1 | ParenthesizedExpression | Directive | Hashbang | BlockStatement$1 | VariableDeclaration$1 | VariableDeclarator$1 | EmptyStatement$1 | ExpressionStatement$1 | IfStatement$1 | DoWhileStatement$1 | WhileStatement$1 | ForStatement$1 | ForInStatement$1 | ForOfStatement$1 | ContinueStatement$1 | BreakStatement$1 | ReturnStatement$1 | WithStatement$1 | SwitchStatement$1 | SwitchCase$1 | LabeledStatement$1 | ThrowStatement$1 | TryStatement$1 | CatchClause$1 | DebuggerStatement | AssignmentPattern$1 | ObjectPattern | BindingProperty$1 | ArrayPattern$1 | BindingRestElement$1 | Function$1 | FunctionBody | ArrowFunctionExpression$1 | YieldExpression$1 | Class$1 | ClassBody$1 | MethodDefinition$1 | PropertyDefinition$1 | PrivateIdentifier$1 | StaticBlock$1 | AccessorProperty$1 | ImportExpression$1 | ImportDeclaration$1 | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportAttribute$1 | ExportNamedDeclaration$1 | ExportDefaultDeclaration$1 | ExportAllDeclaration$1 | ExportSpecifier | V8IntrinsicExpression | BooleanLiteral$1 | NullLiteral$1 | NumericLiteral$1 | StringLiteral$1 | BigIntLiteral$1 | RegExpLiteral$1 | JSXElement$1 | JSXOpeningElement$1 | JSXClosingElement | JSXFragment$1 | JSXOpeningFragment | JSXClosingFragment | JSXNamespacedName$1 | JSXMemberExpression$1 | JSXExpressionContainer$1 | JSXEmptyExpression | JSXAttribute$1 | JSXSpreadAttribute$1 | JSXIdentifier$1 | JSXSpreadChild$1 | JSXText$1 | TSThisParameter | TSEnumDeclaration$1 | TSEnumBody | TSEnumMember | TSTypeAnnotation$1 | TSLiteralType$1 | TSConditionalType$1 | TSUnionType$1 | TSIntersectionType$1 | TSParenthesizedType$1 | TSTypeOperator$1 | TSArrayType$1 | TSIndexedAccessType$1 | TSTupleType$1 | TSNamedTupleMember$1 | TSOptionalType$1 | TSRestType$1 | TSAnyKeyword | TSStringKeyword | TSBooleanKeyword | TSNumberKeyword | TSNeverKeyword | TSIntrinsicKeyword | TSUnknownKeyword | TSNullKeyword | TSUndefinedKeyword | TSVoidKeyword | TSSymbolKeyword | TSThisType | TSObjectKeyword | TSBigIntKeyword | TSTypeReference$1 | TSQualifiedName$1 | TSTypeParameterInstantiation$1 | TSTypeParameter | TSTypeParameterDeclaration$1 | TSTypeAliasDeclaration$1 | TSClassImplements | TSInterfaceDeclaration$1 | TSInterfaceBody$1 | TSPropertySignature$1 | TSIndexSignature$1 | TSCallSignatureDeclaration$1 | TSMethodSignature$1 | TSConstructSignatureDeclaration$1 | TSIndexSignatureName | TSInterfaceHeritage | TSTypePredicate$1 | TSModuleDeclaration$1 | TSGlobalDeclaration | TSModuleBlock$1 | TSTypeLiteral | TSInferType$1 | TSTypeQuery$1 | TSImportType$1 | TSImportTypeQualifiedName | TSFunctionType$1 | TSConstructorType$1 | TSMappedType$1 | TSTemplateLiteralType$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | TSImportEqualsDeclaration$1 | TSExternalModuleReference | TSNonNullExpression$1 | Decorator$1 | TSExportAssignment$1 | TSNamespaceExportDeclaration$1 | TSInstantiationExpression$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType | ParamPattern$1;
+
+declare type Node_2 = Simplify<Built<Node$1>> | Node$1;
+
+declare interface NullLiteral$1 extends Span$1 {
+    type: "Literal";
+    value: null;
+    raw: "null" | null;
+    parent?: Node$1;
+}
+
+declare interface NumericLiteral$1 extends Span$1 {
+    type: "Literal";
+    value: number;
+    raw: string | null;
+    parent?: Node$1;
+}
+
+declare interface ObjectAssignmentTarget extends Span$1 {
+    type: "ObjectPattern";
+    decorators?: [];
+    properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
+    optional?: false;
+    typeAnnotation?: null;
+    parent?: Node$1;
+}
+
+declare interface ObjectExpression$1 extends Span$1 {
+    type: "ObjectExpression";
+    properties: Array<ObjectPropertyKind>;
+    parent?: Node$1;
+}
+
+declare interface ObjectPattern extends Span$1 {
+    type: "ObjectPattern";
+    decorators?: [];
+    properties: Array<BindingProperty$1 | BindingRestElement$1>;
+    optional?: false;
+    typeAnnotation?: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface ObjectProperty$1 extends Span$1 {
+    type: "Property";
+    kind: PropertyKind;
+    key: PropertyKey_2;
+    value: Expression$1;
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+    optional?: false;
+    parent?: Node$1;
+}
+
+declare type ObjectPropertyKind = ObjectProperty$1 | SpreadElement$1;
+
+declare type ParamPattern$1 = FormalParameter | TSParameterProperty | FormalParameterRest;
+
+declare interface ParenthesizedExpression extends Span$1 {
+    type: "ParenthesizedExpression";
+    expression: Expression$1;
+    parent?: Node$1;
+}
+
+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 interface PluginLoaderEntryLike {
+    readonly moduleName: string;
+    readonly plugins: readonly PluginDescriptor[] | undefined;
+    readonly schemaContribution: Record<string, unknown> | undefined;
+}
+
+export declare class PluginLoadFailedError extends PluginLoadFailedError_base {
+    readonly exitClass: 'InternalError';
+}
+
+declare const PluginLoadFailedError_base: Schema.Class<PluginLoadFailedError, Schema.TaggedStruct<"PluginLoadFailedError", {
+    readonly descriptor: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, YieldableError>;
+
+export declare interface PluginLoadPlan {
+    readonly schemaContributions: readonly Record<string, unknown>[];
+    readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
+    readonly pluginModulePaths: readonly string[];
+    readonly pluginSources: readonly PluginSource[];
+    readonly shadowings: readonly {
+        readonly kind: PluginKind;
+        readonly name: string;
+        readonly shadowedIndex: number;
+        readonly winnerIndex: number;
+    }[];
+}
+
+export declare class PluginNotFoundError extends PluginNotFoundError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const PluginNotFoundError_base: Schema.Class<PluginNotFoundError, Schema.TaggedStruct<"PluginNotFoundError", {
+    readonly descriptor: Schema.String;
+}>, YieldableError>;
+
+export declare type PluginSource = AnyWorkerPluginSource | EvaluatorPluginSource;
+
+declare interface PrivateFieldExpression extends Span$1 {
+    type: "MemberExpression";
+    object: Expression$1;
+    property: PrivateIdentifier$1;
+    optional: boolean;
+    computed: false;
+    parent?: Node$1;
+}
+
+declare interface PrivateIdentifier$1 extends Span$1 {
+    type: "PrivateIdentifier";
+    name: string;
+    parent?: Node$1;
+}
+
+declare interface PrivateInExpression$1 extends Span$1 {
+    type: "BinaryExpression";
+    left: PrivateIdentifier$1;
+    operator: "in";
+    right: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface Program$1 extends Span$1 {
+    type: "Program";
+    body: Array<Directive | Statement$1>;
+    sourceType: ModuleKind;
+    hashbang: Hashbang | null;
+    parent?: null;
+}
+
+declare interface PropertyDefinition$1 extends Span$1 {
+    type: PropertyDefinitionType;
+    decorators: Array<Decorator$1>;
+    key: PropertyKey_2;
+    typeAnnotation?: TSTypeAnnotation$1 | null;
+    value: Expression$1 | null;
+    computed: boolean;
+    static: boolean;
+    declare?: boolean;
+    override?: boolean;
+    optional?: boolean;
+    definite?: boolean;
+    readonly?: boolean;
+    accessibility?: TSAccessibility | null;
+    parent?: Node$1;
+}
+
+declare type PropertyDefinitionType = "PropertyDefinition" | "TSAbstractPropertyDefinition";
+
+declare type PropertyKey_2 = IdentifierName$1 | PrivateIdentifier$1 | Expression$1;
+
+declare type PropertyKind = "init" | "get" | "set";
+
+declare interface RegExpLiteral$1 extends Span$1 {
+    type: "Literal";
+    value: RegExp | null;
+    raw: string | null;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    parent?: Node$1;
+}
+
+export declare const resolvePluginWorkerEntry: (params: {
+    readonly loaded: Pick<LoadedPlugins, 'pluginSources'>;
+    readonly kind: WorkerPluginKind;
+    readonly name: string;
+}) => Effect.Effect<WorkerPluginSpawn, PluginNotFoundError>;
+
+declare interface ReturnStatement$1 extends Span$1 {
+    type: "ReturnStatement";
+    argument: Expression$1 | null;
+    parent?: Node$1;
+}
+
+declare interface SequenceExpression$1 extends Span$1 {
+    type: "SequenceExpression";
+    expressions: Array<Expression$1>;
+    parent?: Node$1;
+}
+
+declare type SimpleAssignmentTarget$1 = IdentifierReference$1 | TSAsExpression$1 | TSSatisfiesExpression$1 | TSNonNullExpression$1 | TSTypeAssertion$1 | MemberExpression$1;
+
+declare type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+
+declare interface Span$1 {
+    start: number;
+    end: number;
+    range?: [number, number];
+}
+
+declare interface SpreadElement$1 extends Span$1 {
+    type: "SpreadElement";
+    argument: Expression$1;
+    parent?: Node$1;
+}
+
+declare type Statement$1 = BlockStatement$1 | BreakStatement$1 | ContinueStatement$1 | DebuggerStatement | DoWhileStatement$1 | EmptyStatement$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | IfStatement$1 | LabeledStatement$1 | ReturnStatement$1 | SwitchStatement$1 | ThrowStatement$1 | TryStatement$1 | WhileStatement$1 | WithStatement$1 | Declaration | ModuleDeclaration;
+
+declare interface StaticBlock$1 extends Span$1 {
+    type: "StaticBlock";
+    body: Array<Statement$1>;
+    parent?: Node$1;
+}
+
+declare interface StaticMemberExpression$1 extends Span$1 {
+    type: "MemberExpression";
+    object: Expression$1;
+    property: IdentifierName$1;
+    optional: boolean;
+    computed: false;
+    parent?: Node$1;
+}
+
+declare interface StringLiteral$1 extends Span$1 {
+    type: "Literal";
+    value: string;
+    raw: string | null;
+    parent?: Node$1;
+}
+
+declare interface Super$1 extends Span$1 {
+    type: "Super";
+    parent?: Node$1;
+}
+
+declare interface SwitchCase$1 extends Span$1 {
+    type: "SwitchCase";
+    test: Expression$1 | null;
+    consequent: Array<Statement$1>;
+    parent?: Node$1;
+}
+
+declare interface SwitchStatement$1 extends Span$1 {
+    type: "SwitchStatement";
+    discriminant: Expression$1;
+    cases: Array<SwitchCase$1>;
+    parent?: Node$1;
+}
+
+declare interface TaggedTemplateExpression$1 extends Span$1 {
+    type: "TaggedTemplateExpression";
+    tag: Expression$1;
+    typeArguments?: TSTypeParameterInstantiation$1 | null;
+    quasi: TemplateLiteral$1;
+    parent?: Node$1;
+}
+
+declare interface TemplateElement$1 extends Span$1 {
+    type: "TemplateElement";
+    value: TemplateElementValue;
+    tail: boolean;
+    parent?: Node$1;
+}
+
+declare interface TemplateElementValue {
+    raw: string;
+    cooked: string | null;
+}
+
+declare interface TemplateLiteral$1 extends Span$1 {
+    type: "TemplateLiteral";
+    quasis: Array<TemplateElement$1>;
+    expressions: Array<Expression$1>;
+    parent?: Node$1;
+}
+
+declare interface ThisExpression$1 extends Span$1 {
+    type: "ThisExpression";
+    parent?: Node$1;
+}
+
+declare interface ThrowStatement$1 extends Span$1 {
+    type: "ThrowStatement";
+    argument: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface TryStatement$1 extends Span$1 {
+    type: "TryStatement";
+    block: BlockStatement$1;
+    handler: CatchClause$1 | null;
+    finalizer: BlockStatement$1 | null;
+    parent?: Node$1;
+}
+
+declare type TSAccessibility = "private" | "protected" | "public";
+
+declare interface TSAnyKeyword extends Span$1 {
+    type: "TSAnyKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSArrayType$1 extends Span$1 {
+    type: "TSArrayType";
+    elementType: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSAsExpression$1 extends Span$1 {
+    type: "TSAsExpression";
+    expression: Expression$1;
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSBigIntKeyword extends Span$1 {
+    type: "TSBigIntKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSBooleanKeyword extends Span$1 {
+    type: "TSBooleanKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSCallSignatureDeclaration$1 extends Span$1 {
+    type: "TSCallSignatureDeclaration";
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface TSClassImplements extends Span$1 {
+    type: "TSClassImplements";
+    expression: IdentifierReference$1 | ThisExpression$1 | MemberExpression$1;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface TSConditionalType$1 extends Span$1 {
+    type: "TSConditionalType";
+    checkType: TSType$1;
+    extendsType: TSType$1;
+    trueType: TSType$1;
+    falseType: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSConstructorType$1 extends Span$1 {
+    type: "TSConstructorType";
+    abstract: boolean;
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1;
+    parent?: Node$1;
+}
+
+declare interface TSConstructSignatureDeclaration$1 extends Span$1 {
+    type: "TSConstructSignatureDeclaration";
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface TSEnumBody extends Span$1 {
+    type: "TSEnumBody";
+    members: Array<TSEnumMember>;
+    parent?: Node$1;
+}
+
+declare interface TSEnumDeclaration$1 extends Span$1 {
+    type: "TSEnumDeclaration";
+    id: BindingIdentifier$1;
+    body: TSEnumBody;
+    const: boolean;
+    declare: boolean;
+    parent?: Node$1;
+}
+
+declare interface TSEnumMember extends Span$1 {
+    type: "TSEnumMember";
+    id: TSEnumMemberName;
+    initializer: Expression$1 | null;
+    computed: boolean;
+    parent?: Node$1;
+}
+
+declare type TSEnumMemberName = IdentifierName$1 | StringLiteral$1 | TemplateLiteral$1;
+
+declare interface TSExportAssignment$1 extends Span$1 {
+    type: "TSExportAssignment";
+    expression: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface TSExternalModuleReference extends Span$1 {
+    type: "TSExternalModuleReference";
+    expression: StringLiteral$1;
+    parent?: Node$1;
+}
+
+declare interface TSFunctionType$1 extends Span$1 {
+    type: "TSFunctionType";
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1;
+    parent?: Node$1;
+}
+
+declare interface TSGlobalDeclaration extends Span$1 {
+    type: "TSModuleDeclaration";
+    id: IdentifierName$1;
+    body: TSModuleBlock$1;
+    kind: "global";
+    declare: boolean;
+    global: true;
+    parent?: Node$1;
+}
+
+declare interface TSImportEqualsDeclaration$1 extends Span$1 {
+    type: "TSImportEqualsDeclaration";
+    id: BindingIdentifier$1;
+    moduleReference: TSModuleReference;
+    importKind: ImportOrExportKind;
+    parent?: Node$1;
+}
+
+declare interface TSImportType$1 extends Span$1 {
+    type: "TSImportType";
+    source: StringLiteral$1;
+    options: ObjectExpression$1 | null;
+    qualifier: TSImportTypeQualifier | null;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface TSImportTypeQualifiedName extends Span$1 {
+    type: "TSQualifiedName";
+    left: TSImportTypeQualifier;
+    right: IdentifierName$1;
+    parent?: Node$1;
+}
+
+declare type TSImportTypeQualifier = IdentifierName$1 | TSImportTypeQualifiedName;
+
+declare interface TSIndexedAccessType$1 extends Span$1 {
+    type: "TSIndexedAccessType";
+    objectType: TSType$1;
+    indexType: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSIndexSignature$1 extends Span$1 {
+    type: "TSIndexSignature";
+    parameters: Array<TSIndexSignatureName>;
+    typeAnnotation: TSTypeAnnotation$1;
+    readonly: boolean;
+    static: boolean;
+    accessibility: null;
+    parent?: Node$1;
+}
+
+declare interface TSIndexSignatureName extends Span$1 {
+    type: "Identifier";
+    decorators: [];
+    name: string;
+    optional: false;
+    typeAnnotation: TSTypeAnnotation$1;
+    parent?: Node$1;
+}
+
+declare interface TSInferType$1 extends Span$1 {
+    type: "TSInferType";
+    typeParameter: TSTypeParameter;
+    parent?: Node$1;
+}
+
+declare interface TSInstantiationExpression$1 extends Span$1 {
+    type: "TSInstantiationExpression";
+    expression: Expression$1;
+    typeArguments: TSTypeParameterInstantiation$1;
+    parent?: Node$1;
+}
+
+declare interface TSInterfaceBody$1 extends Span$1 {
+    type: "TSInterfaceBody";
+    body: Array<TSSignature>;
+    parent?: Node$1;
+}
+
+declare interface TSInterfaceDeclaration$1 extends Span$1 {
+    type: "TSInterfaceDeclaration";
+    id: BindingIdentifier$1;
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    extends: Array<TSInterfaceHeritage>;
+    body: TSInterfaceBody$1;
+    declare: boolean;
+    parent?: Node$1;
+}
+
+declare interface TSInterfaceHeritage extends Span$1 {
+    type: "TSInterfaceHeritage";
+    expression: Expression$1;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface TSIntersectionType$1 extends Span$1 {
+    type: "TSIntersectionType";
+    types: Array<TSType$1>;
+    parent?: Node$1;
+}
+
+declare interface TSIntrinsicKeyword extends Span$1 {
+    type: "TSIntrinsicKeyword";
+    parent?: Node$1;
+}
+
+declare type TSLiteral = BooleanLiteral$1 | NumericLiteral$1 | BigIntLiteral$1 | StringLiteral$1 | TemplateLiteral$1 | UnaryExpression$1;
+
+declare interface TSLiteralType$1 extends Span$1 {
+    type: "TSLiteralType";
+    literal: TSLiteral;
+    parent?: Node$1;
+}
+
+declare interface TSMappedType$1 extends Span$1 {
+    type: "TSMappedType";
+    key: BindingIdentifier$1;
+    constraint: TSType$1;
+    nameType: TSType$1 | null;
+    typeAnnotation: TSType$1 | null;
+    optional: TSMappedTypeModifierOperator | false;
+    readonly: TSMappedTypeModifierOperator | null;
+    parent?: Node$1;
+}
+
+declare type TSMappedTypeModifierOperator = true | "+" | "-";
+
+declare interface TSMethodSignature$1 extends Span$1 {
+    type: "TSMethodSignature";
+    key: PropertyKey_2;
+    computed: boolean;
+    optional: boolean;
+    kind: TSMethodSignatureKind;
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    params: ParamPattern$1[];
+    returnType: TSTypeAnnotation$1 | null;
+    accessibility: null;
+    readonly: false;
+    static: false;
+    parent?: Node$1;
+}
+
+declare type TSMethodSignatureKind = "method" | "get" | "set";
+
+declare interface TSModuleBlock$1 extends Span$1 {
+    type: "TSModuleBlock";
+    body: Array<Directive | Statement$1>;
+    parent?: Node$1;
+}
+
+declare interface TSModuleDeclaration$1 extends Span$1 {
+    type: "TSModuleDeclaration";
+    id: BindingIdentifier$1 | StringLiteral$1 | TSQualifiedName$1;
+    body: TSModuleBlock$1 | null;
+    kind: TSModuleDeclarationKind;
+    declare: boolean;
+    global: false;
+    parent?: Node$1;
+}
+
+declare type TSModuleDeclarationKind = "module" | "namespace";
+
+declare type TSModuleReference = TSExternalModuleReference | IdentifierReference$1 | TSQualifiedName$1;
+
+declare interface TSNamedTupleMember$1 extends Span$1 {
+    type: "TSNamedTupleMember";
+    label: IdentifierName$1;
+    elementType: TSTupleElement;
+    optional: boolean;
+    parent?: Node$1;
+}
+
+declare interface TSNamespaceExportDeclaration$1 extends Span$1 {
+    type: "TSNamespaceExportDeclaration";
+    id: IdentifierName$1;
+    parent?: Node$1;
+}
+
+declare interface TSNeverKeyword extends Span$1 {
+    type: "TSNeverKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSNonNullExpression$1 extends Span$1 {
+    type: "TSNonNullExpression";
+    expression: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface TSNullKeyword extends Span$1 {
+    type: "TSNullKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSNumberKeyword extends Span$1 {
+    type: "TSNumberKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSObjectKeyword extends Span$1 {
+    type: "TSObjectKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSOptionalType$1 extends Span$1 {
+    type: "TSOptionalType";
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSParameterProperty extends Span$1 {
+    type: "TSParameterProperty";
+    accessibility: TSAccessibility | null;
+    decorators: Array<Decorator$1>;
+    override: boolean;
+    parameter: FormalParameter;
+    readonly: boolean;
+    static: boolean;
+    parent?: Node$1;
+}
+
+declare interface TSParenthesizedType$1 extends Span$1 {
+    type: "TSParenthesizedType";
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSPropertySignature$1 extends Span$1 {
+    type: "TSPropertySignature";
+    computed: boolean;
+    optional: boolean;
+    readonly: boolean;
+    key: PropertyKey_2;
+    typeAnnotation: TSTypeAnnotation$1 | null;
+    accessibility: null;
+    static: false;
+    parent?: Node$1;
+}
+
+declare interface TSQualifiedName$1 extends Span$1 {
+    type: "TSQualifiedName";
+    left: TSTypeName;
+    right: IdentifierName$1;
+    parent?: Node$1;
+}
+
+declare interface TSRestType$1 extends Span$1 {
+    type: "TSRestType";
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSSatisfiesExpression$1 extends Span$1 {
+    type: "TSSatisfiesExpression";
+    expression: Expression$1;
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
+
+declare type TSSignature = TSIndexSignature$1 | TSPropertySignature$1 | TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSMethodSignature$1;
+
+declare interface TSStringKeyword extends Span$1 {
+    type: "TSStringKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSSymbolKeyword extends Span$1 {
+    type: "TSSymbolKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSTemplateLiteralType$1 extends Span$1 {
+    type: "TSTemplateLiteralType";
+    quasis: Array<TemplateElement$1>;
+    types: Array<TSType$1>;
+    parent?: Node$1;
+}
+
+declare interface TSThisParameter extends Span$1 {
+    type: "Identifier";
+    decorators: [];
+    name: "this";
+    optional: false;
+    typeAnnotation: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface TSThisType extends Span$1 {
+    type: "TSThisType";
+    parent?: Node$1;
+}
+
+declare type TSTupleElement = TSOptionalType$1 | TSRestType$1 | TSType$1;
+
+declare interface TSTupleType$1 extends Span$1 {
+    type: "TSTupleType";
+    elementTypes: Array<TSTupleElement>;
+    parent?: Node$1;
+}
+
+declare type TSType$1 = TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSArrayType$1 | TSConditionalType$1 | TSConstructorType$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSTemplateLiteralType$1 | TSThisType | TSTupleType$1 | TSTypeLiteral | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUnionType$1 | TSParenthesizedType$1 | JSDocNullableType$1 | JSDocNonNullableType$1 | JSDocUnknownType;
+
+declare interface TSTypeAliasDeclaration$1 extends Span$1 {
+    type: "TSTypeAliasDeclaration";
+    id: BindingIdentifier$1;
+    typeParameters: TSTypeParameterDeclaration$1 | null;
+    typeAnnotation: TSType$1;
+    declare: boolean;
+    parent?: Node$1;
+}
+
+declare interface TSTypeAnnotation$1 extends Span$1 {
+    type: "TSTypeAnnotation";
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
+
+declare interface TSTypeAssertion$1 extends Span$1 {
+    type: "TSTypeAssertion";
+    typeAnnotation: TSType$1;
+    expression: Expression$1;
+    parent?: Node$1;
+}
+
+declare interface TSTypeLiteral extends Span$1 {
+    type: "TSTypeLiteral";
+    members: Array<TSSignature>;
+    parent?: Node$1;
+}
+
+declare type TSTypeName = IdentifierReference$1 | TSQualifiedName$1 | ThisExpression$1;
+
+declare interface TSTypeOperator$1 extends Span$1 {
+    type: "TSTypeOperator";
+    operator: TSTypeOperatorOperator;
+    typeAnnotation: TSType$1;
+    parent?: Node$1;
+}
+
+declare type TSTypeOperatorOperator = "keyof" | "unique" | "readonly";
+
+declare interface TSTypeParameter extends Span$1 {
+    type: "TSTypeParameter";
+    name: BindingIdentifier$1;
+    constraint: TSType$1 | null;
+    default: TSType$1 | null;
+    in: boolean;
+    out: boolean;
+    const: boolean;
+    parent?: Node$1;
+}
+
+declare interface TSTypeParameterDeclaration$1 extends Span$1 {
+    type: "TSTypeParameterDeclaration";
+    params: Array<TSTypeParameter>;
+    parent?: Node$1;
+}
+
+declare interface TSTypeParameterInstantiation$1 extends Span$1 {
+    type: "TSTypeParameterInstantiation";
+    params: Array<TSType$1>;
+    parent?: Node$1;
+}
+
+declare interface TSTypePredicate$1 extends Span$1 {
+    type: "TSTypePredicate";
+    parameterName: TSTypePredicateName;
+    asserts: boolean;
+    typeAnnotation: TSTypeAnnotation$1 | null;
+    parent?: Node$1;
+}
+
+declare type TSTypePredicateName = IdentifierName$1 | TSThisType;
+
+declare interface TSTypeQuery$1 extends Span$1 {
+    type: "TSTypeQuery";
+    exprName: TSTypeQueryExprName;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
+
+declare type TSTypeQueryExprName = TSImportType$1 | TSTypeName;
+
+declare interface TSTypeReference$1 extends Span$1 {
+    type: "TSTypeReference";
+    typeName: TSTypeName;
+    typeArguments: TSTypeParameterInstantiation$1 | null;
+    parent?: Node$1;
+}
+
+declare interface TSUndefinedKeyword extends Span$1 {
+    type: "TSUndefinedKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSUnionType$1 extends Span$1 {
+    type: "TSUnionType";
+    types: Array<TSType$1>;
+    parent?: Node$1;
+}
+
+declare interface TSUnknownKeyword extends Span$1 {
+    type: "TSUnknownKeyword";
+    parent?: Node$1;
+}
+
+declare interface TSVoidKeyword extends Span$1 {
+    type: "TSVoidKeyword";
+    parent?: Node$1;
+}
+
+declare interface UnaryExpression$1 extends Span$1 {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    argument: Expression$1;
+    prefix: true;
+    parent?: Node$1;
+}
+
+declare type UnaryOperator = "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
+
+declare interface UpdateExpression$1 extends Span$1 {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    prefix: boolean;
+    argument: SimpleAssignmentTarget$1;
+    parent?: Node$1;
+}
+
+declare type UpdateOperator = "++" | "--";
+
+declare interface V8IntrinsicExpression extends Span$1 {
+    type: "V8IntrinsicExpression";
+    name: IdentifierName$1;
+    arguments: Array<Argument$1>;
+    parent?: Node$1;
+}
+
+declare interface VariableDeclaration$1 extends Span$1 {
+    type: "VariableDeclaration";
+    kind: VariableDeclarationKind;
+    declarations: Array<VariableDeclarator$1>;
+    declare?: boolean;
+    parent?: Node$1;
+}
+
+declare type VariableDeclarationKind = "var" | "let" | "const" | "using" | "await using";
+
+declare interface VariableDeclarator$1 extends Span$1 {
+    type: "VariableDeclarator";
+    id: BindingPattern$1;
+    init: Expression$1 | null;
+    definite?: boolean;
+    parent?: Node$1;
+}
+
+declare interface WhileStatement$1 extends Span$1 {
+    type: "WhileStatement";
+    test: Expression$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+declare interface WithStatement$1 extends Span$1 {
+    type: "WithStatement";
+    object: Expression$1;
+    body: Statement$1;
+    parent?: Node$1;
+}
+
+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 type WorkerPluginSpawn = typeof WorkerPluginSpawnSchema.Type;
+
+export declare const WorkerPluginSpawnSchema: S.Struct<{
+    readonly kind: S.Literals<readonly ["TestRunner", "Checker", "Reporter"]>;
+    readonly entrypoint: S.String;
+}>;
+
+declare interface YieldExpression$1 extends Span$1 {
+    type: "YieldExpression";
+    delegate: boolean;
+    argument: Expression$1 | null;
+    parent?: Node$1;
+}
+
+export { }