@opencode/codemode 2.0.1 → 2.0.2

package/dist/interpreter/objects.js

@@ -1,42 +1,124 @@
 import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
+/** Ordinary assignment: writable, enumerable, configurable. */
+export const data = { writable: true, enumerable: true, configurable: true };
+/** Built-in methods and `constructor`: writable and configurable but hidden from enumeration. */
+export const hidden = { writable: true, enumerable: false, configurable: true };
+/** Function `name` and `length`: read-only but deletable. */
+export const readonly = { writable: false, enumerable: false, configurable: true };
+/** Constants such as `Math.PI` and a constructor's `prototype`. */
+export const frozen = { writable: false, enumerable: false, configurable: false };
 /** An object owned by the program: own properties plus a prototype link. */
 export class ProgramObject {
     proto;
     props = new Map();
-    constructor(proto = null) {
+    constructor(proto) {
         this.proto = proto;
     }
 }
 export class ProgramArray extends ProgramObject {
     items;
-    constructor(items = []) {
-        super();
+    constructor(proto, items = []) {
+        super(proto);
         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;
+export class Callable extends ProgramObject {
+    constructor(proto, name, length) {
+        super(proto);
+        define(this, "length", length, readonly);
+        define(this, "name", name, readonly);
+    }
+}
+export class ProgramFunction extends Callable {
     parameters;
     body;
     capturedScopes;
     async;
     generator;
-    length;
-    constructor(name, parameters, body, capturedScopes, async, generator) {
-        super();
-        this.name = name;
+    constructor(proto, name, parameters, body, capturedScopes, async, generator) {
+        const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
+        super(proto, name, optional === -1 ? parameters.length : optional);
         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;
     }
 }
+export class NativeFunction extends Callable {
+    call;
+    construct;
+    callback;
+    constructor(proto, options) {
+        super(proto, options.name, options.length ?? 0);
+        this.call = options.call;
+        this.construct = options.construct;
+        this.callback = options.callback ?? true;
+    }
+}
+export class ProgramPromise extends ProgramObject {
+    fiber;
+    constructor(proto, fiber) {
+        super(proto);
+        this.fiber = fiber;
+    }
+}
+export class ProgramGenerator extends ProgramObject {
+    asynchronous;
+    request;
+    constructor(proto, asynchronous, request) {
+        super(proto);
+        this.asynchronous = asynchronous;
+        this.request = request;
+    }
+}
+export class ProgramDate extends ProgramObject {
+    time;
+    constructor(proto, time) {
+        super(proto);
+        this.time = time;
+    }
+}
+export class ProgramRegExp extends ProgramObject {
+    regex;
+    constructor(proto, pattern, flags) {
+        super(proto);
+        this.regex = new RegExp(pattern, flags);
+        define(this, "lastIndex", 0, { writable: true, enumerable: false, configurable: false });
+    }
+}
+export class ProgramMap extends ProgramObject {
+    map = new Map();
+}
+export class ProgramSet extends ProgramObject {
+    set = new Set();
+}
+export class ProgramURLSearchParams extends ProgramObject {
+    params;
+    constructor(proto, params) {
+        super(proto);
+        this.params = params;
+    }
+}
+export class ProgramURL extends ProgramObject {
+    url;
+    searchParams;
+    constructor(proto, searchParamsProto, url) {
+        super(proto);
+        this.url = url;
+        this.searchParams = new ProgramURLSearchParams(searchParamsProto, url.searchParams);
+    }
+}
+/** Built-in objects that wrap a host value; data-like, but never plain data. */
+export const isWrapper = (value) => value instanceof ProgramDate ||
+    value instanceof ProgramRegExp ||
+    value instanceof ProgramMap ||
+    value instanceof ProgramSet ||
+    value instanceof ProgramURL ||
+    value instanceof ProgramURLSearchParams;
 const MAX_ARRAY_LENGTH = 4_294_967_295;
 export const parseArrayIndex = (key) => {
     const property = String(key);
@@ -47,79 +129,119 @@ export const parseArrayIndex = (key) => {
 };
 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) => {
+/** The own property under `key`, including an array's live indexes and `length`. */
+export const own = (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);
+    if (target instanceof ProgramArray) {
+        const at = index(target, name);
+        if (at !== undefined) {
+            return at in target.items ? { value: target.items[at], ...data } : undefined;
+        }
+        if (name === "length")
+            return { value: target.items.length, writable: true, enumerable: false, configurable: false };
+    }
+    return target.props.get(name);
 };
+const read = (slot, receiver) => "value" in slot ? slot.value : slot.get === undefined ? undefined : slot.get(receiver);
+export const hasOwn = (target, key) => own(target, key) !== undefined;
 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);
+    const slot = own(target, key);
+    return slot === undefined ? undefined : read(slot, target);
 };
-export const get = (target, key) => {
+/** [[Get]]: walks the prototype chain; accessors see `receiver`, which is the primitive for wrapper prototypes. */
+export const get = (target, key, receiver = target) => {
     for (let current = target; current !== null; current = current.proto) {
-        if (hasOwn(current, key))
-            return getOwn(current, key);
+        const slot = own(current, key);
+        if (slot !== undefined)
+            return read(slot, receiver);
     }
     return undefined;
 };
-export const hasPrototype = (value, proto) => {
-    for (let current = value instanceof ProgramObject ? value.proto : null; current !== null; current = current.proto) {
-        if (current === proto)
+export const has = (target, key) => {
+    for (let current = target; current !== null; current = current.proto) {
+        if (own(current, key) !== undefined)
             return true;
     }
     return false;
 };
-export const has = (target, key) => {
-    for (let current = target; current !== null; current = current.proto) {
-        if (hasOwn(current, key))
+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 set = (target, key, value) => {
-    const name = canonical(key);
+const writeArray = (target, name, value) => {
     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)
+    if (name !== "length")
+        return undefined;
+    const length = typeof value === "number" ? value : Number(value);
+    if (!Number.isInteger(length) || length < 0 || length > MAX_ARRAY_LENGTH)
+        return false;
+    target.items.length = length;
+    return true;
+};
+/** [[Set]]: an inherited setter or read-only property decides before an own data property is created. */
+export const set = (target, key, value) => {
+    const name = canonical(key);
+    for (let current = target; current !== null; current = current.proto) {
+        const slot = own(current, name);
+        if (slot === undefined)
+            continue;
+        if (!("value" in slot)) {
+            if (slot.set === undefined)
+                return false;
+            slot.set(target, value);
+            return true;
+        }
+        if (!slot.writable)
             return false;
-        target.items.length = length;
+        if (current !== target)
+            break;
+        if (target instanceof ProgramArray) {
+            const written = writeArray(target, name, value);
+            if (written !== undefined)
+                return written;
+        }
+        slot.value = value;
         return true;
     }
-    if (builtin(target, name))
-        return false;
-    target.props.set(name, value);
+    if (target instanceof ProgramArray) {
+        const written = writeArray(target, name, value);
+        if (written !== undefined)
+            return written;
+    }
+    target.props.set(name, { value, ...data });
     return true;
 };
+/** [[DefineOwnProperty]] for a data property, ignoring the chain. */
+export const define = (target, key, value, attrs = data) => {
+    const name = canonical(key);
+    if (target instanceof ProgramArray && writeArray(target, name, value) !== undefined)
+        return;
+    target.props.set(name, { value, ...attrs });
+};
+export const defineAccessor = (target, key, get, set) => {
+    target.props.set(canonical(key), { get, set, enumerable: false, configurable: 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))
+    if (target instanceof ProgramArray) {
+        const at = index(target, name);
+        if (at !== undefined)
+            return delete target.items[at];
+        if (name === "length")
+            return false;
+    }
+    const slot = target.props.get(name);
+    if (slot === undefined)
         return true;
+    if (!slot.configurable)
+        return false;
     target.props.delete(name);
     return true;
 };
@@ -128,27 +250,29 @@ 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) : []),
+        ...(target instanceof ProgramArray ? [...Object.keys(target.items), "length"] : []),
         ...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);
+const enumerable = (target, key) => own(target, key)?.enumerable === true;
+/** Own enumerable keys, including the iterator symbols; what spread and `Object.assign` copy. */
+export const enumerableKeys = (target) => ownKeys(target).filter((key) => (typeof key === "string" || key === IteratorSymbol || key === AsyncIteratorSymbol) && enumerable(target, key));
+/** Own enumerable string keys: `Object.keys`. */
+export const keys = (target) => ownKeys(target).filter((key) => typeof key === "string" && enumerable(target, key));
+/** Own enumerable string entries: `Object.entries` and serialization. */
+export const entries = (target) => keys(target).map((key) => [key, getOwn(target, key)]);
+export const record = (proto, fields) => {
+    const target = new ProgramObject(proto);
+    for (const [key, value] of Object.entries(fields))
+        define(target, key, value);
     return target;
 };
 export const assign = (target, source, skip) => {
-    for (const key of ownKeys(source)) {
+    for (const key of enumerableKeys(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

@@ -1,31 +1,30 @@
 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 AstNode, InterpreterRuntimeError } from "./model.js";
+import { ProgramObject, ProgramPromise } from "./objects.js";
 import { type Runner } from "./runner.js";
 export declare class PromiseRuntime<R> {
     private readonly scope;
+    private readonly proto;
     private readonly active;
     private readonly ids;
     private readonly observed;
     private readonly failures;
     private nextID;
-    constructor(scope: Scope.Scope);
+    constructor(scope: Scope.Scope, proto: ProgramObject);
     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>>;
+        promise?: ProgramPromise;
+    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<ProgramPromise, never, R>;
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<ProgramPromise, never, R>;
+    markObserved(promise: ProgramPromise): void;
+    await(promise: ProgramPromise): 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;
+    promise?: ProgramPromise;
 }) => 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>;
+export declare const resolvePromise: <R>(runner: Runner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<ProgramPromise, never, R>;
+export declare const promiseGlobal: <R>(runner: Runner<R>, promises: PromiseRuntime<R>) => import("./objects.js").NativeFunction<R>;

package/dist/interpreter/promises.js

@@ -1,26 +1,27 @@
 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 { InterpreterRuntimeError, ProgramThrow } from "./model.js";
+import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
+import { constructor, fn, methods, native, receiver, requiresNew } from "./native.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) => {
+const capability = (runner, name, settle) => fn(runner.prototypes, name, 1, (_, args) => {
     settle(args[0]);
     return undefined;
 });
 // Observation only controls rejection reporting; program completion interrupts all promise work.
 export class PromiseRuntime {
     scope;
+    proto;
     active = new Set();
     ids = new WeakMap();
     observed = new WeakSet();
     failures = new Map();
     nextID = 0;
-    constructor(scope) {
+    constructor(scope, proto) {
         this.scope = scope;
+        this.proto = proto;
     }
     // Resolution bodies need the promise's own identity to reject `resolve(promise)` self-resolution.
     createWithSelf(body) {
@@ -35,7 +36,7 @@ export class PromiseRuntime {
             // 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);
+                const promise = new ProgramPromise(this.proto, fiber);
                 this.active.add(promise);
                 this.ids.set(promise, id);
                 fiber.addObserver((exit) => {
@@ -86,7 +87,7 @@ export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaini
 export const resolvePromiseValue = (runner, value, node, own) => {
     if (own?.promise !== undefined && value === own.promise)
         return Effect.fail(selfResolutionError(node));
-    if (value instanceof Values.Promise)
+    if (value instanceof ProgramPromise)
         return runner.settlePromise(value);
     if (!(value instanceof ProgramObject))
         return Effect.succeed(value);
@@ -97,9 +98,9 @@ export const resolvePromiseValue = (runner, value, node, own) => {
         // 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));
+        const resolve = capability(runner, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
+        const reject = capability(runner, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason))));
+        const executed = yield* Effect.exit(runner.invokeCallable(then, value, [resolve, reject], node));
         if (!Exit.isSuccess(executed)) {
             if (Cause.hasInterruptsOnly(executed.cause))
                 return yield* Effect.failCause(executed.cause);
@@ -109,7 +110,7 @@ export const resolvePromiseValue = (runner, value, node, own) => {
     });
 };
 export const resolvePromise = (runner, promises, value, node) => {
-    if (value instanceof Values.Promise)
+    if (value instanceof ProgramPromise)
         return Effect.succeed(value);
     return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
 };
@@ -136,22 +137,25 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
             items.push(item);
         }
         if (name === "all") {
-            return new ProgramArray(yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
+            return new ProgramArray(runner.prototypes.Array, 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 }));
+                    outcomes.push(record(runner.prototypes.Object, { 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)) }));
+                outcomes.push(record(runner.prototypes.Object, {
+                    status: "rejected",
+                    reason: caughtErrorValue(runner, Cause.squash(exit.cause)),
+                }));
             }
             yield* Effect.yieldNow;
-            return new ProgramArray(outcomes);
+            return new ProgramArray(runner.prototypes.Array, outcomes);
         }
         if (name === "race") {
             if (items.length === 0) {
@@ -169,15 +173,16 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
         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 instanceMethod = (runner, promises, name, thisValue, args, node) => {
+    const method = `Promise.prototype.${name}`;
+    const promise = receiver(ProgramPromise, thisValue, method, node);
+    promises.markObserved(promise);
+    if (name === "finally") {
+        return chainFinally(runner, promises, 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 onFulfilled = name === "then" ? reactionHandler(args[0], method, node) : undefined;
+    const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method, node);
+    return chainReaction(runner, promises, promise, onFulfilled, onRejected, method, node);
 };
 const constructPromise = (runner, promises, executor, node) => {
     if (!(executor instanceof ProgramFunction)) {
@@ -186,9 +191,9 @@ const constructPromise = (runner, promises, executor, 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]));
+        const resolve = capability(runner, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
+        const reject = capability(runner, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
+        const executed = yield* Effect.exit(runner.invokeCallable(executor, undefined, [resolve, reject], node));
         if (!Exit.isSuccess(executed)) {
             if (Cause.hasInterruptsOnly(executed.cause))
                 return yield* Effect.failCause(executed.cause);
@@ -245,26 +250,27 @@ const chainFinally = (runner, promises, source, cleanup, method, node) => promis
     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({
+    const protos = runner.prototypes;
+    const proto = protos.Promise;
+    const promise = constructor(protos, proto, {
         name: "Promise",
+        length: 1,
         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);
-        },
+        construct: (args, _, node) => constructPromise(runner, promises, args[0], node),
     });
+    // Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
+    for (const name of promiseStatics) {
+        define(promise, name, native(protos, {
+            name,
+            length: 1,
+            call: (_, args, node) => invokePromiseMethod(runner, promises, name, args, node),
+            callback: false,
+        }), hidden);
+    }
+    methods(protos, proto, [
+        ["then", 2, (thisValue, args, node) => instanceMethod(runner, promises, "then", thisValue, args, node)],
+        ["catch", 1, (thisValue, args, node) => instanceMethod(runner, promises, "catch", thisValue, args, node)],
+        ["finally", 1, (thisValue, args, node) => instanceMethod(runner, promises, "finally", thisValue, args, node)],
+    ]);
+    return promise;
 };

package/dist/interpreter/references.d.ts

@@ -1,4 +1,5 @@
 import { type AstNode } from "./model.js";
+/** Values that cannot cross the data boundary. */
 export declare const isRuntimeReference: (value: unknown) => boolean;
 export declare const containsRuntimeReference: (value: unknown) => boolean;
 export declare const containsOpaqueReference: (value: unknown) => boolean;