@poe-platform/safe-js 0.1.0

package/dist/safe-js/modules/mcp.d.ts

@@ -0,0 +1,63 @@
+import { type McpModuleOptions } from "./mcp-transport.js";
+export type McpModuleServerHandle = {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+};
+export type McpModuleTool = {
+    name: string;
+    description?: string;
+    schema?: unknown;
+};
+export type McpModuleToolCall = {
+    name: string;
+    args?: unknown;
+};
+export type McpModuleToolBatchError = {
+    name: string;
+    message: string;
+};
+export type McpModuleToolBatchResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: McpModuleToolBatchError;
+};
+export type McpModuleClient = {
+    tools(): Promise<McpModuleTool[]>;
+    tool(name: string, args?: unknown): Promise<unknown>;
+    toolBatch(calls: McpModuleToolCall[]): Promise<McpModuleToolBatchResult[]>;
+};
+type McpConnection = {
+    listTools(): Promise<{
+        tools: unknown[];
+    }>;
+    callTool(params: {
+        name: string;
+        arguments?: unknown;
+    }): Promise<unknown>;
+    callToolBatch?(params: Array<{
+        name: string;
+        arguments?: unknown;
+    }>): Promise<McpModuleToolBatchResult[]>;
+};
+export type ConnectMcp = (server: McpModuleServerHandle) => Promise<McpConnection> | McpConnection;
+export type McpNamedServerHandle = {
+    name: string;
+};
+export type ManagedMcpClient = McpModuleClient & {
+    close(): Promise<void>;
+};
+export type ManagedMcpModule = {
+    servers: Record<string, ManagedMcpClient>;
+    server(name: string): McpNamedServerHandle;
+    client(handle: McpNamedServerHandle | string): Promise<ManagedMcpClient>;
+};
+type CustomMcpModule = {
+    server(server: McpModuleServerHandle): McpModuleServerHandle;
+    client(handle: McpModuleServerHandle): Promise<McpModuleClient>;
+};
+export declare function makeMcpModule(options: McpModuleOptions): ManagedMcpModule;
+export declare function makeMcpModule(connectMcp: ConnectMcp): CustomMcpModule;
+export {};

package/dist/safe-js/modules/metric.d.ts

@@ -0,0 +1,4 @@
+export type NpmRunner = (scriptName: string) => Promise<string>;
+export declare function makeMetricModule(npmRunner: NpmRunner): {
+    run(name: string): Promise<number>;
+};

package/dist/safe-js/modules/registry.d.ts

@@ -0,0 +1,16 @@
+import type { Budget, CompileOwner } from "../interp/budget.js";
+import type { HostCallJournal } from "../interp/host-call.js";
+import { type CallerInjectedBinding } from "../interp/host-bridge.js";
+import type { SandboxValue } from "../interp/values.js";
+import type { Module } from "../parse/parser.js";
+export type ModuleExports = ReadonlyMap<string, CallerInjectedBinding> | Record<string, CallerInjectedBinding>;
+export type ModuleRegistry = ReadonlyMap<string, ModuleExports> | Record<string, ModuleExports>;
+export declare function createUnknownModuleMessage(moduleName: string, moduleNames: readonly string[]): string;
+export declare function createUnknownExportMessage(moduleName: string, exportName: string, availableExports: readonly string[]): string;
+export declare function resolveModuleImports(module: Module, modules: ModuleRegistry | undefined, options: {
+    budget: Budget;
+    compileOwner?: CompileOwner;
+    hostCalls?: HostCallJournal;
+    signal?: AbortSignal;
+    allowMissing?: boolean;
+}): Record<string, SandboxValue>;

package/dist/safe-js/modules/time.d.ts

@@ -0,0 +1,12 @@
+export type TimeModuleOptions = {
+    now?: () => number;
+    random?: () => number;
+    seed?: number;
+    signal?: AbortSignal;
+};
+export declare function makeTimeModule(options?: TimeModuleOptions): {
+    random: () => number;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+    uuid: () => string;
+};

package/dist/safe-js/observability/otel.d.ts

