@opencode/codemode 0.0.0-reserved → 2.0.1

package/dist/interpreter/model.d.ts

@@ -0,0 +1,89 @@
+import type { Node } from "acorn";
+import type { ErrorType } from "./intrinsics.js";
+import type { Effect } from "effect";
+import type { DiagnosticKind } from "../codemode.js";
+import type { ProgramObject } from "./objects.js";
+import type { Values } from "../values.js";
+/** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
+export type AstNode = Node;
+export type Binding = {
+    mutable: boolean;
+    value: unknown;
+    initialized?: boolean;
+};
+export type StatementResult = {
+    kind: "none";
+} | {
+    kind: "return";
+    value: unknown;
+} | {
+    kind: "break";
+    label?: string;
+} | {
+    kind: "continue";
+    label?: string;
+};
+export type MemberReference = {
+    target: ProgramObject | Values.RegExp | Values.URL;
+    key: PropertyKey;
+};
+export type GeneratorRequestKind = "next" | "return" | "throw";
+export declare class CodeModeGenerator {
+    readonly asynchronous: boolean;
+    readonly request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>;
+    constructor(asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>);
+}
+export declare class GeneratorMethodReference {
+    readonly generator: CodeModeGenerator;
+    readonly kind: GeneratorRequestKind | "iterator";
+    constructor(generator: CodeModeGenerator, kind: GeneratorRequestKind | "iterator");
+}
+export declare class IntrinsicReference {
+    readonly receiver: unknown;
+    readonly name: string;
+    constructor(receiver: unknown, name: string);
+}
+export declare class ComputedValue {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare const AsyncIteratorSymbol: unique symbol;
+export declare const IteratorSymbol: unique symbol;
+export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
+export type PromiseInstanceMethodName = "then" | "catch" | "finally";
+export declare class PromiseInstanceMethodReference {
+    readonly promise: Values.Promise;
+    readonly name: PromiseInstanceMethodName;
+    constructor(promise: Values.Promise, name: PromiseInstanceMethodName);
+}
+export declare class ProgramThrow {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare class GeneratorReturn {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare const OptionalShortCircuit: unique symbol;
+export declare class InterpreterRuntimeError extends Error {
+    readonly kind: DiagnosticKind;
+    readonly suggestions?: ReadonlyArray<string> | undefined;
+    /** The JS error class a program sees when it catches this failure. */
+    readonly type: ErrorType;
+    readonly node?: AstNode;
+    constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined, 
+    /** The JS error class a program sees when it catches this failure. */
+    type?: ErrorType);
+}
+export declare const rangeError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+export declare const referenceError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+export declare const syntaxError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+export declare const uriError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+export declare const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
+export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const sourceLocation: (node: AstNode) => {
+    readonly line: number;
+    readonly column: number;
+};
+export declare const formatLocation: (node?: AstNode) => string;

package/dist/interpreter/model.js

