@opencode/codemode 0.0.0-beta-19500 → 0.0.0-dev-19274

package/dist/interpreter/model.d.ts

@@ -1,10 +1,23 @@
-import type { Node } from "acorn";
 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;
+import type { SafeObject } from "../tool-runtime.js";
+import type { CodeModePromise, CodeModeRegExp, CodeModeURL } from "../values.js";
+export type SourcePosition = {
+    line: number;
+    column: number;
+};
+export type SourceLocation = {
+    start: SourcePosition;
+    end: SourcePosition;
+};
+export type AstNode = {
+    type: string;
+    loc?: SourceLocation;
+    [key: string]: unknown;
+};
+export type ProgramNode = AstNode & {
+    type: "Program";
+    body: Array<AstNode>;
+};
 export type Binding = {
     mutable: boolean;
     value: unknown;
@@ -23,9 +36,17 @@ export type StatementResult = {
     label?: string;
 };
 export type MemberReference = {
-    target: ProgramObject | Values.RegExp | Values.URL;
+    target: SafeObject | Array<unknown> | CodeModeRegExp | CodeModeURL;
     key: PropertyKey;
 };
+export declare class CodeModeFunction {
+    readonly parameters: ReadonlyArray<AstNode>;
+    readonly body: AstNode;
+    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
+    readonly async: boolean;
+    readonly generator: boolean;
+    constructor(parameters: ReadonlyArray<AstNode>, body: AstNode, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+}
 export type GeneratorRequestKind = "next" | "return" | "throw";
 export declare class CodeModeGenerator {
     readonly asynchronous: boolean;
@@ -46,14 +67,51 @@ export declare class ComputedValue {
     readonly value: unknown;
     constructor(value: unknown);
 }
+export declare class PromiseNamespace {
+}
+export declare class SymbolNamespace {
+}
 export declare const AsyncIteratorSymbol: unique symbol;
 export declare const IteratorSymbol: unique symbol;
 export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
+export type PromiseMethodName = "all" | "allSettled" | "race" | "any" | "resolve" | "reject";
+export declare class PromiseMethodReference {
+    readonly name: PromiseMethodName;
+    constructor(name: PromiseMethodName);
+}
 export type PromiseInstanceMethodName = "then" | "catch" | "finally";
 export declare class PromiseInstanceMethodReference {
-    readonly promise: Values.Promise;
+    readonly promise: CodeModePromise;
     readonly name: PromiseInstanceMethodName;
-    constructor(promise: Values.Promise, name: PromiseInstanceMethodName);
+    constructor(promise: CodeModePromise, name: PromiseInstanceMethodName);
+}
+export declare class PromiseCapabilityFunction {
+    readonly settle: (value: unknown) => void;
+    constructor(settle: (value: unknown) => void);
+}
+export type GlobalNamespaceName = "Object" | "Math" | "JSON" | "Array" | "console" | "Date" | "RegExp" | "Map" | "Set" | "URL" | "URLSearchParams";
+export declare class GlobalNamespace {
+    readonly name: GlobalNamespaceName;
+    constructor(name: GlobalNamespaceName);
+}
+export declare class GlobalMethodReference {
+    readonly namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String";
+    readonly name: string;
+    constructor(namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String", name: string);
+}
+export declare class JsonMethodReference {
+    readonly name: "parse" | "stringify";
+    constructor(name: "parse" | "stringify");
+}
+export declare class CoercionFunction {
+    readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
+    constructor(name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN");
+}
+export declare class UriFunction {
+    readonly name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
+    constructor(name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent");
+}
+export declare class SearchFunction {
 }
 export declare class ProgramThrow {
     readonly value: unknown;
@@ -63,7 +121,13 @@ export declare class GeneratorReturn {
     readonly value: unknown;
     constructor(value: unknown);
 }
+export declare class ErrorConstructorReference {
+    readonly name: string;
+    constructor(name: string);
+}
+export type DiagnosticKind = "ParseError" | "UnsupportedSyntax" | "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded" | "TimeoutExceeded" | "ToolFailure" | "ExecutionFailure";
 export declare const OptionalShortCircuit: unique symbol;
+export declare const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
 export declare class InterpreterRuntimeError extends Error {
     readonly kind: DiagnosticKind;
     readonly suggestions?: ReadonlyArray<string> | undefined;
@@ -72,9 +136,14 @@ export declare class InterpreterRuntimeError extends Error {
     constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);
     as(errorName: string): this;
 }
-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 asNode: (value: unknown, context: string) => AstNode;
+export declare const getArray: (node: AstNode, key: string) => Array<unknown>;
+export declare const getString: (node: AstNode, key: string) => string;
+export declare const getBoolean: (node: AstNode, key: string) => boolean;
+export declare const getOptionalNode: (node: AstNode, key: string) => AstNode | undefined;
+export declare const getNode: (node: AstNode, key: string) => AstNode;
 export declare const sourceLocation: (node: AstNode) => {
     readonly line: number;
     readonly column: number;

package/dist/interpreter/model.js

@@ -1,3 +1,17 @@
+export class CodeModeFunction {
+    parameters;
+    body;
+    capturedScopes;
+    async;
+    generator;
+    constructor(parameters, body, capturedScopes, async, generator) {
+        this.parameters = parameters;
+        this.body = body;
+        this.capturedScopes = capturedScopes;
+        this.async = async;
+        this.generator = generator;
+    }
+}
 export class CodeModeGenerator {
     asynchronous;
     request;
@@ -28,9 +42,19 @@ export class ComputedValue {
         this.value = value;
     }
 }
+export class PromiseNamespace {
+}
+export class SymbolNamespace {
+}
 export const AsyncIteratorSymbol = Symbol("codemode.async-iterator");
 export const IteratorSymbol = Symbol("codemode.iterator");
 export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol];
+export class PromiseMethodReference {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
 export class PromiseInstanceMethodReference {
     promise;
     name;
@@ -39,6 +63,46 @@ export class PromiseInstanceMethodReference {
         this.name = name;
     }
 }
+export class PromiseCapabilityFunction {
+    settle;
+    constructor(settle) {
+        this.settle = settle;
+    }
+}
+export class GlobalNamespace {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class GlobalMethodReference {
+    namespace;
+    name;
+    constructor(namespace, name) {
+        this.namespace = namespace;
+        this.name = name;
+    }
+}
+export class JsonMethodReference {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class CoercionFunction {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class UriFunction {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class SearchFunction {
+}
 export class ProgramThrow {
     value;
     constructor(value) {
@@ -51,7 +115,14 @@ export class GeneratorReturn {
         this.value = value;
     }
 }
+export class ErrorConstructorReference {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
 export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
+export const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
 export class InterpreterRuntimeError extends Error {
     kind;
     suggestions;
@@ -70,10 +141,39 @@ export class InterpreterRuntimeError extends Error {
         return this;
     }
 }
-// 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]);
 export const isRecord = (value) => typeof value === "object" && value !== null;
+export const asNode = (value, context) => {
+    if (!isRecord(value) || typeof value.type !== "string") {
+        throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`);
+    }
+    return value;
+};
+export const getArray = (node, key) => {
+    const value = node[key];
+    if (!Array.isArray(value))
+        throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node);
+    return value;
+};
+export const getString = (node, key) => {
+    const value = node[key];
+    if (typeof value !== "string")
+        throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node);
+    return value;
+};
+export const getBoolean = (node, key) => {
+    const value = node[key];
+    if (typeof value !== "boolean")
+        throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node);
+    return value;
+};
+export const getOptionalNode = (node, key) => {
+    const value = node[key];
+    if (value === undefined || value === null)
+        return undefined;
+    return asNode(value, key);
+};
+export const getNode = (node, key) => asNode(node[key], key);
 export const sourceLocation = (node) => ({
     line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
     column: Math.max(1, (node.loc?.start.column ?? 4) - 3),

package/dist/interpreter/promises.d.ts

@@ -1,9 +1,9 @@
 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";
+import { type AstNode, InterpreterRuntimeError, PromiseInstanceMethodReference, PromiseMethodReference } from "./model.js";
+import { type CallbackRunner } from "./methods.js";
+import { CodeModePromise } from "../values.js";
+import type { SyncIteratorRunner } from "./iterator.js";
 export declare class PromiseRuntime<R> {
     private readonly scope;
     private readonly active;
@@ -12,20 +12,18 @@ export declare class PromiseRuntime<R> {
     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>>;
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<CodeModePromise, never, R>;
+    markObserved(promise: CodeModePromise): void;
+    await(promise: CodeModePromise): 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;
+export declare const resolvePromiseValue: <R>(runner: CallbackRunner<R>, value: unknown, node: AstNode, own?: {
+    promise?: CodeModePromise;
 }) => 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: CallbackRunner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<CodeModePromise, never, R>;
+export declare const invokePromiseMethod: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, promises: PromiseRuntime<R>, ref: PromiseMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokePromiseInstanceMethod: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, ref: PromiseInstanceMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<CodeModePromise, never, R>;
+export declare const constructPromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, executor: unknown, node: AstNode) => Effect.Effect<CodeModePromise, unknown, R>;

package/dist/interpreter/promises.js

@@ -1,17 +1,10 @@
 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 { CodeModeFunction, InterpreterRuntimeError, ProgramThrow, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, } from "./model.js";
 import { caughtErrorValue, normalizeError } from "./errors.js";
+import { applyCollectionCallback, isSupportedCallback } from "./methods.js";
 import { typeofValue } from "./references.js";
 import { createAggregateErrorValue } from "../stdlib/value.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;
-});
+import { CodeModePromise } from "../values.js";
 // Observation only controls rejection reporting; program completion interrupts all promise work.
 export class PromiseRuntime {
     scope;
@@ -23,20 +16,12 @@ export class PromiseRuntime {
     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);
+                const promise = new CodeModePromise(fiber);
                 this.active.add(promise);
                 this.ids.set(promise, id);
                 fiber.addObserver((exit) => {
@@ -87,19 +72,23 @@ 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 CodeModePromise)
         return runner.settlePromise(value);
-    if (!(value instanceof ProgramObject))
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, "then"))
         return Effect.succeed(value);
-    const then = get(value, "then");
+    const then = 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 resolve = new PromiseCapabilityFunction((result) => {
+            Deferred.doneUnsafe(deferred, Exit.succeed(result));
+        });
+        const reject = new PromiseCapabilityFunction((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))
@@ -110,22 +99,25 @@ export const resolvePromiseValue = (runner, value, node, own) => {
     });
 };
 export const resolvePromise = (runner, promises, value, node) => {
-    if (value instanceof Values.Promise)
+    if (value instanceof CodeModePromise)
         return Effect.succeed(value);
-    return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
+    const box = {};
+    return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {
+        box.promise = promise;
+        return promise;
+    });
 };
-const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
-const invokePromiseMethod = (runner, promises, name, args, node) => {
-    if (name === "resolve") {
+export const invokePromiseMethod = (runner, promises, ref, args, node) => {
+    if (ref.name === "resolve") {
         return resolvePromise(runner, promises, args[0], node);
     }
-    if (name === "reject") {
+    if (ref.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).as("TypeError");
+            throw new InterpreterRuntimeError(`Promise.${ref.name} expects an array or other synchronous iterable.`, node).as("TypeError");
         }
         const items = [];
         while (true) {
@@ -136,25 +128,28 @@ const invokePromiseMethod = (runner, promises, name, args, 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 (ref.name === "all") {
+            return yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" }));
         }
-        if (name === "allSettled") {
+        if (ref.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(Object.assign(Object.create(null), { status: "fulfilled", value: exit.value }));
                     continue;
                 }
                 if (Cause.hasInterruptsOnly(exit.cause))
                     return yield* Effect.failCause(exit.cause);
-                outcomes.push(record({ status: "rejected", reason: caughtErrorValue(Cause.squash(exit.cause)) }));
+                outcomes.push(Object.assign(Object.create(null), {
+                    status: "rejected",
+                    reason: caughtErrorValue(Cause.squash(exit.cause)),
+                }));
             }
             yield* Effect.yieldNow;
-            return new ProgramArray(outcomes);
+            return outcomes;
         }
-        if (name === "race") {
+        if (ref.name === "race") {
             if (items.length === 0) {
                 throw new InterpreterRuntimeError("Promise.race([]) would never settle; provide at least one promise or value.", node);
             }
@@ -180,15 +175,21 @@ export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) =
     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)) {
+export const constructPromise = (runner, promises, executor, node) => {
+    if (!(executor instanceof CodeModeFunction)) {
         throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node).as("TypeError");
     }
     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 box = {};
+        const promise = yield* promises.create(Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, box)));
+        box.promise = promise;
+        const resolve = new PromiseCapabilityFunction((value) => {
+            Deferred.doneUnsafe(deferred, Exit.succeed(value));
+        });
+        const reject = new PromiseCapabilityFunction((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))
@@ -223,15 +224,20 @@ const reactionExit = (promises, source) => Effect.gen(function* () {
     return exit;
 });
 const chainReaction = (runner, promises, source, onFulfilled, onRejected, method, node) => {
-    return promises.createWithSelf((self) => Effect.gen(function* () {
+    const box = {};
+    const body = 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(Cause.squash(exit.cause));
         const result = yield* applyCollectionCallback(runner, handler, method, node)([input]);
-        return yield* resolvePromiseValue(runner, result, node, self);
-    }));
+        return yield* resolvePromiseValue(runner, result, node, box);
+    });
+    return Effect.map(promises.create(body), (derived) => {
+        box.promise = derived;
+        return derived;
+    });
 };
 const chainFinally = (runner, promises, source, cleanup, method, node) => promises.create(Effect.gen(function* () {
     const exit = yield* reactionExit(promises, source);
@@ -245,27 +251,3 @@ 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({
-        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);
-        },
-    });
-};

package/dist/interpreter/references.d.ts

@@ -3,5 +3,4 @@ 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 describeValue: (value: unknown) => string;
 export declare const typeofValue: (value: unknown) => string;