@@ -0,0 +1,21 @@
+export type OtelSpan = {
+    setAttribute(key: string, value: unknown): void;
+    addEvent(name: string, attrs: Record<string, unknown>): void;
+    end(): void;
+};
+export interface OtelSink {
+    startSpan(name: string, attrs: Record<string, unknown>): OtelSpan;
+    recordException(span: ReturnType<OtelSink["startSpan"]>, error: unknown): void;
+}
+export declare const noopOtelSink: OtelSink;
+export declare function bindOtelSpan(value: object, span: OtelSpan): void;
+export declare function getBoundOtelSpan(value: unknown): OtelSpan | undefined;
+export declare function activateOtelSpan(span: OtelSpan): () => void;
+export declare function getActiveOtelSpan(): OtelSpan | undefined;
+export declare function activateOtelSink(sink: OtelSink | undefined): () => void;
+export declare function getActiveOtelSink(): OtelSink | undefined;
+export declare function safeStartSpan(sink: OtelSink | undefined, name: string, attrs: Record<string, unknown>): OtelSpan;
+export declare function safeSetAttribute(span: OtelSpan, key: string, value: unknown): void;
+export declare function safeAddEvent(span: OtelSpan | undefined, name: string, attrs?: Record<string, unknown>): void;
+export declare function safeRecordException(sink: OtelSink | undefined, span: OtelSpan, error: unknown): void;
+export declare function safeEndSpan(span: OtelSpan): void;

package/dist/safe-js/output-stream.d.ts

@@ -0,0 +1,12 @@
+export type OutputStream = {
+    off?(event: "error", listener: (error: unknown) => void): void;
+    on?(event: "error", listener: (error: unknown) => void): void;
+    write(chunk: string): void;
+};
+export type BrokenPipeState = {
+    closed: boolean;
+};
+export declare function createBrokenPipeState(): BrokenPipeState;
+export declare function createSafeOutputStream(stream: OutputStream, brokenPipe: BrokenPipeState): OutputStream;
+export declare function withBrokenPipeGuard<TResult>(streams: readonly OutputStream[], brokenPipe: BrokenPipeState, callback: () => Promise<TResult>): Promise<TResult>;
+export declare function addBrokenPipeListener(stream: OutputStream, brokenPipe: BrokenPipeState): () => void;

package/dist/safe-js/parse/parse-export.d.ts

@@ -0,0 +1,36 @@
+import type { Token } from "./tokenizer.js";
+import type { Expression, Module, SourceSpan, VariableDeclaration, VariableDeclarator } from "./parser.js";
+export type ExportNamedDeclaration = {
+    nodeId?: number;
+    type: "ExportNamedDeclaration";
+    declaration: VariableDeclaration;
+    span: SourceSpan;
+};
+export type ExportDefaultDeclaration = {
+    nodeId?: number;
+    type: "ExportDefaultDeclaration";
+    declaration: Expression;
+    span: SourceSpan;
+};
+export type ExtractedNamedExport = {
+    type: "named";
+    name: string;
+    declaration: VariableDeclarator;
+    statement: ExportNamedDeclaration;
+    span: SourceSpan;
+};
+export type ExtractedDefaultExport = {
+    type: "default";
+    name: "default";
+    declaration: Expression;
+    statement: ExportDefaultDeclaration;
+    span: SourceSpan;
+};
+export type ExtractedTopLevelExport = ExtractedDefaultExport | ExtractedNamedExport;
+export declare class ExportExtractionError extends Error {
+    readonly span?: SourceSpan;
+    constructor(message: string, span?: SourceSpan);
+}
+export declare function extractTopLevelExports(module: Module): ExtractedTopLevelExport[];
+export declare function createExportNamedDeclaration(exportToken: Token, declaration: VariableDeclaration): ExportNamedDeclaration;
+export declare function createExportDefaultDeclaration(exportToken: Token, declaration: Expression): ExportDefaultDeclaration;

package/dist/safe-js/parse/parser.d.ts