@@ -0,0 +1,90 @@
+export class CodeModeGenerator {
+    asynchronous;
+    request;
+    constructor(asynchronous, request) {
+        this.asynchronous = asynchronous;
+        this.request = request;
+    }
+}
+export class GeneratorMethodReference {
+    generator;
+    kind;
+    constructor(generator, kind) {
+        this.generator = generator;
+        this.kind = kind;
+    }
+}
+export class IntrinsicReference {
+    receiver;
+    name;
+    constructor(receiver, name) {
+        this.receiver = receiver;
+        this.name = name;
+    }
+}
+export class ComputedValue {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export const AsyncIteratorSymbol = Symbol("codemode.async-iterator");
+export const IteratorSymbol = Symbol("codemode.iterator");
+export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol];
+export class PromiseInstanceMethodReference {
+    promise;
+    name;
+    constructor(promise, name) {
+        this.promise = promise;
+        this.name = name;
+    }
+}
+export class ProgramThrow {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export class GeneratorReturn {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
+export class InterpreterRuntimeError extends Error {
+    kind;
+    suggestions;
+    type;
+    node;
+    constructor(message, node, kind = "ExecutionFailure", suggestions, 
+    /** The JS error class a program sees when it catches this failure. */
+    type = "TypeError") {
+        super(message);
+        this.kind = kind;
+        this.suggestions = suggestions;
+        this.type = type;
+        this.name = "InterpreterRuntimeError";
+        if (node)
+            this.node = node;
+    }
+}
+const failure = (type) => (message, node) => new InterpreterRuntimeError(message, node, "ExecutionFailure", undefined, type);
+export const rangeError = failure("RangeError");
+export const referenceError = failure("ReferenceError");
+export const syntaxError = failure("SyntaxError");
+export const uriError = failure("URIError");
+// Orient the agent rather than enumerate JavaScript; interpreter-support.md is the full matrix.
+export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
+export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage], "SyntaxError");
+export const isRecord = (value) => typeof value === "object" && value !== null;
+export const sourceLocation = (node) => ({
+    line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
+    column: Math.max(1, (node.loc?.start.column ?? 4) - 3),
+});
+export const formatLocation = (node) => {
+    if (!node?.loc)
+        return "";
+    const location = sourceLocation(node);
+    return ` (line ${location.line}, col ${location.column})`;
+};

package/dist/interpreter/objects.d.ts

