@opencode/codemode 2.0.3 → 2.0.4

package/dist/interpreter/objects.js

@@ -1,4 +1,5 @@
-import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
+import { checkArrayLength } from "./limits.js";
+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. */
@@ -8,14 +9,14 @@ 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 {
+export class Obj {
     proto;
     props = new Map();
     constructor(proto) {
         this.proto = proto;
     }
 }
-export class ProgramArray extends ProgramObject {
+export class Arr extends Obj {
     items;
     constructor(proto, items = []) {
         super(proto);
@@ -23,16 +24,18 @@ export class ProgramArray extends ProgramObject {
     }
 }
 /** 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 ErrorObj extends Obj {
+    /** The interpreter failure this error materialized from, so rethrowing it keeps the diagnostic kind and location. */
+    host;
 }
-export class Callable extends ProgramObject {
+export class Callable extends Obj {
     constructor(proto, name, length) {
         super(proto);
         define(this, "length", length, readonly);
         define(this, "name", name, readonly);
     }
 }
-export class ProgramFunction extends Callable {
+export class Fn extends Callable {
     parameters;
     body;
     capturedScopes;
@@ -48,7 +51,7 @@ export class ProgramFunction extends Callable {
         this.generator = generator;
     }
 }
-export class NativeFunction extends Callable {
+export class Native extends Callable {
     call;
     construct;
     callback;
@@ -59,14 +62,14 @@ export class NativeFunction extends Callable {
         this.callback = options.callback ?? true;
     }
 }
-export class ProgramPromise extends ProgramObject {
+export class PromiseObj extends Obj {
     fiber;
     constructor(proto, fiber) {
         super(proto);
         this.fiber = fiber;
     }
 }
-export class ProgramGenerator extends ProgramObject {
+export class GeneratorObj extends Obj {
     asynchronous;
     request;
     constructor(proto, asynchronous, request) {
@@ -75,70 +78,82 @@ export class ProgramGenerator extends ProgramObject {
         this.request = request;
     }
 }
-export class ProgramDate extends ProgramObject {
+export class DateObj extends Obj {
     time;
     constructor(proto, time) {
         super(proto);
         this.time = time;
     }
 }
-export class ProgramRegExp extends ProgramObject {
+export class RegExpObj extends Obj {
     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 {
+export class MapObj extends Obj {
     map = new Map();
 }
-export class ProgramSet extends ProgramObject {
+export class SetObj extends Obj {
     set = new Set();
 }
-export class ProgramURLSearchParams extends ProgramObject {
+export class URLSearchParamsObj extends Obj {
     params;
     constructor(proto, params) {
         super(proto);
         this.params = params;
     }
 }
-export class ProgramURL extends ProgramObject {
+export class URLObj extends Obj {
     url;
     searchParams;
     constructor(proto, searchParamsProto, url) {
         super(proto);
         this.url = url;
-        this.searchParams = new ProgramURLSearchParams(searchParamsProto, url.searchParams);
+        this.searchParams = new URLSearchParamsObj(searchParamsProto, url.searchParams);
+    }
+}
+/** A `Uint8Array`: the host array does the byte clamping and ignores out-of-range writes, as JS does. */
+export class Bytes extends Obj {
+    bytes;
+    constructor(proto, bytes) {
+        super(proto);
+        this.bytes = bytes;
     }
 }
 /** 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 isWrapper = (value) => value instanceof DateObj ||
+    value instanceof RegExpObj ||
+    value instanceof MapObj ||
+    value instanceof SetObj ||
+    value instanceof URLObj ||
+    value instanceof URLSearchParamsObj ||
+    value instanceof Bytes;
+const MAX_ARRAY_INDEX = 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;
+    return index < MAX_ARRAY_INDEX ? index : undefined;
 };
 const canonical = (key) => (typeof key === "symbol" ? key : String(key));
-const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
+const isIndexed = (target) => target instanceof Arr || target instanceof Bytes;
+const elements = (target) => (target instanceof Arr ? target.items : target.bytes);
+const index = (target, key) => isIndexed(target) && typeof key === "string" ? parseArrayIndex(key) : undefined;
 /** The own property under `key`, including an array's live indexes and `length`. */
 export const own = (target, key) => {
     const name = canonical(key);
-    if (target instanceof ProgramArray) {
+    if (isIndexed(target)) {
         const at = index(target, name);
         if (at !== undefined) {
-            return at in target.items ? { value: target.items[at], ...data } : undefined;
+            const items = elements(target);
+            return at in items ? { value: items[at], ...data } : undefined;
         }
-        if (name === "length")
+        if (target instanceof Arr && name === "length") {
             return { value: target.items.length, writable: true, enumerable: false, configurable: false };
+        }
     }
     return target.props.get(name);
 };
@@ -165,23 +180,27 @@ export const has = (target, key) => {
     return false;
 };
 export const hasPrototype = (value, proto) => {
-    for (let current = value instanceof ProgramObject ? value.proto : null; current !== null; current = current.proto) {
+    for (let current = value instanceof Obj ? value.proto : null; current !== null; current = current.proto) {
         if (current === proto)
             return true;
     }
     return false;
 };
-const writeArray = (target, name, value) => {
+const writeElement = (target, name, value) => {
     const at = index(target, name);
     if (at !== undefined) {
-        target.items[at] = value;
+        if (target instanceof Bytes)
+            target.bytes[at] = typeof value === "number" ? value : Number(value);
+        else
+            target.items[at] = value;
         return true;
     }
-    if (name !== "length")
+    if (!(target instanceof Arr) || name !== "length")
         return undefined;
     const length = typeof value === "number" ? value : Number(value);
-    if (!Number.isInteger(length) || length < 0 || length > MAX_ARRAY_LENGTH)
+    if (!Number.isInteger(length) || length < 0)
         return false;
+    checkArrayLength(length);
     target.items.length = length;
     return true;
 };
@@ -202,16 +221,16 @@ export const set = (target, key, value) => {
             return false;
         if (current !== target)
             break;
-        if (target instanceof ProgramArray) {
-            const written = writeArray(target, name, value);
+        if (isIndexed(target)) {
+            const written = writeElement(target, name, value);
             if (written !== undefined)
                 return written;
         }
         slot.value = value;
         return true;
     }
-    if (target instanceof ProgramArray) {
-        const written = writeArray(target, name, value);
+    if (isIndexed(target)) {
+        const written = writeElement(target, name, value);
         if (written !== undefined)
             return written;
     }
@@ -221,7 +240,7 @@ export const set = (target, key, value) => {
 /** [[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)
+    if (isIndexed(target) && writeElement(target, name, value) !== undefined)
         return;
     target.props.set(name, { value, ...attrs });
 };
@@ -230,11 +249,11 @@ export const defineAccessor = (target, key, get, set) => {
 };
 export const remove = (target, key) => {
     const name = canonical(key);
-    if (target instanceof ProgramArray) {
+    if (isIndexed(target)) {
         const at = index(target, name);
         if (at !== undefined)
-            return delete target.items[at];
-        if (name === "length")
+            return target instanceof Bytes ? !(at in target.bytes) : delete target.items[at];
+        if (target instanceof Arr && name === "length")
             return false;
     }
     const slot = target.props.get(name);
@@ -250,7 +269,8 @@ 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), "length"] : []),
+        ...(isIndexed(target) ? Object.keys(elements(target)) : []),
+        ...(target instanceof Arr ? ["length"] : []),
         ...strings.filter((key) => parseArrayIndex(key) !== undefined).sort((a, b) => Number(a) - Number(b)),
         ...strings.filter((key) => parseArrayIndex(key) === undefined),
         ...symbols,
@@ -264,7 +284,7 @@ export const keys = (target) => ownKeys(target).filter((key) => typeof 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);
+    const target = new Obj(proto);
     for (const [key, value] of Object.entries(fields))
         define(target, key, value);
     return target;

package/dist/interpreter/promises.d.ts

@@ -1,9 +1,8 @@
 import { Effect, Exit, Scope } from "effect";
 import type { Diagnostic } from "../codemode.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> {
+import { Obj, PromiseObj } from "./objects.js";
+import type { Interpreter } from "./interpreter.js";
+export declare class Pending<R> {
     private readonly scope;
     private readonly proto;
     private readonly active;
@@ -11,20 +10,19 @@ export declare class PromiseRuntime<R> {
     private readonly observed;
     private readonly failures;
     private nextID;
-    constructor(scope: Scope.Scope, proto: ProgramObject);
+    constructor(scope: Scope.Scope, proto: Obj);
     createWithSelf(body: (self: {
-        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>>;
+        promise?: PromiseObj;
+    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<PromiseObj, never, R>;
+    markObserved(promise: PromiseObj): void;
+    await(promise: PromiseObj): 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?: ProgramPromise;
+export declare const resolvePromiseValue: <R>(ctx: Interpreter<R>, value: unknown, own?: {
+    promise?: PromiseObj;
 }) => Effect.Effect<unknown, unknown, 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>;
+export declare const resolvePromise: <R>(ctx: Interpreter<R>, value: unknown) => Effect.Effect<PromiseObj, never, R>;
+export declare const promiseGlobal: <R>(ctx: Interpreter<R>) => import("./objects.js").Native<R>;

package/dist/interpreter/promises.js

@@ -1,17 +1,18 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
-import { InterpreterRuntimeError, ProgramThrow } from "./model.js";
-import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
+import { MAX_PENDING_PROMISES } from "./limits.js";
+import { CallSite, Throw, rangeError, typeError } from "./model.js";
+import { Callable, define, get, hidden, Arr, Fn, Obj, PromiseObj, record } from "./objects.js";
 import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js";
-import { caughtErrorValue, createAggregateErrorValue, normalizeError } from "./errors.js";
+import { createAggregateErrorValue, locate, materialize, normalizeError } from "./errors.js";
 import { typeofValue } from "./references.js";
-import { applyCollectionCallback, isSupportedCallback } from "./runner.js";
+import { applyCollectionCallback, isSupportedCallback } from "./callback.js";
 // A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
-const capability = (runner, name, settle) => fn(runner.prototypes, name, 1, (_, args) => {
+const capability = (ctx, name, settle) => fn(ctx.builtins, name, 1, (_, args) => {
     settle(args[0]);
     return undefined;
 });
 // Observation only controls rejection reporting; program completion interrupts all promise work.
-export class PromiseRuntime {
+export class Pending {
     scope;
     proto;
     active = new Set();
@@ -32,11 +33,15 @@ export class PromiseRuntime {
         });
     }
     create(effect) {
-        return Effect.suspend(() => {
+        return Effect.flatMap(CallSite, (site) => {
+            if (this.active.size >= MAX_PENDING_PROMISES) {
+                throw rangeError(`Too many pending promises (limit ${MAX_PENDING_PROMISES}); await promises before creating more.`);
+            }
             // 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 ProgramPromise(this.proto, fiber);
+            const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site.node)));
+            return Effect.map(Effect.forkIn(body, this.scope, { startImmediately: true }), (fiber) => {
+                const promise = new PromiseObj(this.proto, fiber);
                 this.active.add(promise);
                 this.ids.set(promise, id);
                 fiber.addObserver((exit) => {
@@ -83,13 +88,13 @@ export class PromiseRuntime {
         });
     }
 }
-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 ProgramPromise)
-        return runner.settlePromise(value);
-    if (!(value instanceof ProgramObject))
+export const resolvePromiseValue = (ctx, value, own) => {
+    if (own?.promise !== undefined && value === own.promise) {
+        return Effect.die(typeError("Chaining cycle detected: a promise cannot resolve with itself."));
+    }
+    if (value instanceof PromiseObj)
+        return ctx.await(value);
+    if (!(value instanceof Obj))
         return Effect.succeed(value);
     const then = get(value, "then");
     if (typeofValue(then) !== "function")
@@ -98,102 +103,101 @@ 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(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));
+        const resolve = capability(ctx, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
+        const reject = capability(ctx, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(reason))));
+        const executed = yield* Effect.exit(ctx.call(then, value, [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 yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), node, own);
+        return yield* resolvePromiseValue(ctx, yield* Deferred.await(deferred), own);
     });
 };
-export const resolvePromise = (runner, promises, value, node) => {
-    if (value instanceof ProgramPromise)
+export const resolvePromise = (ctx, value) => {
+    if (value instanceof PromiseObj)
         return Effect.succeed(value);
-    return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
+    return ctx.pending.createWithSelf((self) => resolvePromiseValue(ctx, value, self));
 };
 const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
-const invokePromiseMethod = (runner, promises, name, args, node) => {
+const invokePromiseMethod = (ctx, name, args) => {
     if (name === "resolve") {
-        return resolvePromise(runner, promises, args[0], node);
+        return resolvePromise(ctx, args[0]);
     }
     if (name === "reject") {
-        return promises.create(Effect.fail(new ProgramThrow(args[0])));
+        return ctx.pending.create(Effect.fail(new Throw(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);
-        }
+    return ctx.pending.create(Effect.gen(function* () {
+        const cursor = yield* ctx.iterate(args[0]);
+        if (cursor === undefined)
+            throw typeError(`Promise.${name} expects an array or other synchronous iterable.`);
         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);
+            const item = yield* resolvePromise(ctx, step.value);
+            ctx.pending.markObserved(item);
             items.push(item);
         }
         if (name === "all") {
-            return new ProgramArray(runner.prototypes.Array, yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" })));
+            return new Arr(ctx.builtins.Array, yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(ctx.pending.await(item))), { concurrency: "unbounded" })));
         }
         if (name === "allSettled") {
             const outcomes = [];
             for (const item of items) {
-                const exit = yield* promises.await(item);
+                const exit = yield* ctx.pending.await(item);
                 if (Exit.isSuccess(exit)) {
-                    outcomes.push(record(runner.prototypes.Object, { status: "fulfilled", value: exit.value }));
+                    outcomes.push(record(ctx.builtins.Object, { status: "fulfilled", value: exit.value }));
                     continue;
                 }
                 if (Cause.hasInterruptsOnly(exit.cause))
                     return yield* Effect.failCause(exit.cause);
-                outcomes.push(record(runner.prototypes.Object, {
+                outcomes.push(record(ctx.builtins.Object, {
                     status: "rejected",
-                    reason: caughtErrorValue(runner, Cause.squash(exit.cause)),
+                    reason: materialize(ctx, Cause.squash(exit.cause)),
                 }));
             }
             yield* Effect.yieldNow;
-            return new ProgramArray(runner.prototypes.Array, outcomes);
+            return new Arr(ctx.builtins.Array, outcomes);
         }
         if (name === "race") {
             if (items.length === 0) {
-                throw new InterpreterRuntimeError("Promise.race([]) would never settle; provide at least one promise or value.", node);
+                throw typeError("Promise.race([]) would never settle; provide at least one promise or value.");
             }
-            return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => promises.await(item)))));
+            return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => ctx.pending.await(item)))));
         }
-        const flipped = items.map((item) => Effect.flatMap(promises.await(item), (exit) => {
+        const flipped = items.map((item) => Effect.flatMap(ctx.pending.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 Effect.succeed(materialize(ctx, 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))));
+        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new Throw(createAggregateErrorValue(ctx, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
     }));
 };
-const instanceMethod = (runner, promises, name, thisValue, args, node) => {
+const instanceMethod = (ctx, name, thisValue, args) => {
     const method = `Promise.prototype.${name}`;
-    const promise = receiver(ProgramPromise, thisValue, method, node);
-    promises.markObserved(promise);
+    const promise = receiver(PromiseObj, thisValue, method);
+    ctx.pending.markObserved(promise);
     if (name === "finally") {
-        return chainFinally(runner, promises, promise, reactionHandler(args[0], method, node), method, node);
+        return chainFinally(ctx, promise, reactionHandler(args[0], method), method);
     }
-    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 onFulfilled = name === "then" ? reactionHandler(args[0], method) : undefined;
+    const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method);
+    return chainReaction(ctx, promise, onFulfilled, onRejected, method);
 };
-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);
+const constructPromise = (ctx, executor) => {
+    if (!(executor instanceof Fn)) {
+        throw typeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).");
     }
     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(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));
+        const promise = yield* ctx.pending.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(ctx, value, self)));
+        const resolve = capability(ctx, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
+        const reject = capability(ctx, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new Throw(value))));
+        const executed = yield* Effect.exit(ctx.call(executor, undefined, [resolve, reject]));
         if (!Exit.isSuccess(executed)) {
             if (Cause.hasInterruptsOnly(executed.cause))
                 return yield* Effect.failCause(executed.cause);
@@ -210,67 +214,67 @@ class PromiseAnyFulfilled {
         this.value = value;
     }
 }
-const reactionHandler = (value, method, node) => {
+const reactionHandler = (value, method) => {
     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);
+        throw typeError(`${method} cannot use this callable as a handler; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`);
     }
     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);
+const reactionExit = (ctx, source) => Effect.gen(function* () {
+    const exit = yield* ctx.pending.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 chainReaction = (ctx, source, onFulfilled, onRejected, method) => {
+    return ctx.pending.createWithSelf((self) => Effect.gen(function* () {
+        const exit = yield* reactionExit(ctx, 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 input = Exit.isSuccess(exit) ? exit.value : materialize(ctx, Cause.squash(exit.cause));
+        const result = yield* applyCollectionCallback(ctx, handler, method)([input]);
+        return yield* resolvePromiseValue(ctx, result, self);
     }));
 };
-const chainFinally = (runner, promises, source, cleanup, method, node) => promises.create(Effect.gen(function* () {
-    const exit = yield* reactionExit(promises, source);
+const chainFinally = (ctx, source, cleanup, method) => ctx.pending.create(Effect.gen(function* () {
+    const exit = yield* reactionExit(ctx, 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));
+        const result = yield* applyCollectionCallback(ctx, cleanup, method)([]);
+        const intermediate = yield* ctx.pending.create(Effect.gen(function* () {
+            yield* ctx.await(yield* resolvePromise(ctx, result));
             return yield* exit;
         }));
-        return yield* runner.settlePromise(intermediate);
+        return yield* ctx.await(intermediate);
     }
     return yield* exit;
 }));
-export const promiseGlobal = (runner, promises) => {
-    const protos = runner.prototypes;
-    const proto = protos.Promise;
-    const promise = constructor(protos, proto, {
+export const promiseGlobal = (ctx) => {
+    const builtins = ctx.builtins;
+    const proto = builtins.Promise;
+    const promise = constructor(builtins, proto, {
         name: "Promise",
         length: 1,
         call: requiresNew("Promise"),
-        construct: (args, _, node) => constructPromise(runner, promises, args[0], node),
+        construct: (args) => constructPromise(ctx, args[0]),
     });
     // Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
     for (const name of promiseStatics) {
-        define(promise, name, native(protos, {
+        define(promise, name, native(builtins, {
             name,
             length: 1,
-            call: (_, args, node) => invokePromiseMethod(runner, promises, name, args, node),
+            call: (_, args) => invokePromiseMethod(ctx, name, args),
             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)],
+    methods(builtins, proto, [
+        ["then", 2, (thisValue, args) => instanceMethod(ctx, "then", thisValue, args)],
+        ["catch", 1, (thisValue, args) => instanceMethod(ctx, "catch", thisValue, args)],
+        ["finally", 1, (thisValue, args) => instanceMethod(ctx, "finally", thisValue, args)],
     ]);
     return promise;
 };

package/dist/interpreter/references.d.ts

@@ -1,8 +1,7 @@
-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;
-export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, node: AstNode, seen?: Set<object>) => void;
+export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, seen?: Set<object>) => void;
 export declare const describeValue: (value: unknown) => string;
 export declare const typeofValue: (value: unknown) => string;