@@ -0,0 +1,356 @@
+import { type Position } from "./tokenizer.js";
+import { type ExportDefaultDeclaration, type ExportNamedDeclaration } from "./parse-export.js";
+import { type CompileOwner } from "../interp/budget.js";
+export type { ExportDefaultDeclaration, ExportNamedDeclaration } from "./parse-export.js";
+export type SourceSpan = {
+    start: Position;
+    end: Position;
+};
+export declare class DisallowedSyntaxError extends Error {
+    constructor(syntax: string, position: Position);
+}
+type BaseNode = {
+    nodeId?: number;
+    type: string;
+    span: SourceSpan;
+};
+export type Identifier = BaseNode & {
+    type: "Identifier";
+    name: string;
+};
+export type ThisExpression = BaseNode & {
+    type: "ThisExpression";
+};
+export type NumericLiteral = BaseNode & {
+    type: "NumericLiteral";
+    raw: string;
+    value: number;
+};
+export type StringLiteral = BaseNode & {
+    type: "StringLiteral";
+    raw: string;
+    value: string;
+};
+export type RegexLiteral = BaseNode & {
+    type: "RegexLiteral";
+    raw: string;
+};
+export type BooleanLiteral = BaseNode & {
+    type: "BooleanLiteral";
+    raw: "true" | "false";
+    value: boolean;
+};
+export type NullLiteral = BaseNode & {
+    type: "NullLiteral";
+    raw: "null";
+    value: null;
+};
+export type UndefinedLiteral = BaseNode & {
+    type: "UndefinedLiteral";
+    raw: "undefined";
+    value: undefined;
+    elision?: true;
+};
+export type TemplateElement = BaseNode & {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        raw: string;
+        cooked: string | undefined;
+    };
+};
+export type TemplateLiteral = BaseNode & {
+    type: "TemplateLiteral";
+    expressions: Expression[];
+    quasis: TemplateElement[];
+};
+export type TaggedTemplateExpression = BaseNode & {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+};
+export type SpreadElement = BaseNode & {
+    type: "SpreadElement";
+    argument: Expression;
+};
+export type Property = BaseNode & {
+    type: "Property";
+    computed: boolean;
+    shorthand: boolean;
+    key: Expression;
+    value: Expression;
+};
+export type PatternTarget = ArrayPattern | Identifier | MemberExpression | ObjectPattern;
+export type AssignmentTarget = MetaProperty | PatternTarget;
+export type UpdateTarget = Identifier | MemberExpression;
+export type AssignmentPattern = BaseNode & {
+    type: "AssignmentPattern";
+    left: PatternTarget;
+    right: Expression;
+};
+export type RestElement = BaseNode & {
+    type: "RestElement";
+    argument: PatternTarget;
+};
+export type AssignmentProperty = BaseNode & {
+    type: "AssignmentProperty";
+    computed: boolean;
+    shorthand: boolean;
+    key: Expression;
+    value: AssignmentPattern | ArrayPattern | Identifier | MemberExpression | ObjectPattern;
+};
+export type ArrayPattern = BaseNode & {
+    type: "ArrayPattern";
+    elements: Array<AssignmentPattern | ArrayPattern | Identifier | MemberExpression | ObjectPattern | RestElement | null>;
+};
+export type ObjectPattern = BaseNode & {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+};
+export type ArrayExpression = BaseNode & {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement>;
+};
+export type ObjectExpression = BaseNode & {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+};
+export type UnaryOperator = "!" | "+" | "-" | "~" | "delete" | "typeof" | "void";
+export type UnaryExpression = BaseNode & {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+};
+export type UpdateOperator = "++" | "--";
+export type UpdateExpression = BaseNode & {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    prefix: boolean;
+    argument: UpdateTarget;
+};
+export type AwaitExpression = BaseNode & {
+    type: "AwaitExpression";
+    argument: Expression;
+};
+export type YieldExpression = BaseNode & {
+    type: "YieldExpression";
+    argument?: Expression;
+    delegate: boolean;
+};
+export type BinaryOperator = "!=" | "!==" | "%" | "&" | "*" | "**" | "+" | "-" | "/" | "<" | "<<" | "<=" | "==" | "===" | ">" | ">=" | ">>" | ">>>" | "instanceof" | "in" | "^" | "|";
+export type BinaryExpression = BaseNode & {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+};
+export type LogicalOperator = "&&" | "??" | "||";
+export type LogicalExpression = BaseNode & {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+};
+export type ConditionalExpression = BaseNode & {
+    type: "ConditionalExpression";
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
+};
+export type SequenceExpression = BaseNode & {
+    type: "SequenceExpression";
+    expressions: Expression[];
+};
+export type MemberExpression = BaseNode & {
+    type: "MemberExpression";
+    computed: boolean;
+    object: Expression;
+    optional: boolean;
+    property: Expression;
+};
+export type MetaProperty = BaseNode & {
+    type: "MetaProperty";
+    meta: Identifier & {
+        name: "import";
+    };
+    property: Identifier & {
+        name: "meta";
+    };
+};
+export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "&=" | "|=" | "^=" | "<<=" | ">>=" | ">>>=" | "&&=" | "||=" | "??=";
+export type AssignmentExpression = BaseNode & {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: AssignmentTarget;
+    right: Expression;
+};
+export type CallExpression = BaseNode & {
+    type: "CallExpression";
+    arguments: Array<Expression | SpreadElement>;
+    callee: Expression;
+    optional: boolean;
+};
+export type NewExpression = BaseNode & {
+    type: "NewExpression";
+    arguments: Array<Expression | SpreadElement>;
+    callee: Expression;
+};
+export type VariableDeclarator = BaseNode & {
+    type: "VariableDeclarator";
+    id: ArrayPattern | Identifier | ObjectPattern;
+    init?: Expression;
+};
+export type VariableDeclarationKind = "const" | "let" | "var";
+export type VariableDeclaration = BaseNode & {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: VariableDeclarationKind;
+};
+export type ReturnStatement = BaseNode & {
+    type: "ReturnStatement";
+    argument?: Expression;
+};
+export type BreakStatement = BaseNode & {
+    type: "BreakStatement";
+    label?: string;
+};
+export type ContinueStatement = BaseNode & {
+    type: "ContinueStatement";
+    label?: string;
+};
+export type ExpressionStatement = BaseNode & {
+    type: "ExpressionStatement";
+    expression: Expression;
+};
+export type EmptyStatement = BaseNode & {
+    type: "EmptyStatement";
+};
+export type BlockStatement = BaseNode & {
+    type: "BlockStatement";
+    body: Statement[];
+};
+export type FunctionDeclaration = BaseNode & {
+    type: "FunctionDeclaration";
+    async: boolean;
+    body: BlockStatement;
+    generator: boolean;
+    id: Identifier;
+    params: ArrowFunctionExpression["params"];
+};
+export type FunctionExpression = BaseNode & {
+    type: "FunctionExpression";
+    async: boolean;
+    body: BlockStatement;
+    generator: boolean;
+    id?: Identifier;
+    method?: true;
+    params: ArrowFunctionExpression["params"];
+};
+export type IfStatement = BaseNode & {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement;
+};
+export type ForStatement = BaseNode & {
+    type: "ForStatement";
+    init?: Expression | VariableDeclaration;
+    test?: Expression;
+    update?: Expression;
+    body: Statement;
+    label?: string;
+    labels?: string[];
+};
+export type ForOfStatement = BaseNode & {
+    type: "ForOfStatement";
+    left: PatternTarget | VariableDeclaration;
+    right: Expression;
+    body: Statement;
+    label?: string;
+    labels?: string[];
+};
+export type ForInStatement = BaseNode & {
+    type: "ForInStatement";
+    left: Identifier | VariableDeclaration;
+    right: Expression;
+    body: Statement;
+    label?: string;
+    labels?: string[];
+};
+export type WhileStatement = BaseNode & {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+    label?: string;
+    labels?: string[];
+};
+export type DoWhileStatement = BaseNode & {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+    label?: string;
+    labels?: string[];
+};
+export type ThrowStatement = BaseNode & {
+    type: "ThrowStatement";
+    argument: Expression;
+};
+export type CatchClause = BaseNode & {
+    type: "CatchClause";
+    param?: ArrayPattern | Identifier | ObjectPattern;
+    body: BlockStatement;
+};
+export type TryStatement = BaseNode & {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause;
+    finalizer?: BlockStatement;
+};
+export type SwitchCase = BaseNode & {
+    type: "SwitchCase";
+    test?: Expression;
+    consequent: Statement[];
+};
+export type SwitchStatement = BaseNode & {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+};
+export type ImportSpecifier = BaseNode & {
+    type: "ImportSpecifier";
+    imported: Identifier;
+    local: Identifier;
+};
+export type ImportDefaultSpecifier = BaseNode & {
+    type: "ImportDefaultSpecifier";
+    local: Identifier;
+};
+export type ImportNamespaceSpecifier = BaseNode & {
+    type: "ImportNamespaceSpecifier";
+    local: Identifier;
+};
+export type ImportDeclaration = BaseNode & {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier>;
+    source: StringLiteral;
+};
+export type Module = BaseNode & {
+    type: "Module";
+    body: Statement[];
+};
+export type Statement = BlockStatement | BreakStatement | DoWhileStatement | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | TryStatement | ContinueStatement | EmptyStatement | ExpressionStatement | FunctionDeclaration | ForInStatement | ForOfStatement | ForStatement | IfStatement | ReturnStatement | SwitchStatement | ThrowStatement | VariableDeclaration | WhileStatement;
+export type ArrowFunctionExpression = BaseNode & {
+    type: "ArrowFunctionExpression";
+    async: boolean;
+    body: BlockStatement | Expression;
+    expression: boolean;
+    params: Array<AssignmentPattern | ArrayPattern | Identifier | ObjectPattern | RestElement>;
+};
+export type FunctionNode = ArrowFunctionExpression | FunctionDeclaration | FunctionExpression;
+export type Expression = ArrowFunctionExpression | AssignmentExpression | ArrayExpression | AwaitExpression | BinaryExpression | BooleanLiteral | CallExpression | ConditionalExpression | FunctionExpression | Identifier | LogicalExpression | MemberExpression | MetaProperty | NewExpression | NullLiteral | NumericLiteral | ObjectExpression | RegexLiteral | SequenceExpression | StringLiteral | TaggedTemplateExpression | TemplateLiteral | ThisExpression | UnaryExpression | UpdateExpression | UndefinedLiteral | YieldExpression;
+export type ParseResult = Expression | Statement;
+export declare function parse(source: string, filename?: string, owner?: CompileOwner): ParseResult;
+export declare function parseModule(source: string, filename?: string, owner?: CompileOwner): Module;
+export declare function parseExecutableModule(source: string, filename?: string, owner?: CompileOwner): Module;
+export declare function findRegexLiteral(node: unknown): RegexLiteral | undefined;