@@ -0,0 +1,37 @@
+import type { BlockStatement, Expression, Pattern } from "acorn";
+import { type Binding } from "./model.js";
+/** An object owned by the program: own properties plus a prototype link. */
+export declare class ProgramObject {
+    proto: ProgramObject | null;
+    readonly props: Map<PropertyKey, unknown>;
+    constructor(proto?: ProgramObject | null);
+}
+export declare class ProgramArray extends ProgramObject {
+    readonly items: Array<unknown>;
+    constructor(items?: Array<unknown>);
+}
+/** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
+export declare class ProgramError extends ProgramObject {
+}
+export declare class ProgramFunction extends ProgramObject {
+    readonly name: string;
+    readonly parameters: ReadonlyArray<Pattern>;
+    readonly body: BlockStatement | Expression;
+    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
+    readonly async: boolean;
+    readonly generator: boolean;
+    readonly length: number;
+    constructor(name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+}
+export declare const parseArrayIndex: (key: string | number) => number | undefined;
+export declare const hasOwn: (target: ProgramObject, key: PropertyKey) => boolean;
+export declare const getOwn: (target: ProgramObject, key: PropertyKey) => unknown;
+export declare const get: (target: ProgramObject, key: PropertyKey) => unknown;
+export declare const hasPrototype: (value: unknown, proto: ProgramObject) => boolean;
+export declare const has: (target: ProgramObject, key: PropertyKey) => boolean;
+export declare const set: (target: ProgramObject, key: PropertyKey, value: unknown) => boolean;
+export declare const remove: (target: ProgramObject, key: PropertyKey) => boolean;
+export declare const ownKeys: (target: ProgramObject) => Array<string | symbol>;
+export declare const ownEntries: (target: ProgramObject) => Array<[string, unknown]>;
+export declare const record: (entries: Record<string, unknown>) => ProgramObject;
+export declare const assign: (target: ProgramObject, source: ProgramObject, skip?: ReadonlySet<PropertyKey>) => void;

package/dist/interpreter/objects.js

@@ -0,0 +1,154 @@
+import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
+/** An object owned by the program: own properties plus a prototype link. */
+export class ProgramObject {
+    proto;
+    props = new Map();
+    constructor(proto = null) {
+        this.proto = proto;
+    }
+}
+export class ProgramArray extends ProgramObject {
+    items;
+    constructor(items = []) {
+        super();
+        this.items = items;
+    }
+}
+/** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
+export class ProgramError extends ProgramObject {
+}
+export class ProgramFunction extends ProgramObject {
+    name;
+    parameters;
+    body;
+    capturedScopes;
+    async;
+    generator;
+    length;
+    constructor(name, parameters, body, capturedScopes, async, generator) {
+        super();
+        this.name = name;
+        this.parameters = parameters;
+        this.body = body;
+        this.capturedScopes = capturedScopes;
+        this.async = async;
+        this.generator = generator;
+        const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
+        this.length = optional === -1 ? parameters.length : optional;
+    }
+}
+const MAX_ARRAY_LENGTH = 4_294_967_295;
+export const parseArrayIndex = (key) => {
+    const property = String(key);
+    if (!/^(0|[1-9]\d*)$/.test(property))
+        return undefined;
+    const index = Number(property);
+    return index < MAX_ARRAY_LENGTH ? index : undefined;
+};
+const canonical = (key) => (typeof key === "symbol" ? key : String(key));
+const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
+// Non-enumerable built-in properties: array length, function name and length.
+const builtin = (target, name) => (name === "length" && target instanceof ProgramArray) ||
+    ((name === "name" || name === "length") && target instanceof ProgramFunction);
+export const hasOwn = (target, key) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined)
+        return at in target.items;
+    return builtin(target, name) || target.props.has(name);
+};
+export const getOwn = (target, key) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined)
+        return target.items[at];
+    if (target instanceof ProgramArray && name === "length")
+        return target.items.length;
+    if (target instanceof ProgramFunction && name === "name")
+        return target.name;
+    if (target instanceof ProgramFunction && name === "length")
+        return target.length;
+    return target.props.get(name);
+};
+export const get = (target, key) => {
+    for (let current = target; current !== null; current = current.proto) {
+        if (hasOwn(current, key))
+            return getOwn(current, key);
+    }
+    return undefined;
+};
+export const hasPrototype = (value, proto) => {
+    for (let current = value instanceof ProgramObject ? value.proto : null; current !== null; current = current.proto) {
+        if (current === proto)
+            return true;
+    }
+    return false;
+};
+export const has = (target, key) => {
+    for (let current = target; current !== null; current = current.proto) {
+        if (hasOwn(current, key))
+            return true;
+    }
+    return false;
+};
+export const set = (target, key, value) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined) {
+        ;
+        target.items[at] = value;
+        return true;
+    }
+    if (name === "length" && target instanceof ProgramArray) {
+        const length = typeof value === "number" ? value : Number(value);
+        if (!Number.isInteger(length) || length < 0 || length > 4_294_967_295)
+            return false;
+        target.items.length = length;
+        return true;
+    }
+    if (builtin(target, name))
+        return false;
+    target.props.set(name, value);
+    return true;
+};
+export const remove = (target, key) => {
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined)
+        return delete target.items[at];
+    if (name === "length" && target instanceof ProgramArray)
+        return false;
+    if (builtin(target, name))
+        return true;
+    target.props.delete(name);
+    return true;
+};
+// JS order: array indexes, integer-like keys ascending, other strings, then symbols.
+export const ownKeys = (target) => {
+    const strings = [...target.props.keys()].filter((key) => typeof key === "string");
+    const symbols = [...target.props.keys()].filter((key) => typeof key === "symbol");
+    return [
+        ...(target instanceof ProgramArray ? Object.keys(target.items) : []),
+        ...strings.filter((key) => parseArrayIndex(key) !== undefined).sort((a, b) => Number(a) - Number(b)),
+        ...strings.filter((key) => parseArrayIndex(key) === undefined),
+        ...symbols,
+    ];
+};
+export const ownEntries = (target) => ownKeys(target)
+    .filter((key) => typeof key === "string")
+    .map((key) => [key, getOwn(target, key)]);
+export const record = (entries) => {
+    const target = new ProgramObject();
+    for (const [key, value] of Object.entries(entries))
+        set(target, key, value);
+    return target;
+};
+export const assign = (target, source, skip) => {
+    for (const key of ownKeys(source)) {
+        if (skip?.has(key))
+            continue;
+        if (typeof key === "symbol" && key !== IteratorSymbol && key !== AsyncIteratorSymbol)
+            continue;
+        set(target, key, getOwn(source, key));
+    }
+};

package/dist/interpreter/promises.d.ts

@@ -0,0 +1,31 @@
+import { Effect, Exit, Scope } from "effect";
+import type { Diagnostic } from "../codemode.js";
+import { type AstNode, InterpreterRuntimeError, PromiseInstanceMethodReference } from "./model.js";
+import { HostFunction } from "./host.js";
+import { Values } from "../values.js";
+import { type Runner } from "./runner.js";
+export declare class PromiseRuntime<R> {
+    private readonly scope;
+    private readonly active;
+    private readonly ids;
+    private readonly observed;
+    private readonly failures;
+    private nextID;
+    constructor(scope: Scope.Scope);
+    createWithSelf(body: (self: {
+        promise?: Values.Promise;
+    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R>;
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R>;
+    markObserved(promise: Values.Promise): void;
+    await(promise: Values.Promise): Effect.Effect<Exit.Exit<unknown, unknown>>;
+    fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R>;
+    diagnostics(): Array<Diagnostic>;
+    interrupt(): Effect.Effect<Array<Diagnostic>>;
+}
+export declare const selfResolutionError: (node?: AstNode) => InterpreterRuntimeError;
+export declare const resolvePromiseValue: <R>(runner: Runner<R>, value: unknown, node: AstNode, own?: {
+    promise?: Values.Promise;
+}) => Effect.Effect<unknown, unknown, R>;
+export declare const resolvePromise: <R>(runner: Runner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<Values.Promise, never, R>;
+export declare const invokePromiseInstanceMethod: <R>(runner: Runner<R>, promises: PromiseRuntime<R>, ref: PromiseInstanceMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<Values.Promise, never, R>;
+export declare const promiseGlobal: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => HostFunction<R>;

package/dist/interpreter/promises.js

@@ -0,0 +1,270 @@
+import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
+import { InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference } from "./model.js";
+import { get, ProgramArray, ProgramFunction, ProgramObject, record } from "./objects.js";
+import { HostFunction, requiresNew, sync } from "./host.js";
+import { caughtErrorValue, createAggregateErrorValue, normalizeError } from "./errors.js";
+import { typeofValue } from "./references.js";
+import { Values } from "../values.js";
+import { applyCollectionCallback, isSupportedCallback } from "./runner.js";
+// A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
+const capability = (name, settle) => sync(name, (args) => {
+    settle(args[0]);
+    return undefined;
+});
+// Observation only controls rejection reporting; program completion interrupts all promise work.
+export class PromiseRuntime {
+    scope;
+    active = new Set();
+    ids = new WeakMap();
+    observed = new WeakSet();
+    failures = new Map();
+    nextID = 0;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    // Resolution bodies need the promise's own identity to reject `resolve(promise)` self-resolution.
+    createWithSelf(body) {
+        const self = {};
+        return Effect.map(this.create(body(self)), (promise) => {
+            self.promise = promise;
+            return promise;
+        });
+    }
+    create(effect) {
+        return Effect.suspend(() => {
+            // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
+            const id = this.nextID++;
+            return Effect.map(Effect.forkIn(effect, this.scope, { startImmediately: true }), (fiber) => {
+                const promise = new Values.Promise(fiber);
+                this.active.add(promise);
+                this.ids.set(promise, id);
+                fiber.addObserver((exit) => {
+                    this.active.delete(promise);
+                    if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) || this.observed.has(promise)) {
+                        this.ids.delete(promise);
+                        return;
+                    }
+                    const failure = normalizeError(Cause.squash(exit.cause));
+                    this.failures.set(id, {
+                        ...failure,
+                        message: `Unhandled rejection from an un-awaited promise: ${failure.message}`,
+                    });
+                });
+                return promise;
+            });
+        });
+    }
+    // Observation must be recorded when responsibility transfers, before the consumer fiber runs.
+    markObserved(promise) {
+        this.observed.add(promise);
+        const id = this.ids.get(promise);
+        this.ids.delete(promise);
+        if (id !== undefined)
+            this.failures.delete(id);
+    }
+    await(promise) {
+        return Fiber.await(promise.fiber);
+    }
+    fork(effect) {
+        return Effect.asVoid(Effect.forkIn(effect, this.scope, { startImmediately: true }));
+    }
+    diagnostics() {
+        return [...this.failures].sort(([left], [right]) => left - right).map(([, failure]) => failure);
+    }
+    // Re-check because a straggler can create promises before its interruption lands.
+    interrupt() {
+        const self = this;
+        return Effect.gen(function* () {
+            while (self.active.size > 0) {
+                yield* Fiber.interruptAll([...self.active].map((promise) => promise.fiber));
+            }
+            return self.diagnostics();
+        });
+    }
+}
+export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node);
+export const resolvePromiseValue = (runner, value, node, own) => {
+    if (own?.promise !== undefined && value === own.promise)
+        return Effect.fail(selfResolutionError(node));
+    if (value instanceof Values.Promise)
+        return runner.settlePromise(value);
+    if (!(value instanceof ProgramObject))
+        return Effect.succeed(value);
+    const then = get(value, "then");
+    if (typeofValue(then) !== "function")
+        return Effect.succeed(value);
+    return Effect.gen(function* () {
+        // Promise resolution invokes a thenable's method in a later job.
+        yield* Effect.yieldNow;
+        const deferred = Deferred.makeUnsafe();
+        const resolve = capability("resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
+        const reject = capability("reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason))));
+        const executed = yield* Effect.exit(runner.invokeCallable(then, [resolve, reject], node));
+        if (!Exit.isSuccess(executed)) {
+            if (Cause.hasInterruptsOnly(executed.cause))
+                return yield* Effect.failCause(executed.cause);
+            Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
+        }
+        return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), node, own);
+    });
+};
+export const resolvePromise = (runner, promises, value, node) => {
+    if (value instanceof Values.Promise)
+        return Effect.succeed(value);
+    return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
+};
+const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
+const invokePromiseMethod = (runner, promises, name, args, node) => {
+    if (name === "resolve") {
+        return resolvePromise(runner, promises, args[0], node);
+    }
+    if (name === "reject") {
+        return promises.create(Effect.fail(new ProgramThrow(args[0])));
+    }
+    return promises.create(Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(args[0], node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError(`Promise.${name} expects an array or other synchronous iterable.`, node);
+        }
+        const items = [];
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                break;
+            const item = yield* resolvePromise(runner, promises, step.value, node);
+            promises.markObserved(item);
+            items.push(item);
+        }
+        if (name === "all") {
+            return new ProgramArray(yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
+        }
+        if (name === "allSettled") {
+            const outcomes = [];
+            for (const item of items) {
+                const exit = yield* promises.await(item);
+                if (Exit.isSuccess(exit)) {
+                    outcomes.push(record({ status: "fulfilled", value: exit.value }));
+                    continue;
+                }
+                if (Cause.hasInterruptsOnly(exit.cause))
+                    return yield* Effect.failCause(exit.cause);
+                outcomes.push(record({ status: "rejected", reason: caughtErrorValue(runner, Cause.squash(exit.cause)) }));
+            }
+            yield* Effect.yieldNow;
+            return new ProgramArray(outcomes);
+        }
+        if (name === "race") {
+            if (items.length === 0) {
+                throw new InterpreterRuntimeError("Promise.race([]) would never settle; provide at least one promise or value.", node);
+            }
+            return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => promises.await(item)))));
+        }
+        const flipped = items.map((item) => Effect.flatMap(promises.await(item), (exit) => {
+            if (Exit.isSuccess(exit))
+                return Effect.fail(new PromiseAnyFulfilled(exit.value));
+            if (Cause.hasInterruptsOnly(exit.cause))
+                return Effect.failCause(exit.cause);
+            return Effect.succeed(caughtErrorValue(runner, Cause.squash(exit.cause)));
+        }));
+        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(runner, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
+    }));
+};
+export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) => {
+    const method = `Promise.prototype.${ref.name}`;
+    promises.markObserved(ref.promise);
+    if (ref.name === "finally") {
+        return chainFinally(runner, promises, ref.promise, reactionHandler(args[0], method, node), method, node);
+    }
+    const onFulfilled = ref.name === "then" ? reactionHandler(args[0], method, node) : undefined;
+    const onRejected = reactionHandler(ref.name === "then" ? args[1] : args[0], method, node);
+    return chainReaction(runner, promises, ref.promise, onFulfilled, onRejected, method, node);
+};
+const constructPromise = (runner, promises, executor, node) => {
+    if (!(executor instanceof ProgramFunction)) {
+        throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node);
+    }
+    return Effect.gen(function* () {
+        const deferred = Deferred.makeUnsafe();
+        const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, self)));
+        const resolve = capability("resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
+        const reject = capability("reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
+        const executed = yield* Effect.exit(runner.invokeFunction(executor, [resolve, reject]));
+        if (!Exit.isSuccess(executed)) {
+            if (Cause.hasInterruptsOnly(executed.cause))
+                return yield* Effect.failCause(executed.cause);
+            Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
+        }
+        return promise;
+    });
+};
+// Settle one reaction turn after the deciding member, after its existing reactions.
+const settleAfterTurn = (body) => Effect.flatMap(Effect.exit(body), (exit) => Effect.andThen(Effect.yieldNow, exit));
+class PromiseAnyFulfilled {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+const reactionHandler = (value, method, node) => {
+    if (isSupportedCallback(value))
+        return value;
+    if (typeofValue(value) === "function") {
+        throw new InterpreterRuntimeError(`${method} cannot use this callable as a handler; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
+    }
+    return undefined;
+};
+// Teardown bypasses handlers; settled reactions yield once so handlers never run inline.
+const reactionExit = (promises, source) => Effect.gen(function* () {
+    const exit = yield* promises.await(source);
+    if (!Exit.isSuccess(exit) && Cause.hasInterruptsOnly(exit.cause))
+        return yield* Effect.failCause(exit.cause);
+    yield* Effect.yieldNow;
+    return exit;
+});
+const chainReaction = (runner, promises, source, onFulfilled, onRejected, method, node) => {
+    return promises.createWithSelf((self) => Effect.gen(function* () {
+        const exit = yield* reactionExit(promises, source);
+        const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
+        if (handler === undefined)
+            return yield* exit;
+        const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(runner, Cause.squash(exit.cause));
+        const result = yield* applyCollectionCallback(runner, handler, method, node)([input]);
+        return yield* resolvePromiseValue(runner, result, node, self);
+    }));
+};
+const chainFinally = (runner, promises, source, cleanup, method, node) => promises.create(Effect.gen(function* () {
+    const exit = yield* reactionExit(promises, source);
+    if (cleanup !== undefined) {
+        const result = yield* applyCollectionCallback(runner, cleanup, method, node)([]);
+        const intermediate = yield* promises.create(Effect.gen(function* () {
+            yield* runner.settlePromise(yield* resolvePromise(runner, promises, result, node));
+            return yield* exit;
+        }));
+        return yield* runner.settlePromise(intermediate);
+    }
+    return yield* exit;
+}));
+export const promiseGlobal = (runner, promises) => {
+    // Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
+    const statics = new Map(promiseStatics.map((name) => [
+        name,
+        new HostFunction({
+            name: `Promise.${name}`,
+            call: (args, node) => invokePromiseMethod(runner, promises, name, args, node),
+            callback: false,
+        }),
+    ]));
+    return new HostFunction({
+        name: "Promise",
+        call: requiresNew("Promise"),
+        construct: (args, node) => constructPromise(runner, promises, args[0], node),
+        instanceOf: (value) => value instanceof Values.Promise,
+        // Unknown statics fail loudly so a missing await cannot hide behind `undefined`.
+        members: (key, node) => {
+            const method = typeof key === "string" ? statics.get(key) : undefined;
+            if (method !== undefined)
+                return method;
+            throw new InterpreterRuntimeError(`Promise.${String(key)} is not available. Available: Promise.all, Promise.allSettled, Promise.race, Promise.any, Promise.resolve, and Promise.reject; consume promises with await.`, node);
+        },
+    });
+};