package/dist/safe-js/parse/tokenizer.d.ts

@@ -0,0 +1,26 @@
+import { type CompileScope } from "../interp/regex/compile-guard.js";
+export type Position = {
+    line: number;
+    column: number;
+    offset: number;
+};
+export type TokenType = "identifier" | "keyword" | "numeric" | "regex" | "string" | "template" | "punctuator" | "eof";
+export type Token = {
+    type: TokenType;
+    value: string;
+    start: Position;
+    end: Position;
+};
+export type Comment = {
+    type: "block" | "line";
+    value: string;
+    start: Position;
+    end: Position;
+};
+export type TokenizeOptions = {
+    allowRegexLiterals?: boolean;
+    comments?: Comment[];
+    compilation?: CompileScope;
+};
+export declare function tokenize(source: string, options?: TokenizeOptions): Token[];
+export declare function collectComments(source: string): Comment[];

package/dist/safe-js/parse.d.ts

@@ -0,0 +1,4 @@
+import { type ParseResult as ParsedNode } from "./parse/parser.js";
+export { DisallowedSyntaxError } from "./parse/parser.js";
+export declare const parse: (source: string, filename?: string) => ParsedNode;
+export type { ArrayPattern, ArrayExpression, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AssignmentProperty, AwaitExpression, BinaryExpression, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CatchClause, ConditionalExpression, ContinueStatement, DoWhileStatement, EmptyStatement, Expression, ExpressionStatement, ExportDefaultDeclaration, ExportNamedDeclaration, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, LogicalExpression, MemberExpression, MetaProperty, NewExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ParseResult, PatternTarget, Property, RegexLiteral, RestElement, ReturnStatement, SequenceExpression, SourceSpan, SpreadElement, Statement, StringLiteral, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UndefinedLiteral, UpdateExpression, UpdateTarget, VariableDeclaration, VariableDeclarationKind, VariableDeclarator, WhileStatement } from "./parse/parser.js";

package/dist/safe-js/random.d.ts

@@ -0,0 +1,9 @@
+import type { SafeJSSnapshot } from "./restore.js";
+import type { RunRandom } from "./run.js";
+export type ReplayableRandom = RunRandom & {
+    restore: (state: number) => void;
+};
+export declare function createReplayableRandom(options?: {
+    seed?: number;
+    snapshot?: SafeJSSnapshot;
+}): ReplayableRandom;

package/dist/safe-js/restore.d.ts

@@ -0,0 +1,26 @@
+import type { CompileOwner } from "./interp/budget.js";
+import { type SnapshotMigration } from "./snapshot/migration.js";
+export type SafeJSSnapshot = {
+    version?: number;
+    sourceHash: string;
+    migration?: SnapshotMigration;
+    clock?: {
+        next: number;
+    };
+    random?: {
+        seed: number;
+        state: number;
+        initialState?: number;
+        resumeState?: number;
+    };
+    [key: string]: unknown;
+};
+export type RestoreOptions = {
+    source: string;
+};
+export declare class SnapshotMismatchError extends Error {
+    readonly actualHash: string;
+    readonly expectedHash: string;
+    constructor(expectedHash: string, actualHash: string);
+}
+export declare function restore<TSnapshot extends SafeJSSnapshot>(snapshot: TSnapshot, options: RestoreOptions, owner?: CompileOwner): TSnapshot;

package/dist/safe-js/run.d.ts

@@ -0,0 +1,74 @@
+import { type ErrorSourceSpan } from "./error/shape.js";
+import { type SourceSpan } from "./parse/parser.js";
+import { type SafeJSSnapshot } from "./restore.js";
+import { Budget } from "./interp/budget.js";
+import { type PromiseReplaySnapshot } from "./interp/promise-replay.js";
+import { type HostCallRecord, type HostCallReplay, type HostCallResumeProvider } from "./interp/host-call.js";
+import { type ConsoleSink } from "./interp/globals/console-json.js";
+import { type CallerInjectedBinding } from "./interp/host-bridge.js";
+import { type InterpreterResult, type LoopIterationSnapshot } from "./interp/interpreter.js";
+import { type ModuleRegistry } from "./modules/registry.js";
+import { type OtelSink } from "./observability/otel.js";
+import type { SnapshotBackend } from "./snapshot/backend.js";
+import { type ReplayData } from "./snapshot/replay-data.js";
+export type RunOptions = {
+    bindings?: Record<string, CallerInjectedBinding>;
+    budget?: Budget;
+    clock?: RunClock;
+    entryPointArgs?: readonly unknown[];
+    filename?: string;
+    importMeta?: Record<string, unknown>;
+    hostCallResumeProvider?: HostCallResumeProvider;
+    modules?: ModuleRegistry;
+    random?: RunRandom;
+    randomSeed?: number;
+    otelSink?: OtelSink;
+    signal?: AbortSignal;
+    snapshot?: SafeJSSnapshot;
+    snapshotBackend?: SnapshotBackend;
+    snapshotIntervalMs?: number;
+    snapshotPath?: string;
+    sink?: ConsoleSink;
+};
+export declare class UnhandledRejectionError extends Error {
+    readonly reason: unknown;
+    constructor(reason: unknown, span?: ErrorSourceSpan);
+}
+export type RunSnapshot = SafeJSSnapshot & {
+    bindings: InterpreterResult["snapshot"]["bindings"];
+    clock?: RunClockSnapshot;
+    hostCalls?: HostCallRecord[];
+    replay?: HostCallReplay;
+    replayError?: string;
+    promiseReplay?: PromiseReplaySnapshot;
+    initialInputs?: ReplayData;
+    loopIterations?: Record<string, LoopIterationSnapshot>;
+    pendingAwaits?: RunPendingAwaitSnapshot[];
+    random?: {
+        seed: number;
+        state: number;
+        initialState?: number;
+        resumeState?: number;
+    };
+};
+export type RunPendingAwaitSnapshot = {
+    nodeId?: number;
+    span: SourceSpan;
+};
+export type RunClockSnapshot = {
+    next: number;
+};
+export type RunClock = {
+    snapshot: () => RunClockSnapshot | undefined;
+};
+export type RunRandom = {
+    next: () => number;
+    seed: number;
+    snapshot: () => number;
+};
+type WithRunSnapshot<TResult extends InterpreterResult> = TResult extends unknown ? Omit<TResult, "snapshot"> & {
+    snapshot: RunSnapshot;
+} : never;
+export type RunResult = WithRunSnapshot<InterpreterResult>;
+export declare function run(source: string, options?: RunOptions): Promise<RunResult>;
+export {};